Arrays类

1. 概述2. 常见方法3. sort 方法的自定义排序4. 代码示例5. 输出结果6. 注意事项

具体信息请查看 API 帮助文档

1. 概述

Arrays类是Java中的一个工具类，位于java.util包中。

它提供了一组静态方法，用于操作数组。通过Arrays类，我们可以对数组进行复制、填充、排序以及查找等常见操作。

Arrays类的方法主要包括以下几个方面：

数组拷贝：提供了copyOf()和copyOfRange()方法，用于将原数组复制到新数组中，并可以指定拷贝的范围。

数组填充：通过fill()方法，可以将数组中的所有元素填充为指定的值。

数组排序：使用sort()方法，可以对数组进行排序。sort()方法有两个版本，一个是使用默认规则进行排序，另一个是可以指定排序规则。

数组查找：提供了binarySearch()方法，使用二分查找法在数组中查找指定的元素。

2. 常见方法

方法功能public static String toString(数组)将数组拼接成一个字符串public static int binarySearch(数组，查找的元素)使用二分查找法在数组中查找元素public static int[] copyOf(原数组，新数组长度)拷贝数组并指定新数组的长度public static int[] copyOfRange(原数组，起始索引，结束索引)拷贝数组的指定范围到新数组中public static void fill(数组，元素)将数组中的所有元素填充为指定元素public static void sort(数组)使用默认规则对数组进行排序public static void sort(数组，排序规则)使用指定规则对数组进行排序

注意：

public static int binarySearch(数组，查找的元素) ： 二分查找法查找元素

细节1：二分查找的前提：数组中的元素必须是有序的，且数组中的元素必须是升序的

细节2：

如果要查找的元素存在，则返回的是真实的索引值；

如果要查找的元素不存在，则返回的是 -插入点 -1。

-1的原因：如果此时，我们要查找数字0（假如0在数组中并不存在），那么如果返回的值是-插入点，那么则为-0；有的人认为-0等同于0，因此为避免这种情况出现，Java规定如果要查找的元素不存在，则返回的是 -插入点 -1。

public static int[] copyOf(原数组，新数组长度) ：拷贝数组

细节：

当新数组的长度小于原数组的长度时，会部分拷贝原数组的元素

当新数组的长度等于原数组的长度时，会全部拷贝原数组的元素

当新数组的长度大于原数组的长度时，会全部拷贝原数组的元素，剩余位置补上默认初始化（例如，int类型的数组剩余位置补0）

public static int[] copyOfRange(原数组,起始索引,结束索引) : 拷贝数组(指定范围)

细节：

包头不包尾，包左不包右 public static void sort(数组) ：按照默认方式进行排序

细节：

默认情况下，给基本数据类型进行升序操作。底层使用的是快速排序 public static void sort(数组,排序规则) : 按照指定的规则排序

参数一：要排序的数组

参数二：排序的规则

细节：

只能给引用数据类型的数组进行排序，如果数组是基本数据类型的话，需要变成其对应的包装类

第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。

但是这个实现类一般只用使用一次，因此没有必要单独写一个类，直接采用匿名内部类的方法就可以了

底层原理：利用插入排序 + 二分查找的方法进行排序的

默认把 0 索引的数据作为有序序列，1索引及其以后得所有数据都作为无序序列。遍历无序序列，得到里面的每一个元素，把得到的元素往有序序列中插入，在插入时，是利用二分查找的方法确认该元素的插入点，然后拿着该元素与插入点的元素进行比较。（比较的方式与之前不同，该比较的方式是从前往后遍历），比较的规则是compare方法的方法体。

如果方法的返回值是负数，拿着该元素继续跟前面的数据进行比较

如果方法的返回值是正数，拿着该元素继续跟后面的数据进行比较

如果方法的返回值是0，拿着该元素继续跟后面的数据进行比较

直到能确定该元素的位置为止 compare方法的形参参数：

参数一 o1：表示在无序序列中，遍历得到的每一个元素参数二 o2：有序序列中的元素返回值：

负数：表示当前要插入的元素是小的，放前面

正数：表示当前要插入的元素是大的，放后面

0：表示当前要插入的元素跟该位置的元素是一样的，放后面

o1-o2:升序排列

o2-o1:降序排列

3. sort 方法的自定义排序

由于Arrays类是一个final类，无法被继承，因此不允许对sort()方法进行重写。

然而，如果想要实现自定义的排序逻辑，可以通过传递一个实现了Comparator接口的自定义比较器对象来调用sort()方法，这样可以指定排序时使用的比较规则。这种方式并不是重写，而是通过回调方法（Comparator接口中的compare()方法）来实现自定义的排序行为。

当我们调用Arrays.sort()方法时，根据传入的参数不同，会调用不同的重载方法。

public static void sort(T[] a)

功能：用于对传入的数组进行排序。参数：a是要排序的数组，类型为T[]，表示一个指定元素类型的数组。排序规则：默认使用数组元素的自然顺序进行排序。如果数组中的元素是基本数据类型，会使用对应的包装类的自然顺序进行排序。返回值：无。示例：Integer[] numbers = {5, 2, 8, 1, 9};

Arrays.sort(numbers);

// 数组将被排序为：{1, 2, 5, 8, 9}

public static void sort(T[] a, Comparator c)

功能：用于对传入的数组进行排序，使用自定义的排序规则。参数：

a是要排序的数组，类型为T[]，表示一个指定元素类型的数组。c是一个Comparator对象，用于定义元素的比较规则。 排序规则：根据Comparator对象的定义进行排序。返回值：无。示例：String[] names = {"John", "Alice", "Bob", "David"};

Arrays.sort(names, (s1, s2) -> s1.compareToIgnoreCase(s2));

// 数组将被排序为：{"Alice", "Bob", "David", "John"}

4. 代码示例

package text.text02;

import java.util.Arrays;

import java.util.Comparator;

/*

Arrays类：

public static String toString(数组) 把数组拼接成一个字符串

public static int binarySearch(数组，查找的元素) 二分查找法查找元素

细节1：二分查找的前提：数组中的元素必须是有序的，且数组中的元素必须是升序的

细节2：如果要查找的元素存在，则返回的是真实的索引值

如果要查找的元素不存在，则返回的是 -插入点-1

-1的原因：如果此时，我们要查找数字0（假如0在数组中并不存在），那么如果返回的值是-插入点，那么则为-0；有的人认为-0等同于0，因此为避免这种情况出现，Java规定如果要查找的元素不存在，则返回的是 -插入点-1。

public static int[] copyOf(原数组，新数组长度) 拷贝数组

细节：当新数组的长度小于原数组的长度时，会部分拷贝原数组的元素

当新数组的长度等于原数组的长度时，会全部拷贝原数组的元素

当新数组的长度大于原数组的长度时，会全部拷贝原数组的元素，剩余位置补上默认初始化（例如，int类型的数组剩余位置补0）

public static int[] copyOfRange(原数组,起始索引,结束索引) 拷贝数组(指定范围)

细节：包头不包尾，包左不包右

public static void fill(数组,元素) 填充数组

public static void sort(数组) 按照默认方式进行排序

细节：默认情况下，给基本数据类型进行升序操作。底层使用的是快速排序

public static void sort(数组,排序规则) 按照指定的规则排序

参数一：要排序的数组

参数二：排序的规则

细节：只能给引用数据类型的数组进行排序，如果数组是基本数据类型的话，需要变成其对应的包装类

第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。

但是这个实现类一般只用使用一次，因此没有必要单独写一个类，直接采用匿名内部类的方法就可以了

底层原理：利用插入排序 + 二分查找的方法进行排序的

默认把 0 索引的数据作为有序序列，1索引及其以后得所有数据都作为无序序列。

遍历无序序列，得到里面的每一个元素，把得到的元素往有序序列中插入，在插入时，是利用二分查找的方法确认该元素的插入点，然后拿着该元素与插入点的元素进行比较。（比较的方式与之前不同，该比较的方式是从前往后遍历），比较的规则是compare方法的方法体。

如果方法的返回值是负数，拿着该元素继续跟前面的数据进行比较

如果方法的返回值是正数，拿着该元素继续跟后面的数据进行比较

如果方法的返回值是0，拿着该元素继续跟后面的数据进行比较

直到能确定该元素的位置为止

compare方法的形参参数：

参数一 o1：表示在无序序列中，遍历得到的每一个元素

参数二 o2：有序序列中的元素

返回值：

负数：表示当前要插入的元素是小的，放前面

正数：表示当前要插入的元素是大的，放后面

0：表示当前要插入的元素跟该位置的元素是一样的，放后面

o1-o2:升序排列

o2-o1:降序排列

*/

public class text16 {

public static void main(String[] args) {

int[] arr1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] arr2 = {10, 5, 3, 4, 7, 8, 2, 9, 1, 6, 0};

//public static String toString(数组):把数组拼接成一个字符串

System.out.println("=============== toString(数组):把数组拼接成一个字符串 ===============");

String str1 = Arrays.toString(arr1);

System.out.println(str1); //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

System.out.println();

//public static int binarySearch(数组，查找的元素):二分查找法查找元素

//细节1：二分查找的前提：数组中的元素必须是有序的，且数组中的元素必须是升序的

//细节2：如果要查找的元素存在，则返回的是真实的索引值

// 如果要查找的元素不存在，则返回的是 -插入点-1

//-1的原因：如果此时，我们要查找数字0（假如0在数组中并不存在），那么如果返回的值是-插入点，那么则为-0；有的人认为-0等同于0，因此为避免这种情况出现，则Java规定如果要查找的元素不存在，则返回的是 -插入点-1。

System.out.println("=============== binarySearch(数组，查找的元素):二分查找法查找元素 ===============");

int int1 = Arrays.binarySearch(arr1, 5);

int int2 = Arrays.binarySearch(arr1, 10);

int int3 = Arrays.binarySearch(arr1, 15);

System.out.println(int1); //5

System.out.println(int2); //10

System.out.println(int3); //-12

System.out.println();

//public static int[] copyOf(原数组，新数组长度):拷贝数组

//细节：当新数组的长度小于原数组的长度时，会部分拷贝原数组的元素

// 当新数组的长度等于原数组的长度时，会全部拷贝原数组的元素

// 当新数组的长度大于原数组的长度时，会全部拷贝原数组的元素，剩余位置补上默认初始化（例如，int类型的数组剩余位置补0）

System.out.println("=============== copyOf(原数组，新数组长度):拷贝数组 ===============");

int[] int4 = Arrays.copyOf(arr1, 6);

int[] int5 = Arrays.copyOf(arr1, 11);

int[] int6 = Arrays.copyOf(arr1, 20);

System.out.println(Arrays.toString(int4)); //[0, 1, 2, 3, 4, 5]

System.out.println(Arrays.toString(int5)); //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

System.out.println(Arrays.toString(int6)); //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0]

System.out.println();

//public static int[] copyOfRange(原数组,起始索引,结束索引):拷贝数组(指定范围)

//细节：包头不包尾，包左不包右

System.out.println("=============== copyOfRange(原数组,起始索引,结束索引):拷贝数组(指定范围) ===============");

int[] int7 = Arrays.copyOfRange(arr1, 0, 10);

int[] int8 = Arrays.copyOfRange(arr1, 0, 11);

System.out.println(Arrays.toString(int7)); //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

System.out.println(Arrays.toString(int8)); //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

System.out.println();

//public static void fill(数组,元素):填充数组

System.out.println("=============== fill(数组,元素):填充数组 ===============");

Arrays.fill(arr1, 20);

System.out.println(Arrays.toString(arr1)); //[20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]

System.out.println();

//public static void sort(数组):按照默认方式进行排序

//细节：默认情况下，给基本数据类型进行升序操作。底层使用的是快速排序

System.out.println("=============== sort(数组):按照默认方式进行排序 ===============");

Arrays.sort(arr2);

System.out.println(Arrays.toString(arr2)); //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

System.out.println();

//public static void sort(数组,排序规则):按照指定的规则排序

//参数一：要排序的数组

//参数二：排序的规则

//细节：只能给引用数据类型的数组进行排序，如果数组是基本数据类型的话，需要变成其对应的包装类

// 第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。

// 但是这个实现类一般只用使用一次，因此没有必要单独写一个类，直接采用匿名内部类的方法就可以了

//底层原理：利用插入排序 + 二分查找的方法进行排序的

//默认把 0 索引的数据作为有序序列，1索引及其以后得所有数据都作为无序序列。

//遍历无序序列，得到里面的每一个元素，把得到的元素往有序序列中插入，在插入时，是利用二分查找的方法确认该元素的插入点，然后拿着该元素与插入点的元素进行比较。（比较的方式与之前不同，该比较的方式是从前往后遍历），比较的规则是compare方法的方法体。

//如果方法的返回值是负数，拿着该元素继续跟前面的数据进行比较

//如果方法的返回值是正数，拿着该元素继续跟后面的数据进行比较

//如果方法的返回值是0，拿着该元素继续跟后面的数据进行比较

//直到能确定该元素的位置为止

System.out.println("=============== sort(数组,排序规则):按照指定的规则排序 ===============");

Integer[] arr3 = {2, 3, 5, 6, 8, 9, 1, 0, 4, 10, 7};

Arrays.sort(arr3, new Comparator() {

//compare方法的形参参数：

//参数一 o1：表示在无序序列中，遍历得到的每一个元素

//参数二 o2：有序序列中的元素

//返回值：

//负数：表示当前要插入的元素是小的，放前面

//正数：表示当前要插入的元素是大的，放后面

//0：表示当前要插入的元素跟该位置的元素是一样的，放后面

//o1-o2:升序排列

//o2-o1:降序排列

@Override

public int compare(Integer o1, Integer o2) {

return o1 - o2;

}

});

System.out.println("升序排序：" + Arrays.toString(arr3)); //升序排序：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Arrays.sort(arr3, new Comparator() {

//compare方法的形参参数：

//参数一 o1：表示在无序序列中，遍历得到的每一个元素

//参数二 o2：有序序列中的元素

//返回值：

//负数：表示当前要插入的元素是小的，放前面

//正数：表示当前要插入的元素是大的，放后面

//0：表示当前要插入的元素跟该位置的元素是一样的，放后面

//o1-o2:升序排列

//o2-o1:降序排列

@Override

public int compare(Integer o1, Integer o2) {

return o2 - o1;

}

});

System.out.println("降序排序：" + Arrays.toString(arr3)); //降序排序：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

}

}

5. 输出结果

public static String toString(数组):把数组拼接成一个字符串

public static int binarySearch(数组，查找的元素):二分查找法查找元素

public static int[] copyOf(原数组，新数组长度):拷贝数组

public static int[] copyOfRange(原数组,起始索引,结束索引):拷贝数组(指定范围)

public static void fill(数组,元素):填充数组

public static void sort(数组):按照默认方式进行排序

public static void sort(数组,排序规则):按照指定的规则排序

6. 注意事项

Arrays类中的方法都是静态方法，无需实例化对象即可直接调用。

Arrays类的方法通常针对数组进行操作，因此在使用这些方法之前，需要先创建合适的数组对象，并将数据存储在数组中。

使用Arrays.copyOf()或Arrays.copyOfRange()方法时，要确保目标数组的长度足够存储源数组或指定的范围内的元素。否则，可能会出现ArrayIndexOutOfBoundsException错误。

Arrays.toString()和Arrays.deepToString()方法可以将数组转换为字符串，方便打印和调试。但需要注意，这些方法将直接使用数组的toString()方法来获取字符串表示形式，因此自定义的类需要重写toString()方法才能得到正确的输出。

当使用Arrays.sort()方法对数组进行排序时，需要注意数组元素的可比较性。如果数组元素是自定义的类对象，需要确保该类实现了Comparable接口，或者使用重载方法并传入自定义的Comparator对象来指定元素的比较规则。