Java听课笔记5（Arrays工具类）

Arrays工具类

定义：用来操作数组（比如排序和搜索）的各种方法，Arrays类位于 java.util 包中

常用方法：

二分查找
Arrays.binarySearch(Object[] array, Object key)
注意：在调用该方法之前，必须先调用sort()方法进行排序，如果数组没有排序，
那么结果是不确定的，此外如果数组中包含多个指定元素，则无法保证将找到哪个元素
使用 二分法 查找数组内指定元素的索引值
数组内容转换为字符串形式输出，当搜索元素是数组元素，则返回该元素的索引值
如果不是数组元素，则返回 - (索引值 + 1)，具体的用法可以看下面的例子
搜索元素是数组元素，返回该元素索引值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
System.out.println(Arrays.binarySearch(data, 1)); // 0

搜索元素不是数组元素，且小于数组中的最小值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// 此时程序会把数组看作 {0, 1, 3, 5, 7}，此时0的索引值为0，则搜索0时返回 -(0 + 1) = -1
System.out.println(Arrays.binarySearch(data, 0)); // -1

搜索元素不是数组元素，且大于数组中的最大值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// 此时程序会把数组看作 {1, 3, 5, 7， 9}，此时9的索引值为4，则搜索8时返回 -(4 + 1) = -5
System.out.println(Arrays.binarySearch(data, 8)); // -5

搜索元素不是数组元素，但在数组范围内

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// 此时程序会把数组看作 {1, 2, 3, 5, 7}，此时2的索引值为1，则搜索2时返回 -(1 + 1) = -2
System.out.println(Arrays.binarySearch(data, 2)); // -2
Arrays.binarySearch(Object[] array, int fromIndex, int toIndex, Object obj)

使用 二分法 查找数组内指定范围内的指定元素的索引值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// {1, 3}，3的索引值为1
System.out.println(Arrays.binarySearch(data, 0, 2, 3)); // 1

复制指定数组

拷贝数组，其内部调用了 System.arraycopy() 方法，从下标0开始，如果超过原数组长度，会用null进行填充
Arrays.copyOf(int[ ]array,int length);

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOf(data1, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]

Integer[] data2 = Arrays.copyOf(data1, 5);
System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]

拷贝数组，指定起始位置和结束位置，如果超过原数组长度，会用null进行填充
Arrays.copyOf(int[ ]array,int from,int to);

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOfRange(data1, 0, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data2 = Arrays.copyOfRange(data1, 0, 5);
System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]

System.arraycopy(Object src,int srcPos,Object dest,int destPos,int
length)
判断两个数组是否相等

Arrays.equels();

使用指定元素填充数组（会替换掉数组中原来的元素）
Arrays.fill(Object[] array, Object obj);

 Integer[] data = {1, 2, 3, 4};
 Arrays.fill(data, 9);
 System.out.println(Arrays.toString(data)); // [9, 9, 9, 9]

用指定元素填充数组，从起始位置到结束位置，取头不取尾（会替换掉数组中原来的元素）
Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)

Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 0, 2, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 3, 4]

对数组元素进行排序（串行排序）
Arrays.sort(Object[] array)

String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
Arrays.sort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

使用自定义比较器，对数组元素进行排序（串行排序）
Arrays.sort(T[] array, Comparator<? super T> comparator)

String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 实现降序排序，返回-1放左边，1放右边，0保持不变
Arrays.sort(data, (str1, str2) -> {
//注意->需要jdk1.8才能实现
    if (str1.compareTo(str2) > 0) {
        return -1;
    } else {
        return 1;
    }
});
System.out.println(Arrays.toString(data)); // [4, 3, 2, 1]

对数组元素的指定范围进行排序（串行排序）
Arrays.sort(Object[] array, int fromIndex, int toIndex)

String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 对下标[0, 3)的元素进行排序，即对1，4，3进行排序，2保持不变
Arrays.sort(data, 0, 3);
System.out.println(Arrays.toString(data)); // [1, 3, 4, 2]

使用自定义比较器，对数组元素的指定范围进行排序（串行排序）

Arrays.sort(T[] array, int fromIndex, int toIndex, Comparator<? super T> c)
String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 对下标[0, 3)的元素进行降序排序，即对1，4，3进行降序排序，2保持不变
Arrays.sort(data, 0, 3, (str1, str2) -> {
//不许要求jdk1.8才可以
    if (str1.compareTo(str2) > 0) {
        return -1;
    } else {
        return 1;
    }
});
System.out.println(Arrays.toString(data)); // [4, 3, 1, 2]

对数组元素进行排序（并行排序），当数据规模较大时，会有更好的性能
Arrays.parallelSort(T[] array)
注意：其余重载方法与 sort() 相同

String[] data = {"1", "4", "3", "2"};
Arrays.parallelSort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]