数组（1）：数组为什么特殊、数组是第一级对象、返回一个数组

忘是亡心i 2023-07-19 08:19 1阅读 0赞

对数组的基本看法是，你可以创建并组装它们，通过使用整型索引值访问它们的元素，并且它们的尺寸不能改变。在大多数时候，这就是你需要了解的全部，但是有时你需要在数组上执行更加复杂的操作，并且你可能需要评估到底是使用数组还是更加灵活的容器。本章将向你展示如何更加深入的思考数组。

### 一、数组为什么特殊 ###

java中有大量其他的方式可以持有对象，那么，到底是什么使数组变得与众不同呢？

数组与其他种类的容器之间的区别有三方面：效率、类型和保存基本类型的能力。在java中，数组是一种效率最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性序列，这使得元素访问非常快速。但是为这种速度所付出的代价是数组的大小被固定，并且在其生命周期中不可改变。你可能会建议使用ArrayList，它通过创建一个新实例，然后把旧实例中所有的引用移到新实例中，从而实现更多空间的自动分配。尽管通常应该首选ArrayList而不是数组，但是这种弹性需要开销，因此，ArrayList的效率比数组低很多。

数组和容器都可以保证你不能滥用它们。无论你是使用数组还是容器，如果越界，就会变得到一个表示程序员错误的RuntimeException异常。

在泛型之前，其他的容器类在处理对象时，都将它们视作没有任何具体类型。也就是说，它们将这些对象都当作java中所有类的根类Object处理。数组之所以优于泛型之前的容器，就是因为你可以创建一个数组去持有某种具体类型。这意味着你可以通过编译期检查，来防止插入错误类型和抽取不当类型。当然，无论在编译时还是运行时，java都会阻止你向对象发送不恰当的消息。所以，并不是说哪种方法更不安全，只是如果编译时就能够指出错误，会显得更加优雅，也减少了程序的使用者被异常吓着的可能性。

数组可以持有基本类型，而泛型之前的容器则不能。但是有了泛型，容器就可以指定并检查它们所持有对象的类型，并且有了自动包装机制，容器看起来还能够持有基本类型。下面是将数组与泛型容器进行比较的示例：

import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    class BerylliumSphere {
    	private static long counter;
    	private final long id = counter++;
    
    	public String toString() {
    		return "Sphere " + id;
    	}
    }
    
    public class ContainerComparison {
    	public static void main(String[] args) {
    		BerylliumSphere[] spheres = new BerylliumSphere[10];
    		for (int i = 0; i < 5; i++) {
    			spheres[i] = new BerylliumSphere();
    		}
    		System.out.println(Arrays.toString(spheres));
    		System.out.println(spheres[4]);
    		List<BerylliumSphere> sphereList = new ArrayList<>();
    		for (int i = 0; i < 5; i++) {
    			sphereList.add(new BerylliumSphere());
    		}
    		System.out.println(sphereList);
    		System.out.println(sphereList.get(4));
    		int[] integers = { 0, 1, 2, 3, 4, 5 };
    		System.out.println(Arrays.toString(integers));
    		System.out.println(integers[4]);
    		List<Integer> intList = new ArrayList<>(Arrays.asList(0, 1, 2, 3, 4, 5));
    		intList.add(97);
    		System.out.println(intList);
    		System.out.println(intList.get(4));
    	}
    }

这两种持有对象的方式都是类型检查型的，并且唯一明显的差异就是数组使用\[\]来访问元素，而List使用的是add()和get()这样的方法。数组和ArrayList之间的相似性是有意设计的，这使得从概念上讲，这两者之间的切换是很容易的。但是正如你所见到的，容器比数组明显具有更多功能。

随着自动包装机制的出现，容易已经可以与数组几乎一样方便的用于基本类型中了。数组硕果仅存的优点就是效率。然而，如果要解决更一般化的问题，那数组就可能会受到过多的限制，因此在这些情形下你还是会使用容器。

### 二、数组是第一级对象 ###

无论使用哪种类型的数组，数组标识符其实只是一个引用，指向在堆中创建的一个真实对象，这个（数组）对象用以保存指向其他对象的引用。可以作为数组初始化语法的一部分隐式地创建此对象，或者用new表达式显式地创建。只读成员length是数组对象的一部分（事实上，这是唯一一个可以访问的字段或方法），表示此数组对象可以存储多少元素。“\[\]”语法是访问数组对象唯一的方式。

下例总结了初始化数组的各种方式，以及如何对指向数组的引用赋值，使之指向另一个数组对象。此例也说明，对象数组和基本类型数组在使用上几乎是相同的；唯一的区别就是对象数组保存的是引用，基本类型数组直接保存基本类型的值。

import java.util.Arrays;
    
    public class ArrayOptions {
    	public static void main(String[] args) {
    		BerylliumSphere[] a;
    		BerylliumSphere[] b = new BerylliumSphere[5];
    		System.out.println("b : " + Arrays.toString(b));
    		BerylliumSphere[] c = new BerylliumSphere[4];
    		for (int i = 0; i < c.length; i++) {
    			if (c[i] == null) {
    				c[i] = new BerylliumSphere();
    			}
    		}
    		BerylliumSphere[] d = { new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere() };
    		a = new BerylliumSphere[] { new BerylliumSphere(), new BerylliumSphere() };
    		System.out.println("a.length = " + a.length);
    		System.out.println("b.length = " + b.length);
    		System.out.println("c.length = " + c.length);
    		System.out.println("d.length = " + d.length);
    		a = d;
    		System.out.println("a.length = " + a.length);
    
    		int[] e;
    		int[] f = new int[5];
    		System.out.println(Arrays.toString(f));
    		int[] g = new int[4];
    		for (int i = 0; i < g.length; i++) {
    			g[i] = i * i;
    		}
    		int[] h = { 11, 47, 93 };
    //		System.out.println("e.length = " + e.length);
    		System.out.println("f.length = " + f.length);
    		System.out.println("g.length = " + g.length);
    		System.out.println("h.length = " + h.length);
    		e = h;
    		System.out.println("e.length = " + e.length);
    		e = new int[] { 1, 2 };
    		System.out.println("e.length = " + e.length);
    	}
    }

数组a是一个尚未初始化的局部变量，在你对它正确的初始化之前，编译器不允许你用此引用做任何事情。数组b初始化为指向一个BerylliumSphere引用的数组，但其实并没有BerylliumSphere对象置于数组中。然而，仍然可以询问数组的大小，因为b指向一个合法的对象。这样做有一个小缺点：你无法知道在此数组中确切地有多少元素，因为length只表示数组能够容纳多少元素。也就是说，length是数组的大小，而不是实际保存的元素个数。新生成一个数组对象时，其中所有的引用被自动初始化为null；所以检查其中的引用是否为null，即可知道数组的某个位置是否存有对象。同样，基本类型的数组如果是数值型的，就被自动初始化为0；如果是字符型（char）的，就被自动初始化为（char）0；如果是布尔型（boolean），就被自动初始化为false。

数组c表明，数组对象在创建之后，随即将数组的各个位置都赋值为BerylliumSphere对象。数组d表明使用“聚集初始化”语法创建数组对象（隐式的使用new在堆中创建，就像数组c一样），并且以BerylliumSphere对象将其初始化的过程，这些操作只用了一条语句。

下一个数组初始化可以看作是“动态的聚集初始化”。数组d采用的聚集初始化操作必须在定义d的位置使用，但若使用第二种语法，可以在任意位置创建和初始化数组对象。例如，假设方法hide()需要一个BerylliumSphere对象的数组作为输入参数。可以如下调用：

hide(d);

但也可以动态的创建将要作为参数传递的数组：

hide(new BerylliumSphere[]{new BerylliumSphere(),

在许多情况下，此语法使得代码书写变得更方便了。

表达式a=d；说明如何将指向某个数组对象的引用赋给另一个数组对象，这与其他类型的对象引用没有什么区别。现在a与b都指向堆中的同一个数组对象。

ArrayOptions.java的第二部分说明，基本类型数组的工作方式与对象数组一样，不过基本类型的数组直接存储基本类型数据的值。

### 三、返回一个数组 ###

假设你要写一个方法，而且希望它返回的不止一个值，而是一组值。这对于C和C++这样的语言来说就有点困难，因为它们不能返回一个数组，而只能返回指向数组的指针。这会造成一些问题，因为它使得控制数组的生命周期变得很困难，并且容易造成内存泄漏。

在java中，你只是直接“返回一个数组”，而无需担心要为数组负责——只要你需要它，它就会一直存在，当你使用完后，垃圾回收器会清理掉它。

下例演示如何返回String型数组：

import java.util.Arrays;
    import java.util.Random;
    
    public class IceCream {
    	private static Random r = new Random(47);
    
    	static final String[] FLAVORS = { "Chocolate", "Strawberry", "Vanilla Fudge Swirl", "Mint Chip",
    			"Mocha Almond Fudge", "Rum Raisin", "Praline Cream", "Mud Pie" };
    
    	public static String[] flavorSet(int n) {
    		if (n > FLAVORS.length) {
    			throw new IllegalArgumentException("Set too big");
    		}
    		String[] results = new String[n];
    		boolean[] picked = new boolean[FLAVORS.length];
    		for (int i = 0; i < n; i++) {
    			int t;
    			do {
    				t = r.nextInt(FLAVORS.length);
    			} while (picked[t]);
    			results[i] = FLAVORS[t];
    			picked[t] = true;
    		}
    		return results;
    	}
    
    	public static void main(String[] args) {
    		for (int i = 0; i < 7; i++) {
    			System.out.println(Arrays.toString(flavorSet(3)));
    		}
    	}
    }

方法flavorSet()创建了一个名为results的String数组。此数组容量为n，由传入方法的参数决定。然后从数组FLAVORS中随机选择元素。存入results数组中，它是方法所最终返回的数组。返回一个数组与返回任何其他对象（实际上是返回引用）没什么区别。数组是在flavorSet()中被创建还是在别的地方被创建，这一点并不重要。当使用完毕后，垃圾回收器负责清理数组；而只要还需要它，此数组就会一直存在。

注意当flavorSet()随机选择各种数组元素“味道”时，它确保不会重复选择。由一个do循环不断进行随机选择，直到找出一个在数组picked中还不存在的元素。（当然，还会比较String以检查随机选择的元素是否已经在数组results中。）如果成功，将此元素加入数组，然后查找下一个（i递增）。

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