JAVA Arrays类 详细介绍

Arrays类是什么？

java.util.Arrays 类是 Java 中用于操作数组的实用工具类。它提供了一系列静态方法，用于对数组进行排序、搜索、比较等操作。 

什么是静态方法呢，就是在定义方法时加上static ，可以让我们在很多地方直接调用这个方法

---

Arrays类常用方法

1、toString方法

Arrays.toString(a)

import java.util.Arrays;

public class Main{
	public static void main(String[] args) {
		int[] a = {5,4,6,7,1};		
		System.out.println(Arrays.toString(a));//[5, 4, 6, 7, 1]
	}
}

在 Arrays.toString 方法中，数组中的每个元素都会使用其默认的 toString() 方法来转换为字符串形式，并且数组的所有元素会被以逗号分隔、包含在方括号中。

那么问题来了，现在我们知道这是一个输出数组用的方法，你是否有想过我们为什么要这样输出数组，或者说你起先想到输出数组的办法是不是用一个for循环输出，那这里毕竟是讲Arrays类，也就不过多展开了。

但是如果说，你想到的是用 System.out.println(arr); 这样来输出，那么——这是错误的！

在Java中，如果你直接使用 System.out.println(arr) 来输出数组 arr，会得到一个编译错误，因为Java并没有为数组提供一个直接输出到控制台的字符串表示形式。因此，你需要使用 Arrays.toString(arr) 来将数组转换为字符串，然后再使用 System.out.println() 方法来输出这个字符串。

2、sort方法

升序

Arrays.sort(a);

import java.util.Arrays;

public class Main{
	public static void main(String[] args) {
		int[] a = {5,4,6,7,1};		
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
	}
}

当你调用 Arrays.sort() 方法时，它会对数组 a 进行排序。这个方法使用了优化的快速排序算法（Quicksort），时间复杂度为 O(n log n)。排序是原地进行的，即不会创建新的数组，而是直接在原始数组上进行排序。

当然，这个方法默认是升序的，如果我们想要它是降序的，也是可以的

 降序

需要注意的是，我们就不能再使用不能使用基本类型（int,double, char），如果是int型需要改成Integer，float要改成Float

（如果不想了解可以跳过，无影响）——常见的包装类型

• Integer：封装了一个 int 类型的对象。
• Long：封装了一个 long 类型的对象。
• Double：封装了一个 double 类型的对象。
• Float：封装了一个 float 类型的对象。
• Boolean：封装了一个 boolean 类型的对象。
• Character：封装了一个 char 类型的对象。
• Byte：封装了一个 byte 类型的对象。

我们有两种不同的思路，一种是用Collections

import java.util.Arrays;
import java.util.Collections;

public class Main{
	public static void main(String[] args) {
		Integer[] a = {5,4,6,7,1};		
		Arrays.sort(a,Collections.reverseOrder());
		System.out.println(Arrays.toString(a)); //[7, 6, 5, 4, 1]
	}
}

另一种是用Comparator

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

public class Main{
	public static void main(String[] args) {
		Integer[] a = {5,4,6,7,1};		
		Arrays.sort(a,Comparator.reverseOrder());
		System.out.println(Arrays.toString(a)); //[7, 6, 5, 4, 1]
	}
}

效果是一样的

 对自定义对象数组按照属性进行排序

假设有一个 Person 类，拥有 name 和 age 属性，我们想要按照年龄进行升序排序：

当然如果你和我一样只是个弱鸡，可以先跳过，并不影响，日后再来是完全可以的

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

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Person[] people = {
                new Person("Alice", 25),
                new Person("Bob", 30),
                new Person("Charlie", 20)
        };

        // 使用 Comparator 接口实现按照年龄升序排序
        Arrays.sort(people, Comparator.comparingInt(p -> p.age));

        // 输出排序后的结果
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

3、binarySearch方法

Arrays.binarySearch() 方法用于在已排序的数组中搜索指定元素的索引。如果找到指定元素，则返回其索引；如果未找到，则返回一个负数值，表示应插入元素的位置以保持数组的排序顺序。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 定义一个已排序的整数数组
        int[] arr = {1, 3, 5, 7, 9, 11, 13};

        // 在数组中搜索指定的元素
        int key1 = 7;
        int index1 = Arrays.binarySearch(arr, key1);
        System.out.println("元素 " + key1 + " 的索引位置为：" + index1);

        // 在数组中搜索不存在的元素
        int key2 = 6;
        int index2 = Arrays.binarySearch(arr, key2);
        System.out.println("元素 " + key2 + " 的索引位置为：" + index2);
        
        // 插入不存在的元素
        if (index2 < 0) {
            int insertionPoint = -index2 - 1;
            System.out.println("元素 " + key2 + " 应插入到索引位置 " + insertionPoint + " 以保持排序顺序。");
        }
    }
}

输出

元素 7 的索引位置为：3
元素 6 的索引位置为：-4
元素 6 应插入到索引位置 3 以保持排序顺序。

你会发现，-4如果倒过来是4-1之后的3才是正确的6应该放在的位置，我想大概是因为数组顺序是从0开始的吧

4、equals方法

这个方法的使用方式比较多，在这里就只放在Arrays中的方式

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
    	int[] arr1 = {1, 2, 3};
    	int[] arr2 = {1, 2, 3};
    	int[] arr3 = {3, 2, 1};

    	System.out.println(Arrays.equals(arr1, arr2)); // 输出：true
    	System.out.println(Arrays.equals(arr1, arr3)); // 输出：false

    }
}

equals() 方法用于比较两个对象是否相等。在 Java 中，equals() 方法是用来比较对象的内容是否相等的，而不是比较对象的引用地址是否相等。如果不重写 equals() 方法，默认情况下，它将与 == 运算符执行相同的操作，即比较引用地址。

5、fill方法

public static void fill(Object[] a, Object val)

这个方法会将数组 a 中的所有元素都设置为 val，即指定的值。这个方法对于基本数据类型的数组和对象类型的数组都适用。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
    	int[] arr = new int[5];
    	Arrays.fill(arr, 10); // 将数组 arr 中的所有元素都设置为 10
    	System.out.println(Arrays.toString(arr)); // 输出：[10, 10, 10, 10, 10]

    }
}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
    	String[] strArray = new String[3];
    	Arrays.fill(strArray, "Hello"); // 将数组 strArray 中的所有元素都设置为 "Hello"
    	System.out.println(Arrays.toString(strArray)); // 输出：["Hello", "Hello", "Hello"]
    	
    }
}

使用 fill() 方法修改数组的一部分元素：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
    	int[] arr = {1, 2, 3, 4, 5};
    	Arrays.fill(arr, 1, 3, 0); // 将数组 arr 中下标从 1 到 2（不包括）的元素都设置为 0
    	System.out.println(Arrays.toString(arr)); // 输出：[1, 0, 0, 4, 5]

    }
}

用数学的思维的话，那么这个就是左闭右开区间，好记吧? 

6、copyOf方法

copyOf() 方法用于创建一个指定长度的新数组，并将原始数组的部分或全部元素复制到新数组中。这个方法会创建一个新的数组，新数组的长度为 newLength，并且将原始数组 original 中的元素复制到新数组中。如果 newLength 小于原始数组的长度，则只复制原始数组的前 newLength 个元素；如果 newLength 大于原始数组的长度，则新数组的后面元素将被填充为默认值（0 或 null）

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
    	int[] arr2 = {1, 2, 3, 4, 5};
    	int[] partialCopyArr = Arrays.copyOfRange(arr2, 1, 2); // 复制 arr2 的左闭右开个元素
    	System.out.println(Arrays.toString(partialCopyArr)); // 输出：[2]

    }
}

也是可以左闭右开这样子，只有一个数字的话，那么就是前多少个

需要注意的是，copyOf() 方法对于基本数据类型的数组和对象类型的数组都适用，但是返回的数组类型与原始数组类型相同。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
    	String[] strArray1 = {"Hello", "World", "Java"};
    	String[] copyStrArray = Arrays.copyOf(strArray1, strArray1.length);
    	System.out.println(Arrays.toString(copyStrArray)); // 输出：["Hello", "World", "Java"]

    }
}

 7、asList方法

asList() 方法用于将数组转换为 List。这个方法的作用是创建一个固定大小的 List，该 List 的底层实现是由指定的数组支持的。这意味着对数组和列表的更改会彼此影响。但需要注意的是，asList() 返回的列表是一个固定大小的列表，意味着无法调整其大小（添加或删除元素），因为它只是对原始数组的一个视图。

我突然觉得这么重要的内容放在这么后面是不是不太好，唉算了

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
    	String[] array = {"apple", "banana", "orange"};
    	List<String> list = Arrays.asList(array);
    	System.out.println(list); // 输出：[apple, banana, orange]

    }
}

 将数组的部分元素转换为列表：

import java.util.Arrays;
import java.util.List;

public class Main {	
    public static void main(String[] args) {
    	Integer[] array = {1, 2, 3, 4, 5};
    	List<Integer> list = Arrays.asList(array).subList(1, 4); // 转换索引为 1 到 3 的部分
    	System.out.println(list); // 输出：[2, 3, 4]
    }
}

需要注意的是，asList() 返回的列表是一个固定大小的列表，不能调整其大小（添加或删除元素）。如果尝试修改返回的列表（例如调用 add()、remove() 方法），将会抛出 UnsupportedOperationException 异常 

---

好累啊，我要累die了...