Arrays工具类

CAMELLIA2024-05-222024-05-27

!!! note 目录

Arrays工具类

注意：工具类中的方法大部分是静态方法，直接通过类名调用。

一、Arrays.toString

1.1 概念

Arrays.toString()是Java中java.util.Arrays类提供的一个静态方法，用于将数组转换为字符串表示形式。
该方法有多个重载版本，可以处理不同类型的数组，包括原始类型数组（如int[]、double[]等）和对象数组（如String[]、Object[]等）。
Arrays.toString()方法不是通过继承``Object类来实现的。实际上，它是java.util.Arrays`类的静态方法，用于将数组转换为字符串表示形式。

1.2 测试代码

 @Test
    public void testToString(){
        int[] arr = {1,2,3,4,5,6,7,8,9};
//      Object中的toString,println()底层会调用toString。
        System.out.println(arr);

        System.out.println(Arrays.toString(arr));
    }

二、Arrays.deepToString

2.1 概念

Arrays.deepToString()是Java中java.util.Arrays类提供的一个静态方法，用于将多维数组转换为字符串表示形式。
与Arrays.toString()类似，Arrays.deepToString()方法也能够将数组转换为可读的字符串形式，但不同之处在于，它能够处理多维数组，包括嵌套数组。

2.2 测试代码

@Test
  public void testDeepToString(){
      int[][] arr = {
              {1,2,3,4,5,6,7,8,9},
              {11,12,1,31,41,15},
              {1,1,1,1,1}
      };
      System.out.println(Arrays.toString(arr));
      System.out.println(Arrays.deepToString(arr));
  }

三、Arrays.equals

3.1 概念

Arrays.equals()方法在比较两个数组时，会比较它们的内容是否相等。这适用于所有数据类型，包括基本数据类型和对象类型。
需要注意的是，Arrays.equals()方法要求两个数组的长度和每个对应位置的元素都相等才会返回true。

3.2 测试代码

@Test
   public void testEquals(){
       String[] s1={"abc","camellia","huahua"};
       String[] s2={"abc","camellia","huahua"};
       System.out.println(Arrays.equals(s1,s2));
       String[] s3=new String[]{"abc","camellia","huahua"};
       String[] s4=new String[]{"abc","camellia","huahua"};
       System.out.println(Arrays.equals(s3,s4));
   }

四、Arrays.deepEquals

4.1 概念

和Arrays.equals功能相同，只是用来比较多维数组。

4.2 测试代码

@Test
   public void testDeepEquals(){
       String[][] str1={{"a","b"},{"c","d"}};
       String[][] str2={{"a","b"},{"c","d"}};
       System.out.println(Arrays.deepEquals(str1,str2));
   }

五、Arrays.sort

5.1 概念

Arrays.sort 是 Java 提供的用于对数组进行排序的静态方法。
这个方法在 java.util.Arrays 类中定义，支持对各种数据类型的数组进行排序，包括基本数据类型（如 int、char 等）和对象类型（如 String、自定义对象等）。

5.2 基本类型数据&引用类型数据排序

对基本类型数组进行排序
对对象类型数组进行排序
- void sort(Object[] a)
- void sort(T[] a, Comparator<? super T> c)
对数组的某个子范围进行排序
- void sort(基本数据类型, int fromIndex, int toIndex)
- void sort(Object[] a, int fromIndex, int toIndex)
- void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)

5.3 对象类型数组的排序（自定义顺序）

5.3.1 匿名内部类

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        String[] stringArray = {"banana", "apple", "cherry"};
        Arrays.sort(stringArray, new Comparator<String>() {  
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1);  // 按照逆序排序
            }
        });
        System.out.println(Arrays.toString(stringArray));  // 输出: [cherry, banana, apple]
    }
}

注意事项

对于对象类型数组，数组元素必须实现 Comparable 接口或者提供 Comparator 实例，否则会抛出 ClassCastException。

Arrays.sort 是原地排序（in-place），不会产生新的数组，排序过程在原数组上进行。

排序是稳定的（对于 Object[]），即相等的元素在排序后保持它们在原数组中的相对位置。

5.3.2 自定义类

java.lang.ClassCastException: class com.camellia.Arrays.Person 无法强制转换为类 java.lang.Comparable
代码底层一定有：Comparable c1 = (Comparable) p1;这个错误代码表示Person类不是可比较的。
因为p1是Person类实例化的对象，Person和Comparable既没有继承关系也不是实现关系。所以强制类型当然会出错。
解决办法：Person实现Comparable接口中的compareTo方法。

@Test
    public void testCustomSort(){
        Person p1 = new Person("camellia", 20);
        Person p2 = new Person("haha", 23);
        Person p3 = new Person("xiaohua", 21);
        Person p4 = new Person("dujia", 25);
        Person[] arr = {p1,p2,p3,p4};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

Person必须实现Comparable接口

必须重写compareTo方法

1 2	//实现接口 public class Person implements Comparable{}

//重写compareTo方法
 @Override
    public int compareTo(Object o) {
        // 编写比较规则
        Person person = (Person) o; 
        return person.age - this.age;   //降序
    }

注意要强制类型转换
return person.age - this.age; 降序
return this.age-person.age; 升序
String实现了Comparable接口，重写了compareTo方法。所以自定义类中的比较规则是比较字符串可以如下比较：

return this.name.compareTo(person.getName());

return person.getName().compareTo(this.getName());

六、Arrays.parallelSort

6.1 概念

基于分治的归并排序算法，支持多cpu排序，适合大数据量排序。
启用多核CPU并行排序,首先电脑要支持多核。数据量太小的话，不要使用这个方法，因为启用多核也要消耗资源的。
Java8引入的方法，通过源码分析，若果超过4096个位数，就启用多核。在4096以内就使用普通sort。

6.2 代码示例

@Test
    public void testParalleSort(){
        int[] arr = new int[100000000];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(1000000000);
        }
        //获取系统当前的毫秒数。
        long start = System.currentTimeMillis();
        //排序
        Arrays.parallelSort(arr);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

七、Arrays.binarySearch

7.1 概念

Arrays.binarySearch() 是 Java 中用于在已排序的数组中执行二分查找的方法。二分查找是一种高效的搜索算法，用于在有序数组中查找特定元素的位置。

该方法有多种重载形式，但通常最常用的是接受三个参数的形式：

1	public static int binarySearch(int[] a, int key)

这个方法接受一个已排序的整数数组 a 和一个要查找的整数 key，并返回 key 在数组中的索引。如果找到了 key，则返回其索引；否则返回一个负数，表示 key 在数组中的插入点（即将被插入以保持排序的索引位置）的相反数减一。

例如，如果数组为 [1, 3, 5, 7, 9]，而要查找的元素是 5，则 binarySearch() 方法将返回 2，因为 5 在数组中的索引是 2。如果要查找的元素是 6，则返回 -4，表示 6 应该插入在数组索引为 3 的位置。

此外，还有其他重载的 binarySearch() 方法，允许你指定要搜索的范围，以及一个用于比较元素的 Comparator 对象（如果数组不是简单类型）。

7.2 代码示例

@Test
   public void testBinarySearch(){
       int[] arr={1,2,3,4,5,6,7,8,9};
       System.out.println(Arrays.binarySearch(arr,2));
       Person p1=new Person("camellia",20);
       Person p2=new Person("haha",23);
       Person p3=new Person("xiaohua",21);
       Person[] arr1={p1,p2,p3};
       int i = Arrays.binarySearch(arr1, p2, new Comparator<Person>() { //匿名类
           @Override
           public int compare(Person o1, Person o2) {
               return o1.getName().compareTo(o2.getName());
           }
       });
       System.out.println(i);
   }

八、Arrays.fill

8.1概念

Arrays.fill() 是 Java 中用于填充数组元素的方法。它将指定的值赋给数组中的所有元素，从索引 fromIndex（包含）到索引 toIndex（不包含）。
fill() 方法有多种重载形式，最常用的形式是：

1	public static void fill(int[] a, int val)

这个方法接受一个整数数组 a 和一个整数 val，将 val 赋给数组 a 中的所有元素。
除了基本类型 int 外，fill() 方法还可以用于填充其他基本类型数组和对象数组。例如，你可以使用以下方法来填充一个字符串数组：

1 2	String[] strArray = new String[3]; Arrays.fill(strArray, "Hello");

这样，strArray 数组中的所有元素都会变成字符串 "Hello"。
fill() 方法还有其他重载形式，允许你指定填充的范围。

8.2 示例代码

@Test
    public void testFill(){
        int[] arr=new int[5];
        Arrays.fill(arr,2);
        System.out.println(Arrays.toString(arr));
        
        Arrays.fill(arr,1,3,10);
        System.out.println(Arrays.toString(arr));
        
        String[] s1=new String[5];
        Arrays.fill(s1,"Camellia");
        System.out.println(Arrays.toString(s1));
    }

九、Arrays.copyOf

9.1 概念

Arrays.copyOf() 是 Java 中用于复制数组的方法。它可以复制一个现有数组的指定部分或者整个数组，并返回一个新的数组。

9.2 示例代码

@Test
    public void testCopyOf(){
        //数组拷贝
        int[] arr={1,2,3,4,5,6,7,8,9};
        int[] ints = Arrays.copyOf(arr, 5);
        System.out.println(Arrays.toString(ints));
    }

十、Arrays.copyOfRange

10.1 概念

Arrays.copyOfRange() 是 Java 中用于复制数组的一部分内容到新数组的方法。它可以从原始数组中选择指定范围的元素，并将它们复制到新的数组中。

1	public static <T> T[] copyOfRange(T[] original, int from, int to)

这个方法接受三个参数：原始数组 original、起始索引 from（包含）和结束索引 to（不包含）。它会创建一个新的数组，并将原始数组 original 中从索引 from 到索引 to-1 的元素复制到新数组中。

10.2 代码示例

@Test
    public void testCopyOfRange(){
        int[] arr={1,2,3,4,5,6,7,8,9};
        int[] ints = Arrays.copyOfRange(arr, 0, 5);
        System.out.println(Arrays.toString(ints));
    }

注意，copyOfRange() 方法会创建一个新数组，因此新数组的长度将是 to - from。如果 from 大于 to，则会抛出 IllegalArgumentException 异常。

十一、Arrays.aslist

11.1 概念

Arrays.asList() 是 Java 中用于将数组转换为列表的方法。它接受一个数组，并返回一个固定大小的列表，该列表由指定数组中的元素组成。

这个方法有两种重载形式，最常用的形式是：

1	public static <T> List<T> asList(T... a)

这个方法接受一个泛型参数 T，允许你将任意类型的数组转换为列表。它会创建一个由数组元素组成的列表，列表的长度与数组的长度相同。由于 asList() 返回的列表是基于原始数组的视图，因此对列表的修改将反映在原始数组中，反之亦然。

例如，以下代码将创建一个包含整数数组 {1, 2, 3} 元素的列表：

1	List<Integer> list = Arrays.asList(1, 2, 3);

你也可以传递一个数组变量给 asList() 方法：

1 2	String[] array = {"apple", "banana", "orange"}; List<String> list = Arrays.asList(array);

这将创建一个包含字符串数组 array 元素的列表。

需要注意的是，asList() 返回的列表具有固定大小，不能执行添加或删除元素的操作。如果尝试修改列表的大小，例如添加或删除元素，将会抛出 UnsupportedOperationException 异常。

另外，需要注意的是，基本数据类型的数组不能直接作为 asList() 方法的参数，因为 Java 不支持泛型化的基本数据类型。如果需要将基本数据类型的数组转换为列表，需要先将其包装为相应的对象类型数组，然后再调用 asList() 方法。例如：

1 2	int[] intArray = {1, 2, 3}; List<Integer> list = Arrays.asList(Arrays.stream(intArray).boxed().toArray(Integer[]::new));

11.2 代码示例

@Test
    public void testAsList(){
        //将一串数据转成List集合
        List list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+"\t");
        }
    }