java数组与java.util.Arrays工具类

概念

Java中数组属于引用类型。数组使用场合较多，对于数组的操作具有一定重复性，例如：数组拷贝，转换字符串，转换成数组，排序等等。
既然重复的操作与需求多，那么对于数组操作的支持就成了JDK中的一大需求。java.util.Arrays中提供了很多对数组操作的支持。

System.arraycopy: 数组元素拷贝

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

作用是从src数组的srcPos位置往dest数组的destPos位置拷贝length个元素。
当然，数组拷贝位置或元素数量不当时，可能出现ArrayIndexOutOfBoundException异常；类型不匹配时，会出现ArrayStoreException。

int[] a = new int[10];
int[] b = {1,2,3,4,5};

System.out.println("copy all elements of b[5] to a[10]:");
System.arraycopy(b, 0, a, 0, b.length);
System.out.println(Arrays.toString(a));

System.out.println("copy 4 elements of a[10] from index 0 to index 4:");
System.arraycopy(a, 0, a, 4, 4);
System.out.println(Arrays.toString(a));

System.out.println("copy 3 elements of a[10] from index 0 to index 8:");
System.arraycopy(a, 0, a, 8, 3);
System.out.println(Arrays.toString(a));

运行结果：

copy all elements of b[5] to a[10]:
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
copy 4 elements of a[10] from index 0 to index 4:
[1, 2, 3, 4, 1, 2, 3, 4, 0, 0]
copy 3 elements of a[10] from index 0 to index 8:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException

Arrays.equals: 判断数组内容相等

Arrays中针对不同类型的数组提供了多个重载版本，
包括各种基本类型的比较：

public static boolean equals(int[] a, int[] a2);
public static boolean equals(long[] a, long[] a2);
public static boolean equals(boolean[] a, boolean[] a2);
......
以及对象数组之间的比较:
public static boolean equals(Object[] a, Object[] a2);

示例如下：

int[] a = {1,2,3,4,5};
int[] b = {1,2,3,4,5};
System.out.println("int array compare equal? " + Arrays.equals(a, b));

Integer c[] = {new Integer(1), new Integer(3)};
Integer d[] = {new Integer(1), new Integer(3)};
System.out.println("Integer array compare equal? " + Arrays.equals(c,d));

Integer e[] = {1, 3}; //auto boxing
Integer f[] = {new Integer(1), new Integer(3)};
System.out.println("Integer array of autoBoxing and common Integer array: " + Arrays.equals(e,f));

//    int g[] = {1, 3};
//    Integer h[] = {new Integer(1), new Integer(3)};
//    System.out.println(Arrays.equals(h,g)); //compile error

运行结果：

int array compare equal? true
Integer array compare equal? true
Integer array of autoBoxing and common Integer array: true对于最后一个int[]与Integer[]之间的比较，由于jdk中不存在不同类型之间比较的equal方法重载版本，且此处无法自动将int[]转换为封装类型的数组Integer[]，因此结果是编译出错。

Arrays.fill: 数组填充内容，Arrays.toString转换字符串

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

此方法将val填充至数组a中的每一个位置。需要注意的是，此处赋值是浅拷贝。
示例如下：

String strings[] = new String[10];
Arrays.fill(strings, "A");
System.out.println(Arrays.toString(strings));

结果如下：

[A, A, A, A, A, A, A, A, A, A]

Arrays.asList：将数组转换为List

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

例如：

String strings[] = new String[10];
Arrays.fill(strings, "A");
List<String> asList = Arrays.asList(strings);
System.out.println(asList);

此方法使用泛型作为参数及返回值，因此当方法参数和返回值List参数类型不一致时，编译器会报错，例如：

int integers[] = {1,2};
// List<Integer> integers1 = Arrays.asList(integers); // compile error

将int[]转换为List<Integer>就会出现编译器报错。

Arrays.sort: 数组排序

sort对于不同类型提供了多个重载版本，例如int[]的排序方法重载版本，排序完成应该是从小至大的顺序：

public static void sort(int[] a)；

示例如下：

int[] a = {2,3,1,5,4};
Arrays.sort(a);
System.out.println(Arrays.toString(a));

结果如下：

[1, 2, 3, 4, 5]

下面，针对对象进行排序测试。
对象进行比较的前提是，这种类型‘可比较‘。那么，它需要实现Comparable<T>接口。

class Person implements Comparable<Person>
{
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}

	int age;
	String name;

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

	@Override
	public int compareTo(Person o) {
		return (age-o.age);
	}
}

下面构造测试：

Person jack = new Person(21,"jack");
Person rose = new Person(23,"rose");
Person judy = new Person(22,"judy");
Person joo = new Person(24,"joo");
Person persons[] = {jack, rose, judy, joo};
System.out.println(Arrays.toString(persons));

结果如下：

[Person{age=21, name=‘jack‘}, Person{age=23, name=‘rose‘}, Person{age=22, name=‘judy‘}, Person{age=24, name=‘joo‘}]

进行排序：

System.out.println("common sort:");
Arrays.sort(persons);
System.out.println(Arrays.toString(persons));

运行结果：

common sort:
[Person{age=21, name=‘jack‘}, Person{age=22, name=‘judy‘}, Person{age=23, name=‘rose‘}, Person{age=24, name=‘joo‘}]

或者，实现倒序：

System.out.println("reverse sort:");
Arrays.sort(persons, Collections.reverseOrder());
System.out.println(Arrays.toString(persons));

运行结果：

reverse sort:
[Person{age=24, name=‘joo‘}, Person{age=23, name=‘rose‘}, Person{age=22, name=‘judy‘}, Person{age=21, name=‘jack‘}

基于策略模式的自定义Comparator排序

然而，不同人对于相同的对象可能有不同的排序规则。例如，小李想让Person[]按年龄排序，小明想按照Person的名字排序...
基于策略模式，sort的重载版本可指定Comparator<T>作为排序算法：

public static <T> void sort(T[] a, Comparator<? super T> c);

先实现一个对于Person泛型的Comparator类，基于name排序：

class MyComparator implements Comparator<Person>
{
	@Override
	public int compare(Person o1, Person o2) {
		return o1.name.compareTo(o2.name);
	}
}

构造测试：

System.out.println("MyComparator:");
Arrays.sort(persons, new MyComparator());
System.out.println(Arrays.toString(persons));

运行结果：

MyComparator:
[Person{age=21, name=‘jack‘}, Person{age=24, name=‘joo‘}, Person{age=22, name=‘judy‘}, Person{age=23, name=‘rose‘}]

原文地址：https://www.cnblogs.com/xinxinBlog/p/10296042.html