Arrays类
java.util.Arrays
| 返回类型 | 方法 | 描述 |
|---|---|---|
| static <T> List<T> | asList(T… a) | 返回由指定数组支持的固定大小的列表。 |
| static int | binarySearch(byte[] a, byte key) | 使用二进制搜索算法在指定的字节数组中搜索指定的值。 |
| static int | binarySearch(byte[] a, int fromIndex, int toIndex, byte key) | 使用二进制搜索算法搜索指定值的指定字节数组的范围。 |
| static int | binarySearch(char[] a, char key) | 使用二进制搜索算法在指定的字符数组中搜索指定的值。 |
| static int | binarySearch(char[] a, int fromIndex, int toIndex, char key) | 使用二进制搜索算法搜索指定值的指定数组的范围。 |
| static int | binarySearch(double[] a, double key) | 使用二进制搜索算法在指定的双精度数组中搜索指定的值。 |
| static int | binarySearch(double[] a, int fromIndex, int toIndex, double key) | 使用二进制搜索算法搜索指定值的指定数组的范围。 |
| static int | binarySearch(float[] a, float key) | 使用二进制搜索算法在指定的浮点数组中搜索指定的值。 |
| static int | binarySearch(float[] a, int fromIndex, int toIndex, float key) | 使用二进制搜索算法搜索指定值的指定浮点数范围。 |
| static int | binarySearch(int[] a, int key) | 使用二进制搜索算法在指定的int数组中搜索指定的值。 |
| static int | binarySearch(int[] a, int fromIndex, int toIndex, int key) | 使用二进制搜索算法搜索指定值的指定数组的范围。 |
| static int | binarySearch(long[] a, int fromIndex, int toIndex, long key) | 使用二进制搜索算法搜索指定值的指定数组的范围。 |
| static int | binarySearch(long[] a, long key) | 使用二进制搜索算法在指定的long数组中搜索指定的值。 |
| static int | binarySearch(short[] a, int fromIndex, int toIndex, short key) | 使用二进制搜索算法搜索指定值的指定数组的范围。 |
| static int | binarySearch(short[] a, short key) | 使用二进制搜索算法在指定的short数组中搜索指定的值。 |
| static int | binarySearch(Object[] a, int fromIndex, int toIndex, Object key) | 使用二进制搜索算法搜索指定对象的指定数组范围。 |
| static int | binarySearch(Object[] a, Object key) | 使用二进制搜索算法在指定的数组中搜索指定的对象。 |
| static <T> int | binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) | 使用二进制搜索算法搜索指定对象的指定数组范围。 |
| static <T> int | binarySearch(T[] a, T key, Comparator<? super T> c) | 使用二进制搜索算法在指定的数组中搜索指定的对象。 |
| static int | compare(boolean[] a, boolean[] b) | boolean字典顺序比较两个boolean阵列。 |
| static int | compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个boolean阵列。 |
| static int | compare(byte[] a, byte[] b) | byte字典顺序比较两个byte阵列。 |
| static int | compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个byte阵列。 |
| static int | compare(char[] a, char[] b) | char字典顺序比较两个char阵列。 |
| static int | compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个char阵列。 |
| static int | compare(double[] a, double[] b) | double字典顺序比较两个double阵列。 |
| static int | compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个double阵列。 |
| static int | compare(float[] a, float[] b) | float字典顺序比较两个float阵列。 |
| static int | compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个float阵列。 |
| static int | compare(int[] a, int[] b) | int字典顺序比较两个int阵列。 |
| static int | compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个int阵列。 |
| static int | compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个long阵列。 |
| static int | compare(long[] a, long[] b) | long字典顺序比较两个long阵列。 |
| static int | compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个short阵列。 |
| static int | compare(short[] a, short[] b) | short字典顺序比较两个short阵列。 |
| static <T extends Comparable<? super T>>int | compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个Object阵列。 |
| static <T> int | compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 在指定范围内按字典顺序比较两个Object阵列。 |
| static <T extends Comparable<? super T>>int | compare(T[] a, T[] b) | 按Object顺序比较两个Object阵列，在可比元素中。 |
| static <T> int | compare(T[] a, T[] b, Comparator<? super T> cmp) | 使用指定的比较器按字典顺序比较两个Object阵列。 |
| static int | compareUnsigned(byte[] a, byte[] b) | byte字典顺序比较两个byte阵列，数字处理元素为无符号。 |
| static int | compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个byte阵列，将元素数字处理为无符号。 |
| static int | compareUnsigned(int[] a, int[] b) | int字典顺序比较两个int阵列，数字处理元素为无符号。 |
| static int | compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个int数组，将数字按数字处理为无符号。 |
| static int | compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个long阵列，将元素数字处理为无符号。 |
| static int | compareUnsigned(long[] a, long[] b) | long字典顺序比较两个long阵列，数字处理元素为无符号。 |
| static int | compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 在指定范围内按字典顺序比较两个short阵列，将元素数字处理为无符号。 |
| static int | compareUnsigned(short[] a, short[] b) | short字典顺序比较两个short阵列，数字处理元素为无符号。 |
| static boolean[] | copyOf(boolean[] original, int newLength) | 使用false （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。 |
| static byte[] | copyOf(byte[] original, int newLength) | 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static char[] | copyOf(char[] original, int newLength) | 使用空字符复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static double[] | copyOf(double[] original, int newLength) | 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static float[] | copyOf(float[] original, int newLength) | 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static int[] | copyOf(int[] original, int newLength) | 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static long[] | copyOf(long[] original, int newLength) | 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static short[] | copyOf(short[] original, int newLength) | 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static <T> T[] | copyOf(T[] original, int newLength) | 使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static <T,U>T[] | copyOf(U[] original, int newLength, 类<? extends T[]> newType) | 使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 |
| static boolean[] | copyOfRange(boolean[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static byte[] | copyOfRange(byte[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static char[] | copyOfRange(char[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static double[] | copyOfRange(double[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static float[] | copyOfRange(float[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static int[] | copyOfRange(int[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static long[] | copyOfRange(long[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static short[] | copyOfRange(short[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static <T> T[] | copyOfRange(T[] original, int from, int to) | 将指定数组的指定范围复制到新数组中。 |
| static <T,U>T[] | copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType) | 将指定数组的指定范围复制到新数组中。 |
| static boolean | deepEquals(Object[] a1, Object[] a2) | 如果两个指定的数组彼此深度相等 ，则返回true 。 |
| static int | deepHashCode(Object[] a) | 返回基于指定数组的“深层内容”的哈希码。 |
| static String | deepToString(Object[] a) | 返回指定数组的“深层内容”的字符串表示形式。 |
| static boolean | equals(boolean[] a, boolean[] a2) | 如果两个指定的布尔数组彼此相等 ，则返回true 。 |
| static boolean | equals(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex) | 如果两个指定的布尔数组在指定范围内彼此相等 ，则返回true。 |
| static boolean | equals(byte[] a, byte[] a2) | 如果两个指定的字节数组彼此相等 ，则返回true 。 |
| static boolean | equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 如果指定范围内的两个指定字节数彼此相等 ，则返回true。 |
| static boolean | equals(char[] a, char[] a2) | 如果两个指定的字符数组彼此相等* ，则返回true 。 |
| static boolean | equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) | 如果两个指定的chars数组在指定范围内彼此相等 ，则返回true。 |
| static boolean | equals(double[] a, double[] a2) | 如果两个指定的双精度数组彼此相等 ，则返回true 。 |
| static boolean | equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex) | 如果指定范围内的两个指定的双精度数组彼此相等 ，则返回true。 |
| static boolean | equals(float[] a, float[] a2) | 如果两个指定的浮点数组彼此相等 ，则返回true 。 |
| static boolean | equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex) | 如果两个指定的浮点数组在指定范围内彼此相等 ，则返回true。 |
| static boolean | equals(int[] a, int[] a2) | 如果两个指定的int数组彼此相等 ，则返回true 。 |
| static boolean | equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 如果指定范围内的两个指定的int数组彼此相等 ，则返回true。 |
| static boolean | equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 如果指定范围内的两个指定long数组彼此相等 ，则返回true。 |
| static boolean | equals(long[] a, long[] a2) | 如果两个指定的long数组彼此相等 ，则返回true 。 |
| static boolean | equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 如果超过指定范围的两个指定的short数组彼此相等* ，则返回true。 |
| static boolean | equals(short[] a, short[] a2) | 如果两个指定的short数组彼此相等 ，则返回true 。 |
| static boolean | equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex) | 如果在指定范围内指定的两个Object数组彼此相等 ，则返回true。 |
| static boolean | equals(Object[] a, Object[] a2) | 如果两个指定的Objects数组彼此相等 ，则返回true 。 |
| static <T> boolean | equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 如果在指定范围内指定的两个Object数组彼此相等 ，则返回true。 |
| static <T> boolean | equals(T[] a, T[] a2, Comparator<? super T> cmp) | 如果两个指定的Objects数组彼此相等 ，则返回true 。 |
| static void | fill(boolean[] a, boolean val) | 将指定的布尔值分配给指定的布尔数组的每个元素。 |
| static void | fill(boolean[] a, int fromIndex, int toIndex, boolean val) | 将指定的布尔值分配给指定的布尔数组的指定范围的每个元素。 |
| static void | fill(byte[] a, byte val) | 将指定的字节值分配给指定字节数组的每个元素。 |
| static void | fill(byte[] a, int fromIndex, int toIndex, byte val) | 将指定的字节值分配给指定字节数组的指定范围的每个元素。 |
| static void | fill(char[] a, char val) | 将指定的char值分配给指定的chars数组的每个元素。 |
| static void | fill(char[] a, int fromIndex, int toIndex, char val) | 将指定的char值分配给指定的chars数组的指定范围的每个元素。 |
| static void | fill(double[] a, double val) | 将指定的double值分配给指定的double数组的每个元素。 |
| static void | fill(double[] a, int fromIndex, int toIndex, double val) | 将指定的double值分配给指定的double数组的指定范围的每个元素。 |
| static void | fill(float[] a, float val) | 将指定的float值分配给指定浮点数组的每个元素。 |
| static void | fill(float[] a, int fromIndex, int toIndex, float val) | 将指定的float值分配给指定浮点数组的指定范围的每个元素。 |
| static void | fill(int[] a, int val) | 将指定的int值分配给指定的int数组的每个元素。 |
| static void | fill(int[] a, int fromIndex, int toIndex, int val) | 将指定的int值分配给指定的int数组的指定范围的每个元素。 |
| static void | fill(long[] a, int fromIndex, int toIndex, long val) | 将指定的long值分配给指定long数组的指定范围的每个元素。 |
| static void | fill(long[] a, long val) | 将指定的long值分配给指定longs数组的每个元素。 |
| static void | fill(short[] a, int fromIndex, int toIndex, short val) | 将指定的short值分配给指定short类数组的指定范围的每个元素。 |
| static void | fill(short[] a, short val) | 为指定的short数组的每个元素指定指定的short值。 |
| static void | fill(Object[] a, int fromIndex, int toIndex, Object val) | 将指定的Object引用分配给指定Object对象的指定范围的每个元素。 |
| static void | fill(Object[] a, Object val) | 将指定的Object引用分配给指定的Objects数组的每个元素。 |
| static int | hashCode(boolean[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(byte[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(char[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(double[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(float[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(int[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(long[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(short[] a) | 根据指定数组的内容返回哈希码。 |
| static int | hashCode(Object[] a) | 根据指定数组的内容返回哈希码。 |
| static int | mismatch(boolean[] a, boolean[] b) | 查找并返回两个boolean数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个boolean数组之间第一个不匹配的相对索引，否则返回-1（如果未找到不匹配）。 |
| static int | mismatch(byte[] a, byte[] b) | 查找并返回两个byte数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个byte数组之间第一个不匹配的相对索引，否则返回-1（如果未找到不匹配）。 |
| static int | mismatch(char[] a, char[] b) | 查找并返回两个char数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个char数组之间第一个不匹配的相对索引，否则返回-1（如果未找到不匹配）。 |
| static int | mismatch(double[] a, double[] b) | 查找并返回两个double数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个double数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(float[] a, float[] b) | 查找并返回两个float数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个float数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(int[] a, int[] b) | 查找并返回两个int数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个int数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个long数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(long[] a, long[] b) | 查找并返回两个long数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个short数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(short[] a, short[] b) | 查找并返回两个short数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex) | 查找并返回指定范围内两个Object数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。 |
| static int | mismatch(Object[] a, Object[] b) | 查找并返回两个Object数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static <T> int | mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 查找并返回指定范围内两个Object数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。 |
| static <T> int | mismatch(T[] a, T[] b, Comparator<? super T> cmp) | 查找并返回两个Object数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。 |
| static void | parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op) | 对于给定的数组子范围执行parallelPrefix(double[], DoubleBinaryOperator) 。 |
| static void | parallelPrefix(double[] array, DoubleBinaryOperator op) | 使用提供的函数并行地累积给定数组的每个元素。 |
| static void | parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op) | 对于给定的数组子范围执行parallelPrefix(int[], IntBinaryOperator)。 |
| static void | parallelPrefix(int[] array, IntBinaryOperator op) | 使用提供的函数并行地累积给定数组的每个元素。 |
| static void | parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op) | 对于给定的数组子范围执行parallelPrefix(long[], LongBinaryOperator) 。 |
| static void | parallelPrefix(long[] array, LongBinaryOperator op) | 使用提供的函数并行地累积给定数组的每个元素。 |
| static <T> void | parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op) | 对于给定的数组子范围执行 [parallelPrefix(Object[], BinaryOperator)。 |
| static <T> void | parallelPrefix(T[] array, BinaryOperator<T> op) | 使用提供的函数并行地累积给定数组的每个元素。 |
| static void | parallelSetAll(double[] array, IntToDoubleFunction generator) | 使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。 |
| static void | parallelSetAll(int[] array, IntUnaryOperator generator) | 使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。 |
| static void | parallelSetAll(long[] array, IntToLongFunction generator) | 使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。 |
| static <T> void | parallelSetAll(T[] array, IntFunction<? extends T> generator) | 使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素。 |
| static void | parallelSort(byte[] a) | 将指定的数组按升序排序。 |
| static void | parallelSort(byte[] a, int fromIndex, int toIndex) | 将指定的数组范围按数字升序排序。 |
| static void | parallelSort(char[] a) | 将指定的数组按升序排序。 |
| static void | parallelSort(char[] a, int fromIndex, int toIndex) | 将指定的数组范围按数字升序排序。 |
| static void | parallelSort(double[] a) | 将指定的数组按升序排序。 |
| static void | parallelSort(double[] a, int fromIndex, int toIndex) | 将指定的数组范围按数字升序排序。 |
| static void | parallelSort(float[] a) | 将指定的数组按升序排序。 |
| static void | parallelSort(float[] a, int fromIndex, int toIndex) | 将指定的数组范围按数字升序排序。 |
| static void | parallelSort(int[] a) | 将指定的数组按升序排序。 |
| static void | parallelSort(int[] a, int fromIndex, int toIndex) | 将指定的数组范围按数字升序排序。 |
| static void | parallelSort(long[] a) | 将指定的数组按升序排序。 |
| static void | parallelSort(long[] a, int fromIndex, int toIndex) | 将指定的数组范围按数字升序排序。 |
| static void | parallelSort(short[] a) | 将指定的数组按升序排序。 |
| static void | parallelSort(short[] a, int fromIndex, int toIndex) | 将指定的数组范围按数字升序排序。 |
| static <T extends Comparable<? super T>>void | parallelSort(T[] a) | 根据元素的natural ordering对指定的对象数组按升序排序。 |
| static <T extends Comparable<? super T>>void | parallelSort(T[] a, int fromIndex, int toIndex) | 根据元素的natural ordering，将指定对象数组的指定范围按升序排序。 |
| static <T> void | parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp) | 根据指定比较器引发的顺序对指定对象数组的指定范围进行排序。 |
| static <T> void | parallelSort(T[] a, Comparator<? super T> cmp) | 根据指定比较器引发的顺序对指定的对象数组进行排序。 |
| static void | setAll(double[] array, IntToDoubleFunction generator) | 使用提供的生成器函数设置指定数组的所有元素以计算每个元素。 |
| static void | setAll(int[] array, IntUnaryOperator generator) | 使用提供的生成器函数设置指定数组的所有元素以计算每个元素。 |
| static void | setAll(long[] array, IntToLongFunction generator) | 使用提供的生成器函数设置指定数组的所有元素以计算每个元素。 |
| static <T> void | setAll(T[] array, IntFunction<? extends T> generator) | 使用提供的生成器函数设置指定数组的所有元素以计算每个元素。 |
| static void | sort(byte[] a) | 将指定的数组按升序排序。 |
| static void | sort(byte[] a, int fromIndex, int toIndex) | 按升序对数组的指定范围进行排序。 |
| static void | sort(char[] a) | 将指定的数组按升序排序。 |
| static void | sort(char[] a, int fromIndex, int toIndex) | 按升序对数组的指定范围进行排序。 |
| static void | sort(double[] a) | 将指定的数组按升序排序。 |
| static void | sort(double[] a, int fromIndex, int toIndex) | 按升序对数组的指定范围进行排序。 |
| static void | sort(float[] a) | 将指定的数组按升序排序。 |
| static void | sort(float[] a, int fromIndex, int toIndex) | 按升序对数组的指定范围进行排序。 |
| static void | sort(int[] a) | 将指定的数组按升序排序。 |
| static void | sort(int[] a, int fromIndex, int toIndex) | 按升序对数组的指定范围进行排序。 |
| static void | sort(long[] a) | 将指定的数组按升序排序。 |
| static void | sort(long[] a, int fromIndex, int toIndex) | 按升序对数组的指定范围进行排序。 |
| static void | sort(short[] a) | 将指定的数组按升序排序。 |
| static void | sort(short[] a, int fromIndex, int toIndex) | 按升序对数组的指定范围进行排序。 |
| static void | sort(Object[] a) | 根据元素的natural ordering，将指定的对象数组按升序排序。 |
| static void | sort(Object[] a, int fromIndex, int toIndex) | 根据元素的natural ordering，将指定对象数组的指定范围按升序排序。 |
| static <T> void | sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) | 根据指定比较器引发的顺序对指定对象数组的指定范围进行排序。 |
| static <T> void | sort(T[] a, Comparator<? super T> c) | 根据指定比较器引发的顺序对指定的对象数组进行排序。 |
| static Spliterator.OfDouble | spliterator(double[] array) | 返回覆盖所有指定数组的Spliterator.OfDouble。 |
| static Spliterator.OfDouble | spliterator(double[] array, int startInclusive, int endExclusive) | 返回覆盖指定数组的指定范围的Spliterator.OfDouble。 |
| static Spliterator.OfInt | spliterator(int[] array) | 返回覆盖所有指定数组的Spliterator.OfInt。 |
| static Spliterator.OfInt | spliterator(int[] array, int startInclusive, int endExclusive) | 返回覆盖指定数组的指定范围的Spliterator.OfInt。 |
| static Spliterator.OfLong | spliterator(long[] array) | 返回覆盖所有指定数组的Spliterator.OfLong。 |
| static Spliterator.OfLong | spliterator(long[] array, int startInclusive, int endExclusive) | 返回覆盖指定数组的指定范围的Spliterator.OfLong。 |
| static <T> Spliterator<T> | spliterator(T[] array) | 返回覆盖所有指定数组的Spliterator。 |
| static <T> Spliterator<T> | spliterator(T[] array, int startInclusive, int endExclusive) | 返回覆盖指定数组的指定范围的Spliterator。 |
| static DoubleStream | stream(double[] array) | 返回以指定数组作为源的顺序DoubleStream。 |
| static DoubleStream | stream(double[] array, int startInclusive, int endExclusive) | 返回指定数组的指定范围作为其源的顺序DoubleStream。 |
| static IntStream | stream(int[] array) | 返回以指定数组作为源的顺序IntStream 。 |
| static IntStream | stream(int[] array, int startInclusive, int endExclusive) | 返回指定数组的指定范围作为其源的顺序IntStream。 |
| static LongStream | stream(long[] array) | 返回以指定数组作为源的顺序LongStream。 |
| static LongStream | stream(long[] array, int startInclusive, int endExclusive) | 返回指定数组的指定范围作为其源的顺序LongStream 。 |
| static <T> Stream<T> | stream(T[] array) | 返回以指定数组作为源的顺序Stream。 |
| static <T> Stream<T> | stream(T[] array, int startInclusive, int endExclusive) | 返回指定数组的指定范围作为其源的顺序Stream。 |
| static String | toString(boolean[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(byte[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(char[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(double[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(float[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(int[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(long[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(short[] a) | 返回指定数组内容的字符串表示形式。 |
| static String | toString(Object[] a) | 返回指定数组内容的字符串表示形式。 |
ArrayList类
java.util.ArrayList
| 返回类型 | 方法 | 描述 |
|---|---|---|
| void | add(int index, E element) | 将指定元素插入此列表中的指定位置。 |
| boolean | add(E e) | 将指定的元素追加到此列表的末尾。 |
| boolean | addAll(int index, Collection<? extends E> c) | 从指定位置开始，将指定集合中的所有元素插入此列表。 |
| boolean | addAll(Collection<? extends E> c) | 将指定集合中的所有元素按指定集合的Iterator返回的顺序附加到此列表的末尾。 |
| void | clear() | 从此列表中删除所有元素。 |
| Object | clone() | 返回此ArrayList实例的浅表副本。 |
| boolean | contains(Object o) | 如果此列表包含指定的元素，则返回true 。 |
| void | ensureCapacity(int minCapacity) | 如有必要，增加此ArrayList实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。 |
| void | forEach(Consumer<? super E> action) | 对Iterable每个元素执行给定操作，直到处理Iterable所有元素或操作引发异常。 |
| E | get(int index) | 返回此列表中指定位置的元素。 |
| int | indexOf(Object o) | 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。 |
| boolean | isEmpty() | 如果此列表不包含任何元素，则返回true 。 |
| Iterator<E> | iterator() | 以适当的顺序返回此列表中元素的迭代器。 |
| int | lastIndexOf(Object o) | 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。 |
| ListIterator<E> | listIterator() | 返回此列表中元素的列表迭代器（按适当顺序）。 |
| ListIterator<E> | listIterator(int index) | 从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。 |
| E | remove(int index) | 删除此列表中指定位置的元素。 |
| boolean | remove(Object o) | 从该列表中删除指定元素的第一个匹配项（如果存在）。 |
| boolean | removeAll(Collection<?> c) | 从此列表中删除指定集合中包含的所有元素。 |
| boolean | removeIf(Predicate<? super E> filter) | 删除此集合中满足给定谓词的所有元素。 |
| protected void | removeRange(int fromIndex, int toIndex) | 从此列表中删除索引介于fromIndex （含）和toIndex （独占）之间的所有元素。 |
| boolean | retainAll(Collection<?> c) | 仅保留此列表中包含在指定集合中的元素。 |
| E | set(int index, E element) | 用指定的元素替换此列表中指定位置的元素。 |
| int | size() | 返回此列表中的元素数。 |
| Spliterator<E> | spliterator() | 在此列表中的元素上创建late-binding和故障快速 Spliterator。 |
| List<E> | subList(int fromIndex, int toIndex) | 返回指定的fromIndex （包含）和toIndex （不包括）之间的此列表部分的视图。 |
| Object[] | toArray() | 以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。 |
| <T> T[] | toArray(T[] a) | 以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）;返回数组的运行时类型是指定数组的运行时类型。 |
| void | trimToSize() | 将此ArrayList实例的容量调整为列表的当前大小。 |
HashMap类
java.util.HashMap<K,V>
| 返回类型 | 方法 | 描述 |
|---|---|---|
| void | clear() | 从此映射中删除所有映射。 |
| Object | clone() | 返回此HashMap实例的浅表副本：未克隆键和值本身。 |
| V | compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) | 尝试计算指定键及其当前映射值的映射（如果没有当前映射，null ）。 |
| V | computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) | 如果指定的键尚未与值关联（或映射到null ），则尝试使用给定的映射函数计算其值并将其输入此映射，除非null 。 |
| V | computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) | 如果指定键的值存在且为非null，则尝试在给定键及其当前映射值的情况下计算新映射。 |
| boolean | containsKey(Object key) | 如果此映射包含指定键的映射，则返回true 。 |
| boolean | containsValue(Object value) | 如果此映射将一个或多个键映射到指定值，则返回true 。 |
| Set<Map.Entry<K,V>> | entrySet() | 返回此映射中包含的映射的Set视图。 |
| V | get(Object key) | 返回指定键映射到的值，如果此映射不包含键的映射，则返回null 。 |
| boolean | isEmpty() | 如果此映射不包含键 - 值映射，则返回true 。 |
| Set<K> | keySet() | 返回此映射中包含的键的Set视图。 |
| V | merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) | 如果指定的键尚未与值关联或与null关联，则将其与给定的非空值关联。 |
| V | put(K key, V value) | 将指定的值与此映射中的指定键相关联。 |
| void | putAll(Map<? extends K,? extends V> m) | 将指定映射中的所有映射复制到此映射。 |
| V | remove(Object key) | 从此映射中删除指定键的映射（如果存在）。 |
| int | size() | 返回此映射中键 - 值映射的数量。 |
| Collection<V> | values() | 返回此映射中包含的值的Collection视图。 |
HashSet类
java.util.HashSet<E>
| 返回类型 | 方法 | 描述 |
|---|---|---|
| boolean | add(E e) | 如果指定的元素尚不存在，则将其添加到此集合中。 |
| void | clear() | 从该集中删除所有元素。 |
| Object | clone() | 返回此HashSet实例的浅表副本：未克隆元素本身。 |
| boolean | contains(Object o) | 如果此set包含指定的元素，则返回true 。 |
| boolean | isEmpty() | 如果此集合不包含任何元素，则返回true 。 |
| Iterator<E> | iterator() | 返回此set中元素的迭代器。 |
| boolean | remove(Object o) | 如果存在，则从该集合中移除指定的元素。 |
| int | size() | 返回此集合中的元素数（基数）。 |
| Spliterator<E> | spliterator() | 在此集合中的元素上创建late-binding和失败快速 Spliterator 。 |
Math类
java.lang.Math
| 返回类型 | 方法 | 描述 |
|---|---|---|
| static double | abs(double a) | 返回double值的绝对值。 |
| static float | abs(float a) | 返回float值的绝对值。 |
| static int | abs(int a) | 返回int值的绝对值。 |
| static long | abs(long a) | 返回long值的绝对值。 |
| static double | acos(double a) | 返回值的反余弦值;返回的角度在0.0到 pi 的范围内。 |
| static int | addExact(int x, int y) | 返回其参数的总和，如果结果溢出int则抛出异常。 |
| static long | addExact(long x, long y) | 返回其参数的总和，如果结果溢出long则抛出异常。 |
| static double | asin(double a) | 返回值的反正弦值;返回的角度在-pi / 2到pi / 2的范围内。 |
| static double | atan(double a) | 返回值的反正切值;返回的角度在-pi / 2到pi / 2的范围内。 |
| static double | atan2(double y, double x) | 返回从直角坐标（转换角度theta x ，y ）为极坐标*（R，θ-）*。 |
| static double | cbrt(double a) | 返回double值的多维数据集根。 |
| static double | ceil(double a) | 返回大于或等于参数且等于数学整数的最小值（最接近负无穷大)double 。 |
| static double | copySign(double magnitude, double sign) | 返回带有第二个浮点参数符号的第一个浮点参数。 |
| static float | copySign(float magnitude, float sign) | 返回带有第二个浮点参数符号的第一个浮点参数。 |
| static double | cos(double a) | 返回角度的三角余弦值。 |
| static double | cosh(double x) | 返回double值的双曲余弦值。 |
| static int | decrementExact(int a) | 返回参数递减1，如果结果溢出int则抛出异常。 |
| static long | decrementExact(long a) | 返回参数递减1，如果结果溢出long则抛出异常。 |
| static double | exp(double a) | 返回Euler的数字e ，其值double值。 |
| static double | expm1(double x) | 返回e^x -1。 |
| static double | floor(double a) | 返回小于或等于参数且等于数学整数的最大值（最接近正无穷大）double 。 |
| static int | floorDiv(int x, int y) | 返回小于或等于代数商的最大值（最接近正无穷大）int 。 |
| static long | floorDiv(long x, int y) | 返回小于或等于代数商的最大值（最接近正无穷大）long 。 |
| static long | floorDiv(long x, long y) | 返回小于或等于代数商的最大值（最接近正无穷大）long 。 |
| static int | floorMod(int x, int y) | 返回int参数的floor模数。 |
| static int | floorMod(long x, int y) | 返回long和int参数的floor数。 |
| static long | floorMod(long x, long y) | 返回long参数的floor模数。 |
| static double | fma(double a, double b, double c) | 返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的double 。 |
| static float | fma(float a, float b, float c) | 返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的float 。 |
| static int | getExponent(double d) | 返回double表示中使用的无偏指数。 |
| static int | getExponent(float f) | 返回float表示中使用的无偏指数。 |
| static double | hypot(double x, double y) | 返回sqrt（x^2 + y^2 ），没有中间溢出或下溢。 |
| static double | IEEEremainder(double f1, double f2) | 根据IEEE 754标准规定，计算两个参数的余数运算。 |
| static int | incrementExact(int a) | 返回以1递增的参数，如果结果溢出int则抛出异常。 |
| static long | incrementExact(long a) | 返回以1递增的参数，如果结果溢出long则抛出异常。 |
| static double | log(double a) | 返回double值的自然对数（基数e ）。 |
| static double | log10(double a) | 返回double值的基数10对数。 |
| static double | log1p(double x) | 返回参数和的总和的自然对数。 |
| static double | max(double a, double b) | 返回两个double值中较大的double 。 |
| static float | max(float a, float b) | 返回两个float值中较大的float 。 |
| static int | max(int a, int b) | 返回两个int值中较大的int 。 |
| static long | max(long a, long b) | 返回两个long值中较大的long 。 |
| static double | min(double a, double b) | 返回两个double值中较小的double 。 |
| static float | min(float a, float b) | 返回两个float值中较小的float 。 |
| static int | min(int a, int b) | 返回两个int值中较小的int 。 |
| static long | min(long a, long b) | 返回两个long值中较小的long 。 |
| static int | multiplyExact(int x, int y) | 返回参数的乘积，如果结果溢出int则抛出异常。 |
| static long | multiplyExact(long x, int y) | 返回参数的乘积，如果结果溢出long则抛出异常。 |
| static long | multiplyExact(long x, long y) | 返回参数的乘积，如果结果溢出long则抛出异常。 |
| static long | multiplyFull(int x, int y) | 返回参数的确切数学乘积。 |
| static long | multiplyHigh(long x, long y) | 返回long作为两个64位因子的128位乘积的最高64位。 |
| static int | negateExact(int a) | 返回参数的否定，如果结果溢出int则抛出异常。 |
| static long | negateExact(long a) | 返回参数的否定，如果结果溢出long则抛出异常。 |
| static double | nextAfter(double start, double direction) | 返回第二个参数方向上第一个参数旁边的浮点数。 |
| static float | nextAfter(float start, double direction) | 返回第二个参数方向上第一个参数旁边的浮点数。 |
| static double | nextDown(double d) | 返回负无穷大方向上与d相邻的浮点值。 |
| static float | nextDown(float f) | 返回负无穷大方向上与f相邻的浮点值。 |
| static double | nextUp(double d) | 返回正无穷大方向上与d相邻的浮点值。 |
| static float | nextUp(float f) | 返回正无穷大方向上与f相邻的浮点值。 |
| static double | pow(double a, double b) | 返回第一个参数的值，该值是第二个参数的幂。 |
| static double | random() | 返回带有正号的double值，大于或等于0.0且小于1.0 。 |
| static double | rint(double a) | 返回与double值最接近的double值，该值等于数学整数。 |
| static long | round(double a) | 返回与参数最接近的long ，并将关系四舍五入为正无穷大。 |
| static int | round(float a) | 返回与参数最接近的int ，并将关系四舍五入为正无穷大。 |
| static double | scalb(double d, int scaleFactor) | 返回d ×2 ^ scaleFactor舍入，就像通过单个正确舍入的浮点乘以双scaleFactor值集的成员一样。 |
| static float | scalb(float f, int scaleFactor) | 返回f ×2^scaleFactor舍入，就像通过单个正确舍入的浮点乘以浮点值集的成员一样。 |
| static double | signum(double d) | 返回参数的signum函数;如果参数为零，则为零;如果参数大于零，则为1.0;如果参数小于零，则为-1.0。 |
| static float | signum(float f) | 返回参数的signum函数;如果参数为零则为零，如果参数大于零则为1.0f，如果参数小于零则为-1.0f。 |
| static double | sin(double a) | 返回角度的三角正弦值。 |
| static double | sinh(double x) | 返回double值的双曲正弦值。 |
| static double | sqrt(double a) | 返回double值的正确舍入正平方根。 |
| static int | subtractExact(int x, int y) | 返回参数的差异，如果结果溢出int则抛出异常。 |
| static long | subtractExact(long x, long y) | 返回参数的差异，如果结果溢出long则抛出异常。 |
| static double | tan(double a) | 返回角度的三角正切。 |
| static double | tanh(double x) | 返回double值的双曲正切值。 |
| static double | toDegrees(double angrad) | 将以弧度测量的角度转换为以度为单位测量的近似等效角度。 |
| static int | toIntExact(long value) | 返回long参数的值;如果值溢出int则抛出异常。 |
| static double | toRadians(double angdeg) | 将以度为单位测量的角度转换为以弧度为单位测量的近似等效角度。 |
| static double | ulp(double d) | 返回参数的ulp大小。 |
| static float | ulp(float f) | 返回参数的ulp大小。 |
String类
java.lang.String
| 返回类型 | 方法 | 描述 |
|---|---|---|
| char | charAt(int index) | 返回指定索引处的char值。 |
| IntStream | chars() | 返回int的流，将此序列中的char值零扩展。 |
| int | codePointAt(int index) | 返回指定索引处的字符（Unicode代码点）。 |
| int | codePointBefore(int index) | 返回指定索引之前的字符（Unicode代码点）。 |
| int | codePointCount(int beginIndex, int endIndex) | 返回此String的指定文本范围内的Unicode代码点数。 |
| IntStream | codePoints() | 返回此序列中的代码点值流。 |
| int | compareTo(String anotherString) | 按字典顺序比较两个字符串。 |
| int | compareToIgnoreCase(String str) | 按字典顺序比较两个字符串，忽略大小写差异。 |
| String | concat(String str) | 将指定的字符串连接到此字符串的末尾。 |
| boolean | contains(CharSequence s) | 当且仅当此字符串包含指定的char值序列时，才返回true。 |
| boolean | contentEquals(CharSequence cs) | 将此字符串与指定的CharSequence 。 |
| boolean | contentEquals(StringBuffer sb) | 将此字符串与指定的StringBuffer 。 |
| static String | copyValueOf(char[] data) | 相当于valueOf(char[])。 |
| static String | copyValueOf(char[] data, int offset, int count) | 相当于valueOf(char[], int, int)。 |
| boolean | endsWith(String suffix) | 测试此字符串是否以指定的后缀结尾。 |
| boolean | equals(Object anObject) | 将此字符串与指定的对象进行比较。 |
| boolean | equalsIgnoreCase(String anotherString) | 将此String与另一个String比较，忽略了大小写。 |
| static String | format(String format, Object… args) | 使用指定的格式字符串和参数返回格式化字符串。 |
| static String | format(Locale l, String format, Object… args) | 使用指定的语言环境，格式字符串和参数返回格式化的字符串。 |
| byte[] | getBytes() | 使用平台的默认字符集将此String编码为字节序列，将结果存储到新的字节数组中。 |
| byte[] | getBytes(String charsetName) | 使用命名的字符集将此String编码为字节序列，将结果存储到新的字节数组中。 |
| byte[] | getBytes(Charset charset) | 使用给定的charset将此String编码为字节序列，将结果存储到新的字节数组中。 |
| void | getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) | 将此字符串中的字符复制到目标字符数组中。 |
| int | hashCode() | 返回此字符串的哈希码。 |
| int | indexOf(int ch) | 返回指定字符第一次出现的字符串中的索引。 |
| int | indexOf(int ch, int fromIndex) | 返回指定字符第一次出现的此字符串中的索引，从指定索引处开始搜索。 |
| int | indexOf(String str) | 返回指定子字符串第一次出现的字符串中的索引。 |
| int | indexOf(String str, int fromIndex) | 从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。 |
| String | intern() | 返回字符串对象的规范表示。 |
| boolean | isBlank() | 如果字符串为空或仅包含white space代码点，则返回true ，否则false 。 |
| boolean | isEmpty() | 返回true ，当且仅当，length()是0 。 |
| static String | join(CharSequence delimiter, CharSequence… elements) | 返回由CharSequence elements的副本组成的新String，该副本与指定的 delimiter的副本连接在一起。 |
| static String | join(CharSequence delimiter, Iterable<? extends CharSequence> elements) | 返回由String的副本组成的新String ，其中CharSequence elements指定的delimiter的副本。 |
| int | lastIndexOf(int ch) | 返回指定字符最后一次出现的字符串中的索引。 |
| int | lastIndexOf(int ch, int fromIndex) | 返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向后搜索。 |
| int | lastIndexOf(String str) | 返回指定子字符串最后一次出现的字符串中的索引。 |
| int | lastIndexOf(String str, int fromIndex) | 返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。 |
| int | length() | 返回此字符串的长度。 |
| Stream<String> | lines() | 返回从此字符串中提取的行的流，由行终止符分隔。 |
| boolean | matches(String regex) | 判断此字符串是否与给定的regular expression匹配。 |
| int | offsetByCodePoints(int index, int codePointOffset) | 返回此String中的索引，该索引从给定的index偏移codePointOffset代码点。 |
| boolean | regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) | 测试两个字符串区域是否相等。 |
| boolean | regionMatches(int toffset, String other, int ooffset, int len) | 测试两个字符串区域是否相等。 |
| String | repeat(int count) | 返回一个字符串，其值为此字符串的串联重复count次。 |
| String | replace(char oldChar, char newChar) | 返回从替换所有出现的导致一个字符串oldChar在此字符串newChar 。 |
| String | replace(CharSequence target, CharSequence replacement) | 将此字符串中与文字目标序列匹配的每个子字符串替换为指定的文字替换序列。 |
| String | replaceAll(String regex, String replacement) | 将给定替换的给定regular expression匹配的此字符串的每个子字符串替换。 |
| String | replaceFirst(String regex, String replacement) | 将给定替换的给定regular expression匹配的此字符串的第一个子字符串替换。 |
| String[] | split(String regex) | 将此字符串拆分为给定regular expression的匹配项。 |
| String[] | split(String regex, int limit) | 将此字符串拆分为给定regular expression的匹配项 。 |
| boolean | startsWith(String prefix) | 测试此字符串是否以指定的前缀开头。 |
| boolean | startsWith(String prefix, int toffset) | 测试从指定索引开始的此字符串的子字符串是否以指定的前缀开头。 |
| String | strip() | 返回一个字符串，其值为此字符串，并删除了所有前导和尾随white space。 |
| String | stripLeading() | 返回一个字符串，其值为此字符串，并删除了所有前导white space。 |
| String | stripTrailing() | 返回一个字符串，其值为此字符串，并删除所有尾随white space。 |
| CharSequence | subSequence(int beginIndex, int endIndex) | 返回作为此序列的子序列的字符序列。 |
| String | substring(int beginIndex) | 返回一个字符串，该字符串是此字符串的子字符串。 |
| String | substring(int beginIndex, int endIndex) | 返回一个字符串，该字符串是此字符串的子字符串。 |
| char[] | toCharArray() | 将此字符串转换为新的字符数组。 |
| String | toLowerCase() | 使用默认语言环境的规则将此String所有字符转换为小写。 |
| String | toLowerCase(Locale locale) | 使用给定Locale的规则将此String所有字符转换为Locale 。 |
| String | toUpperCase() | 使用默认语言环境的规则将此String所有字符转换为大写。 |
| String | toUpperCase(Locale locale) | 使用给定Locale的规则将此String所有字符转换为大写。 |
| String | trim() | 返回一个字符串，其值为此字符串，删除了所有前导和尾随空格，其中space被定义为其代码点小于或等于’U+0020’ （空格字符）的任何字符。 |
| static String | valueOf(boolean b) | 返回boolean参数的字符串表示形式。 |
| static String | valueOf(char c) | 返回char参数的字符串表示形式。 |
| static String | valueOf(char[] data) | 返回char数组参数的字符串表示形式。 |
| static String | valueOf(char[] data, int offset, int count) | 返回char数组参数的特定子数组的字符串表示形式。 |
| static String | valueOf(double d) | 返回double参数的字符串表示形式。 |
| static String | valueOf(float f) | 返回float参数的字符串表示形式。 |
| static String | valueOf(int i) | 返回int参数的字符串表示形式。 |
| static String | valueOf(long l) | 返回long参数的字符串表示形式。 |
| static String | valueOf(Object obj) | 返回Object参数的字符串表示形式。 |
StringBuilder类
和String类不同的是，StringBuilder类的对象能够被多次修改，且不会产生新的未使用对象
java.lang.StringBuilder
| 返回类型 | 方法 | 描述 |
|---|---|---|
| StringBuilder | append(boolean b) | 将boolean参数的字符串表示形式追加到序列中。 |
| StringBuilder | append(char c) | 将char参数的字符串表示形式追加到此序列。 |
| StringBuilder | append(char[] str) | 将char数组参数的字符串表示形式追加到此序列。 |
| StringBuilder | append(char[] str, int offset, int len) | 将char数组参数的子数组的字符串表示形式追加到此序列。 |
| StringBuilder | append(double d) | 将double参数的字符串表示形式追加到此序列。 |
| StringBuilder | append(float f) | 将float参数的字符串表示形式追加到此序列。 |
| StringBuilder | append(int i) | 将int参数的字符串表示形式追加到此序列。 |
| StringBuilder | append(long lng) | 将long参数的字符串表示形式追加到此序列。 |
| StringBuilder | append(CharSequence s) | 将指定的字符序列追加到此Appendable 。 |
| StringBuilder | append(CharSequence s, int start, int end) | 将指定的CharSequence序列追加到此序列。 |
| StringBuilder | append(Object obj) | 追加Object参数的字符串表示形式。 |
| StringBuilder | append(String str) | 将指定的字符串追加到此字符序列。 |
| StringBuilder | append(StringBuffer sb) | 将指定的StringBuffer追加到此序列。 |
| StringBuilder | appendCodePoint(int codePoint) | 将codePoint参数的字符串表示形式追加到此序列。 |
| int | capacity() | 返回当前容量。 |
| char | charAt(int index) | 返回指定索引处的此序列中的char值。 |
| IntStream | chars() | 返回int的流，对此序列中的char值进行零扩展。 |
| int | codePointAt(int index) | 返回指定索引处的字符（Unicode代码点）。 |
| int | codePointBefore(int index) | 返回指定索引之前的字符（Unicode代码点）。 |
| int | codePointCount(int beginIndex, int endIndex) | 返回此序列的指定文本范围内的Unicode代码点数。 |
| IntStream | codePoints() | 返回此序列中的代码点值流。 |
| int | compareTo(StringBuilder another) | StringBuilder字典顺序比较两个StringBuilder实例。 |
| StringBuilder | delete(int start, int end) | 删除此序列的子字符串中的字符。 |
| StringBuilder | deleteCharAt(int index) | 按此顺序删除指定位置的char 。 |
| void | ensureCapacity(int minimumCapacity) | 确保容量至少等于指定的最小值。 |
| void | getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) | 将字符从此序列复制到目标字符数组dst 。 |
| int | indexOf(String str) | 返回指定子字符串第一次出现的字符串中的索引。 |
| int | indexOf(String str, int fromIndex) | 从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。 |
| StringBuilder | insert(int offset, boolean b) | 将boolean参数的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int offset, char c) | 将char参数的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int offset, char[] str) | 将char数组参数的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int index, char[] str, int offset, int len) | 将str数组参数的子数组的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int offset, double d) | 将double参数的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int offset, float f) | 将float参数的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int offset, int i) | 将第二个int参数的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int offset, long l) | 将long参数的字符串表示形式插入此序列中。 |
| StringBuilder | insert(int dstOffset, CharSequence s) | 将指定的CharSequence插入此序列。 |
| StringBuilder | insert(int dstOffset, CharSequence s, int start, int end) | 将指定的CharSequence序列插入此序列。 |
| StringBuilder | insert(int offset, Object obj) | 将Object参数的字符串表示形式插入此字符序列中。 |
| StringBuilder | insert(int offset, String str) | 将字符串插入此字符序列。 |
| int | lastIndexOf(String str) | 返回指定子字符串最后一次出现的字符串中的索引。 |
| int | lastIndexOf(String str, int fromIndex) | 返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。 |
| int | length() | 返回长度（字符数）。 |
| int | offsetByCodePoints(int index, int codePointOffset) | 返回此序列中的索引，该索引从给定的index偏移codePointOffset代码点。 |
| StringBuilder | replace(int start, int end, String str) | 使用指定的String的字符替换此序列的子字符串中的字符。 |
| StringBuilder | reverse() | 导致此字符序列被序列的反向替换。 |
| void | setCharAt(int index, char ch) | 指定索引处的字符设置为ch 。 |
| void | setLength(int newLength) | 设置字符序列的长度。 |
| CharSequence | subSequence(int start, int end) | 返回一个新的字符序列，它是该序列的子序列。 |
| String | substring(int start) | 返回一个新的String ，其中包含此字符序列中当前包含的字符的子序列。 |
| String | substring(int start, int end) | 返回一个新的String ，其中包含当前包含在此序列中的字符的子序列。 |
| void | trimToSize() | 尝试减少用于字符序列的存储空间。 |
![[免费]基于Python的Django+Vue3在线考试系统【论文+源码+SQL脚本】](https://i-blog.csdnimg.cn/direct/6e930f3dde3c4f2bb9cf4501c8642e1c.jpeg)