数组（2）：多维数组、数组与泛型

港控/mmm° 2023-07-19 13:30 7阅读 0赞

### 一、多维数组 ###

创建多维数组很方便。对于基本类型的多维数组，可以通过使用花括号将每个向量分隔开：

import java.util.Arrays;
    
    public class MultidimensionalPrimitiveArray {
    	public static void main(String[] args) {
    		int[][] a = { { 1, 2, 3 }, { 4, 5, 6 } };
    		System.out.println(Arrays.deepToString(a));
    	}
    }

每对花括号括起来的集合都会把你带到下一级数组。

下面的示例使用了java SE5的Arrays.deepToString()，它可以将多维数组转换为多个String，正如从输出中所看到的那样，还可以使用new来分配数组，下面的三维数组就是在new表达式中分配的：

import java.util.Arrays;
    
    public class ThreeDWithNew {
    	public static void main(String[] args) {
    		int[][][] a = new int[2][2][4];
    		System.out.println(Arrays.deepToString(a));
    	}
    }

你可以看到基本类型数组的值在不进行显式初始化的情况下，会被自动初始化。对象数组会被初始化为null。

数组中构成矩阵的每个向量都可以具有任意的长度（这被称为粗糙数组）：

import java.util.Arrays;
    import java.util.Random;
    
    public class RaggedArray {
    	public static void main(String[] args) {
    		Random r = new Random();
    		int[][][] a = new int[r.nextInt(7)][][];
    		for (int i = 0; i < a.length; i++) {
    			a[i] = new int[r.nextInt(5)][];
    			for (int j = 0; j < a[i].length; j++) {
    				a[i][j] = new int[r.nextInt(5)];
    			}
    		}
    		System.out.println(Arrays.deepToString(a));
    	}
    }

第一个new创建了数组，其第一维长度是由随机数确定的，其他维的长度则没有定义。位于for循环内的第二个new则会决定第二维的长度；直到碰到第三个new，第三维的长度才得以确定。

可以用类似的方法处理非基本类型的对象数组。下面，你可以看到如何用花括号把多个new表达式组织到一起：

import java.util.Arrays;
    
    public class MultidimensionalObjectArrays {
    	public static void main(String[] args) {
    		BerylliumSphere[][] spheres = {
    				{new BerylliumSphere(),new BerylliumSphere()},
    				{
    					new BerylliumSphere(),new BerylliumSphere(),
    					new BerylliumSphere(),new BerylliumSphere()
    				},
    				{
    					new BerylliumSphere(),new BerylliumSphere(),
    					new BerylliumSphere(),new BerylliumSphere(),
    					new BerylliumSphere(),new BerylliumSphere(),
    					new BerylliumSphere(),new BerylliumSphere()
    				}
    		};
    		System.out.println(Arrays.deepToString(spheres));
    	}
    }

你可以看到spheres是另外一个粗糙数组，其每一个对象列表的长度都是不同的。

自动包装机制对数组初始化器也起作用：

import java.util.Arrays;
    
    public class AutoboxingArrays {
    	public static void main(String[] args) {
    		Integer[][] a = {
    				{1,2,3,4,5,6,7,8,9,10},
    				{21,22,23,24,25,26,27,28,29,30},
    				{51,52,53,54,55,56,57,58,59,60},
    				{71,72,73,74,75,76,77,78,79,80}
    		};
    		System.out.println(Arrays.deepToString(a));
    	}
    }

下面的示例展示了可以如何逐个的、部分的构建一个非基本类型的对象数组：

import java.util.Arrays;
    
    public class AssemblingMultidimensionalArrays {
    	public static void main(String[] args) {
    		Integer[][] a;
    		a = new Integer[3][];
    		for (int i = 0; i < a.length; i++) {
    			a[i] = new Integer[3];
    			for (int j = 0; j < a[i].length; j++) {
    				a[i][j] = i * j;
    			}
    		}
    		System.out.println(Arrays.deepToString(a));
    	}
    }

i\*j只是为了使置于Integer中的值变得有些意思。

Arrays.deepToString()方法对基本类型数组和对象数组都起作用：

import java.util.Arrays;
    
    public class MultiDimWrapperArray {
    	public static void main(String[] args) {
    		Integer[][] a1 = { { 1, 2, 3 }, { 4, 5, 6 } };
    		Double[][][] a2 = {
    				{ {1.1,2.2}, {3.3,4.4} },
    				{ {5.5,6.6}, {7.7,8.8} },
    				{ {9.9,1.2}, {2.3,3.4} }
    		};
    		String[][] a3 = {
    				{"The", "Quick", "Sly", "Fox"},
    				{"Jumped", "Over"},
    				{"The", "Lazy", "Brown", "Dog", "and" , "friend"}
    		};
    		System.out.println("a1: " + Arrays.deepToString(a1));
    		System.out.println("a2: " + Arrays.deepToString(a2));
    		System.out.println("a3: " + Arrays.deepToString(a3));
    	}
    }

在Integer和Double数组中，Java SE5的自动包装机制再次为我们创建了包装器对象。

### 二、数组与泛型 ###

通常，数组与泛型不能很好的结合。你不能实例化具有参数化类型的数组：

Peel<Banana>[] peels = new Peel<Banana>[10]; // 非法的

擦除会移除参数类型信息，而数组必须知道它们所持有的确切类型，以强制保证类型安全。但是，你可以参数化数组本身的类型：

class ClassParameter<T> {
    	public T[] f(T[] arg) {
    		return arg;
    	}
    }
    
    class MethodParameter {
    	public static <T> T[] f(T[] arg) {
    		return arg;
    	}
    }
    
    public class ParameterizedArrayType {
    	public static void main(String[] args) {
    		Integer[] ints = { 1, 2, 3, 4, 5 };
    		Double[] doubles = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    		Integer[] ints2 = new ClassParameter<Integer>().f(ints);
    		Double[] doubles2 = new ClassParameter<Double>().f(doubles);
    		ints2 = MethodParameter.f(ints);
    		doubles2 = MethodParameter.f(doubles);
    	}
    }

注意，使用参数化方法而不使用参数化类的方便之处在于：你不必为需要应用的每种不同的类型都使用一个参数去实例化这个类，并且你可以将其定义为静态的。当然，你不能总是选择使用参数化方法而不是参数化类，但是它应该成为首选。

正如上例所证明的那样，不能创建泛型数组这一说法并不十分准确。诚然，编译器确实不让你实例化泛型数组，但是，它允许你创建对这种数组的引用。例如：

List<String>[] ls;

这条语句可以顺利的通过编译器而不报任何错误。而且，尽管你不能创建实际的持有泛型的数组对象，但是你可以创建非泛型的数组，然后将其转型：

import java.util.ArrayList;
    import java.util.List;
    
    public class ArrayOfGenerics {
    	@SuppressWarnings({ "unchecked", "rawtypes" })
    	public static void main(String[] args) {
    		List<String>[] ls;
    		List[] la = new List[10];
    		ls = la;
    		ls[0] = new ArrayList<String>();
    //		ls[1] = new ArrayList<Integer>();
    		Object[] objects = ls;
    		objects[1] = new ArrayList<Integer>();
    		List<BerylliumSphere>[] spheres = new List[10];
    		for (int i = 0; i < spheres.length; i++) {
    			spheres[i] = new ArrayList<>();
    		}
    	}
    }

一旦拥有了对List<String>\[\]的引用，你就会看到你将得到某些编译器检查。问题是数组是协变类型的，因此List<String>\[\]也是一个Object\[\]，并且你可以利用这一点，将一个ArrayList<Integer>赋值到你的数组中，而不会有任何编译期或运行时错误。

如果你知道将来不会向上转型，并且需求也相对比较简单，那么你仍旧可以创建泛型数组，它可以提供基本的编译期类型检查。但是，事实上，泛型容器总是比泛型数组是更好的选择。

一般而言，你会发现泛型在类或方法的边界处很有效，而在类或方法的内部，擦除通常会使泛型变得不适用。例如，你不能创建泛型数组：

public class ArrayOfGenericType<T> {
    	T[] array;
    
    	@SuppressWarnings("unchecked")
    	public ArrayOfGenericType(int size) {
    //		array = new T[size];
    		array = (T[]) new Object[size];
    	}
    
    //	public <U> U[] makeArray() {
    //		return new U[10];
    //	}
    }

擦除再次成为了障碍——本例试图创建的类型已被擦除，因而是类型未知的数组。注意，你可以创建Object数组，然后将其转型，但是如果没有@SuppressWarnings注解，你将在编译期得到一个“不受检查”的警告消息，因为这个数组没有真正持有或动态检查类型T。也就是说，如果我创建一个String\[\]，java在编译期和运行时都会强制要求我只能将String对象置于该数组中。但是，如果创建的是Object\[\]，那么我就可以将除基本类型之外的任何对象置于该数组中。

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