Java 中的Arrays 类（2千字详解）

梦里梦外; 2023-09-28 15:10 12阅读 0赞

### 文章目录 ###

*  Arrays 类常用方法
 *   *  （1）toString() 方法
     *  （2）binarySearch() 方法
     *  （3）copyOf() 方法
     *  （4）equals() 方法
     *  （5）fill() 方法
     *  （6）普通的sort() 方法
     *  （7）定制的sort() 方法
 *  总结：

# Arrays 类常用方法 #

*  Arrays 类：该类包含用于操作数组的各种方法（如排序和搜索），该类中的方法全部为静态方法，可以将数组视为列表。 如果指定的数组引用为空，则该类中的方法都会抛出一个NullPointerException ，除非另有说明。

## （1）toString() 方法 ##

> **（1）toString() 方法：返回指定数组的内容的字符串表示形式。**

Integer[] integers = {
        1, 20, 90};
    	System.out.println(Arrays.toString(integers));

## （2）binarySearch() 方法 ##

> **（2）binarySearch() 方法：使用二叉搜索算法搜索指定数组中的指定值，要求数组必须是升序排列，返回值为指定值的索引；若指定值不存在，则返回 -(low + 1)。**

Integer[] arr = {
        1, 2, 90, 123, 567};
    	int index = Arrays.binarySearch(arr, 567);
        System.out.println("index = " + index);

## （3）copyOf() 方法 ##

> **（3）copyOf() 方法：复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。**

/*
        1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
        2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
        4. 该方法的底层使用的是 System.arraycopy()*/
    	Integer[] arr = {
        1, 2, 90, 123, 567};
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));

## （4）equals() 方法 ##

> **（4）equals() 方法：如果两个指定的对象数组彼此相等 ，则返回true 。 如果两个数组都包含相同数量的元素或者都为null，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。**

Integer[] arr = {
        1, 2, 90, 123, 567};
    	Integer[] arr2 = {
        1, 2, 90, 123};
    	boolean equals = Arrays.equals(arr, arr2);
    	System.out.println("equals=" + equals);

## （5）fill() 方法 ##

> **（5）fill() 方法：将指定的值分配给指定数组的每个元素。**

Integer[] num = new Integer[]{
        9,3,2};
    	Arrays.fill(num, 99);
        System.out.println("==num数组填充后==");
        System.out.println(Arrays.toString(num));

## （6）普通的sort() 方法 ##

> **（6）普通的sort() 方法：将指定数组进行排序，默认是升序。**

Integer arr[] = {
        1, -1, 7, 0, 89};
    	Arrays.sort(arr); // 默认排序方法
    	tem.out.println("===排序后===");
        System.out.println(Arrays.toString(arr));

## （7）定制的sort() 方法 ##

> **（7）定制的sort(T\[\] a, Comparator<? super T> c) 方法：根据指定的比较器引发的顺序对指定的对象数组进行排序。 数组中的所有元素必须通过指定的比较器相互比较。**

*  **体现了接口编程+动态绑定+匿名内部类的综合使用，在将来的底层框架和源码的使用方式，会非常常见。**

public class ArraysSortCustom {
        
        public static void main(String[] args) {
        
    
            int[] arr = {
        1, -1, 8, 0, 20};
            
            // 传入我们需要排序的数据，和实现了 Comparator 接口的类的对象
            // Comparator 接口的类的对象 相当于我们想要排序的规则，通过匿名内部类我们可以轻松地更改这个规则。
            bubble(arr, new Comparator() {
        // 使用了匿名内部类
            
            	// 重写了接口中的 compare() 方法;
                @Override
                public int compare(Object o1, Object o2) {
        
                    int i1 = (Integer) o1;// 向下转型
                    int i2 = (Integer) o2;
                    return i2 - i1;// 或者 return i1 - i2;会决定最终是升序还是降序排序
                }
            });
    
            System.out.println("==定制排序后的情况==");
            System.out.println(Arrays.toString(arr));
    
        }
    
        // 定制排序方法，此处我们使用冒泡；
        // Arrays.sort() 源码使用的是 二叉排序。
        public static void bubble(int[] arr, Comparator c) {
        
            int temp = 0;
            for (int i = 0; i < arr.length - 1; i++) {
        
                for (int j = 0; j < arr.length - 1 - i; j++) {
        
                
                    // 调用接口中的 compare() 方法，我们可以重写该方法；
                    // 最终数组顺序由 c.compare(arr[j], arr[j + 1]) 返回的值决定
                    if (c.compare(arr[j], arr[j + 1]) > 0) {
        
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

# 总结： #

*  本文是小白博主在学习B站韩顺平老师的Java网课时整理总结的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
 *  本文详细解释了 Arrays类 的 概念与使用，还举了很多例子，希望小伙伴们看后能有所收获！
 *  最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！