数组（5）：Arrays工具类的实用功能

不念不忘少年蓝@ 2023-07-20 15:00 30阅读 0赞

在java.util类库中可以找到Arrays类，它有一套用于数组的static实用方法，其中有六个基本方法：equals()用于比较两个数组是否相等（deepEquals()用于多维数组）；fill()前面已经叙述过了；sort()用于对数组排序；binarySearch()用于在已经排序的数组中查找元素；toString()产生数组的String表示；hashCode()产生数组的散列码。所有这些方法对各种基本类型和Object类而重载过。此外，Arrays.asList()接受任意的序列或数组作为其参数，并将其转变为List容器。

在讨论Arrays的方法之前，我们先看看另一个不属于Arrays但很有用的方法。

### 一、复制数组 ###

java标准类库提供有static方法System.arraycopy()，用它复制数组比用for循环复制要快很多。System.arraycopy()针对所有类型做了重载。下面的例子就是用来处理int数组的：

import java.util.Arrays;
    
    public class CopyingArrays {
    	public static void main(String[] args) {
    		int[] i = new int[7];
    		int[] j = new int[10];
    		Arrays.fill(i, 47);
    		Arrays.fill(j, 99);
    		System.out.println("i = " + Arrays.toString(i));
    		System.out.println("j = " + Arrays.toString(j));
    		System.arraycopy(i, 0, j, 0, i.length);
    		System.out.println("j = " + Arrays.toString(j));
    		int[] k = new int[5];
    		Arrays.fill(k, 103);
    		System.arraycopy(i, 0, k, 0, k.length);
    		System.out.println("k = " + Arrays.toString(k));
    		Arrays.fill(k, 103);
    		System.arraycopy(k, 0, i, 0, k.length);
    		System.out.println("k = " + Arrays.toString(i));
    
    		Integer[] u = new Integer[10];
    		Integer[] v = new Integer[5];
    		Arrays.fill(u, new Integer(47));
    		Arrays.fill(v, new Integer(99));
    		System.out.println("u = " + Arrays.toString(u));
    		System.out.println("v = " + Arrays.toString(v));
    		System.arraycopy(v, 0, u, u.length / 2, v.length);
    		System.out.println("u = " + Arrays.toString(u));
    	}
    }

arraycopy()需要的参数有：源数组，表示从源数组中的什么位置开始复制的偏移量，表示从目标数组的什么位置开始复制的偏移量，以及需要复制的元素个数。当然，对数组的任何越界操作都会导致异常。

这个例子说明基本类型数组与对象数组都可以复制。然而，如果复制对象数组，那么只是复制了对象的引用——而不是对象本身的拷贝。这被称作浅复制（shallow copy）。

System.arraycopy()不会执行自动包装和自动拆包，两个数组必须具有相同的确切类型。

### 二、数组的比较 ###

Arrays类提供了重载后的equals()方法，用来比较整个数组。同样，此方法针对所有基本类型与Object都做了重载。数组相等的条件是元素个数必须相等，并且对应位置的元素也相等，这可以通过对每一个元素使用equals()作比较来判断。（对于基本类型，需要使用基本类型的包装器类的equals()方法，例如，对于int类型使用Integer.equals()作比较）见下例：

import java.util.Arrays;
    
    public class ComparingArrays {
    	public static void main(String[] args) {
    		int[] a1 = new int[10];
    		int[] a2 = new int[10];
    		Arrays.fill(a1, 47);
    		Arrays.fill(a2, 47);
    		System.out.println(Arrays.equals(a1, a2));
    		a2[3] = 11;
    		System.out.println(Arrays.equals(a1, a2));
    		String[] s1 = new String[4];
    		Arrays.fill(s1, "Hi");
    		String[] s2 = { new String("Hi"), new String("Hi"), new String("Hi"), new String("Hi") };
    		System.out.println(Arrays.equals(s1, s2));
    	}
    }

最初，a1与a2完全相等，所以输出为true；然后改变其中一个元素，使得结果为false。在最后一个例子中，s1的所有元素都指向同一个对象，而数组s2包含5个相互独立的对象。然而，数组相等是基于内容的（通过Object.equals()比较），所以结果为true。

### 三、数组元素的比较 ###

排序必须根据对象的实际类型执行比较操作。一种自然的解决方案是为每种不同的类型各编写一个不同的排序方法，但是这样的代码难以被新的类型所复用。

程序设计的基本目标是“将保持不变的事物与会发生改变的事物相分离”，而这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。因此，不是将进行比较的代码编写成不同的子程序，而是使用策略设计模式。通过使用策略，可以将“会发生的变化的代码”封装在单独的类中（策略对象），你可以将策略对象传递给总是相同的代码，这些代码将使用策略来完成其算法。通过这种方式，你能够用不同的对象来表示不同的比较方式，然后将它们传递给相同的排序代码。

java有两种方式来提供比较功能。第一种是实现java.lang.Comparable接口，使你的类具有“天生”的比较能力。此接口很简单，只有compareTo()一个方法。此方法接收另一个Object为参数，如果当前对象小于参数则返回负值，如果相等则返回0，如果当前对象大于参数则返回正值。

下面的类实现了Comparable接口，并且使用java标准类库的方法Arrays.sort()演示了比较的效果：

import java.util.Arrays;
    import java.util.Random;
    
    import com.buba.util.Generated;
    import com.buba.util.Generator;
    
    public class CompType implements Comparable<CompType> {
    	int i;
    	int j;
    	private static int count = 1;
    
    	public CompType(int n1, int n2) {
    		i = n1;
    		j = n2;
    	}
    
    	public String toString() {
    		String result = "[i = " + i + ", j = " + j + "]";
    		if (count++ % 3 == 0) {
    			result += "\n";
    		}
    		return result;
    	}
    
    	@Override
    	public int compareTo(CompType o) {
    		return (i < o.i ? -1 : (i == o.i ? 0 : 1));
    	}
    
    	private static Random r = new Random();
    
    	public static Generator<CompType> generator() {
    		return () -> {
    			return new CompType(r.nextInt(100), r.nextInt(100));
    		};
    	}
    
    	public static void main(String[] args) {
    		CompType[] a = Generated.array(new CompType[12], generator());
    		System.out.println("before sorting");
    		System.out.println(Arrays.toString(a));
    		Arrays.sort(a);
    		System.out.println("after sorting:");
    		System.out.println(Arrays.toString(a));
    	}
    }

在定义作比较的方法时，由你来负责决定将你的一个对象与另一个对象作比较的含义。这里在比较中只用到了i值，而忽略了j值。

generator()方法生成一个对象，此对象通过创建一个匿名内部类来实现Generator接口。该例中构建CompType对象，并使用随机数加以初始化。在main()中，使用生成器填充CompType的数组，然后对其排序。如果没有实现Comparable接口，调用sort()的时候会抛出ClassCastException这个运行时异常。因为sort()需要把参数的类型转变为Comparable。

假设有人给你一个并没有实现Comparable的类，或者给你的类实现了Comparable，但是你不喜欢它的实现方式，你需要另外一种不同的比较方法。要解决这个问题，可以创建一个实现了Comparator接口的单独的类。这是策略设计模式的一个应用实例。这个类有compare()和equals()两个方法。然而，不一定要实现equals()方法，除非你有特殊的性能需要，因为无论何时创建一个类，都是间接继承自Object，而Object带有equals()方法。所以只需用默认的Object和equals()方法就可以满足接口的要求了。

Collections类包含一个reverseOrder()方法，该方法可以产生一个Comparator，它可以自然的排序顺序。这很容易应用于CompType：

import java.util.Arrays;
    import java.util.Collections;
    
    import com.buba.util.Generated;
    
    public class Reverse {
    	public static void main(String[] args) {
    		CompType[] a = Generated.array(new CompType[12], CompType.generator());
    		System.out.println("before sorting");
    		System.out.println(Arrays.toString(a));
    		Arrays.sort(a, Collections.reverseOrder());
    		System.out.println("after sorting:");
    		System.out.println(Arrays.toString(a));
    	}
    }

也可以编写自己的Comparator。在这里的CompType对象是基于j值而不是基于i值的：

import java.util.Arrays;
    import com.buba.util.Generated;
    
    public class ComparatorTest {
    	public static void main(String[] args) {
    		CompType[] a = Generated.array(new CompType[12], CompType.generator());
    		System.out.println("before sorting");
    		System.out.println(Arrays.toString(a));
    		Arrays.sort(a, (o1, o2) -> {
    			return o1.j < o2.j ? -1 : (o1.j == o2.j ? 0 : 1);
    		});
    		System.out.println("after sorting:");
    		System.out.println(Arrays.toString(a));
    	}
    }

### 四、数组排序 ###

使用内置的排序方法，就可以对任意的基本类型数组排序；也可以对任意的对象数组进行排序，只要该对象实现了Comparable接口或具有相关联的Comparator。下面的例子生成随机的String对象，并对其排序：

import java.util.Arrays;
    import java.util.Collections;
    
    import com.buba.util.Generated;
    import com.buba.util.RandomGenerator;
    
    public class StringSorting {
    	public static void main(String[] args) {
    		String[] array = Generated.array(new String[20], new RandomGenerator.String(5));
    		System.out.println("before sort " + Arrays.toString(array));
    		Arrays.sort(array);
    		System.out.println("after sort: " + Arrays.toString(array));
    		Arrays.sort(array, Collections.reverseOrder());
    		System.out.println("reverse sort: " + Arrays.toString(array));
    		Arrays.sort(array, String.CASE_INSENSITIVE_ORDER);
    		System.out.println("Case-insensitive sort: " + Arrays.toString(array));
    	}
    }

注意，String排序算法依据词典编排顺序排序，所以大写字母开头的词都放在前面输出，然后才是小写字母开头的词。如果想忽略大小写字母将单词都放在一起排序，那么可以像上例中最后一个对sort()的调用一样，使用String.CASE\_INSENSITIVE\_ORDER。

java标准类库中的排序算法针对正排序的特殊类型进行了优化——针对基本类型设计的“快速排序”（QuickSort），以及针对对象设计的“稳定归并排序”。所以无需担心排序的性能，除非你可以证明排序部分的确是程序效率的瓶颈。

### 五、在已排序的数组中查找 ###

如果数组已经排好序了，就可以使用Arrays.binarySearch()执行快速查找。如果要针对未排序的数组使用binarySearch()，那么将产生不可预料的结果。下面的例子使用RandomGenerator.Integer填充数组，然后再使用同样的生成器生成要查找的值：

import java.util.Arrays;
    
    import com.buba.util.ConvertTo;
    import com.buba.util.Generated;
    import com.buba.util.Generator;
    import com.buba.util.RandomGenerator;
    
    public class ArraySearching {
    	public static void main(String[] args) {
    		Generator<Integer> gen = new RandomGenerator.Integer(1000);
    		int[] a = ConvertTo.primitive(Generated.array(new Integer[25], gen));
    		Arrays.sort(a);
    		System.out.println("Sorted array: " + Arrays.toString(a));
    		while (true) {
    			int r = gen.next();
    			int location = Arrays.binarySearch(a, r);
    			if (location >= 0) {
    				System.out.println("Location of " + r + " is " + location + ", a[" + location + "] = " + a[location]);
    				break;
    			}
    		}
    	}
    }

在while循环中随机生成一些值作为查找的对象，直到找到一个才停止循环。

如果找到了目标，Arrays.binarySearch()产生的返回值等于或大于0。否则，它产生负返回值，表示若要保持数组的排序状态此目标元素所应该插入的位置。这个负值的计算方式是：

-（插入点） - 1

“插入点”是指，第一个大于查找对象的元素在数组中的位置，如果数组中所有的元素都小于要查找的对象，“插入点”就等于a.length。

如果数组包含重复的元素，则无法保证找到的是这些副本中的哪一个。搜索算法确实不是专为包含重复元素的数组而设计的，不过仍然可用。如果需要对没有重复元素的数组排序，可以使用TreeSet（保持排序顺序），或者LinkedHashSet(保持插入顺序)，后面我们将会介绍它们。这些类会自动处理所有的细节。除非它们成为程序性能的瓶颈，否则不需要自己维护数组。

如果使用Comparator排序了某个对象数组（基本类型数组无法使用Comparator进行排序），在使用binarySearch()时必须提供同样的Comparator（使用binarySearch()方法的重载版本）。例如，可以修改StringSorting.java程序以进行某种查找：

import java.util.Arrays;
    
    import com.buba.util.Generated;
    import com.buba.util.RandomGenerator;
    
    public class AlphabeticSearch {
    	public static void main(String[] args) {
    		String[] array = Generated.array(new String[30], new RandomGenerator.String(5));
    		Arrays.sort(array, String.CASE_INSENSITIVE_ORDER);
    		System.out.println(Arrays.toString(array));
    		int index = Arrays.binarySearch(array, array[10], String.CASE_INSENSITIVE_ORDER);
    		System.out.println("index: " + index + "\n" + array[index]);
    	}
    }

这里的Comparator必须接受重载过的binarySearch()作为其第三个参数。在这个例子中，由于要查找的目标是从数组中选出来的元素，所以肯定能查找到。

**如果本文对您有很大的帮助，还请点赞关注一下。**