无论使用的数组属于什么类型，数组标识符实际都是指向真实对象的一个句柄。那些对象本身是在内存“堆”里创建的。堆对象既可“隐式”创建（即默认产生），亦可“显式”创建（即明确指定，用一个new表达式）。堆对象的一部分（实际是我们能访问的唯一字段或方法）是只读的length（长度）成员，它告诉我们那个数组对象里最多能容纳多少元素。对于数组对象，“[]”语法是我们能采用的唯一另类访问方法。
　　
　　下面这个例子展示了对数组进行初始化的不同方式，以及如何将数组句柄分配给不同的数组对象。它也揭示出对象数组和基本数据类型数组在使用方法上几乎是完全一致的。唯一的差别在于对象数组容纳的是句柄，而基本数据类型数组容纳的是具体的数值（若在执行此程序时遇到困难，请参考第3章的“赋值”小节）：
　　
　　
　　//: arraysize.java
　　// initialization & re-assignment of arrays
　　package c08;
　　
　　class weeble {} // a small mythical creature
　　
　　public class arraysize {
　　　public static void main(string[] args) {
　　　　// arrays of objects:
　　　　weeble[] a; // null handle
　　　　weeble[] b = new weeble[5]; // null handles
　　　　weeble[] c = new weeble[4];
　　　　for(int i = 0; i < c.length; i++)
　　　　　c[i] = new weeble();
　　　　weeble[] d = {
　　　　　new weeble(), new weeble(), new weeble()
　　　　};
　　　　// compile error: variable a not initialized:
　　　　//!system.out.println("a.length=" + a.length);
　　　　system.out.println("b.length = " + b.length);
　　　　// the handles inside the array are
　　　　// automatically initialized to null:
　　　　for(int i = 0; i < b.length; i++)
　　　　　system.out.println("b[" + i + "]=" + b[i]);
　　　　system.out.println("c.length = " + c.length);
　　　　system.out.println("d.length = " + d.length);
　　　　a = d;
　　　　system.out.println("a.length = " + a.length);
　　　　// java 1.1 initialization syntax:
　　　　a = new weeble[] {
　　　　　new weeble(), new weeble()
　　　　};
　　　　system.out.println("a.length = " + a.length);
　　
　　　　// arrays of primitives:
　　　　int[] e; // null handle
　　　　int[] f = new int[5];
　　　　int[] g = new int[4];
　　　　for(int i = 0; i < g.length; i++)
　　　　　g[i] = i*i;
　　　　int[] h = { 11, 47, 93 };
　　　　// compile error: variable e not initialized:
　　　　//!system.out.println("e.length=" + e.length);
　　　　system.out.println("f.length = " + f.length);
　　　　// the primitives inside the array are
　　　　// automatically initialized to zero:
　　　　for(int i = 0; i < f.length; i++)
　　　　　system.out.println("f[" + i + "]=" + f[i]);
　　　　system.out.println("g.length = " + g.length);
　　　　system.out.println("h.length = " + h.length);
　　　　e = h;
　　　　system.out.println("e.length = " + e.length);
　　　　// java 1.1 initialization syntax:
　　　　e = new int[] { 1, 2 };
　　　　system.out.println("e.length = " + e.length);
　　　}
　　} ///:~
　　here’s the output from the program:
　　
　　
　　b.length = 5
　　b[0]=null
　　b[1]=null
　　b[2]=null
　　b[3]=null
　　b[4]=null
　　c.length = 4
　　d.length = 3
　　a.length = 3
　　a.length = 2
　　f.length = 5
　　f[0]=0
　　f[1]=0
　　f[2]=0
　　f[3]=0
　　f[4]=0
　　g.length = 4
　　h.length = 3
　　e.length = 3
　　e.length = 2
　　
　　其中，数组a只是初始化成一个null句柄。此时，编译器会禁止我们对这个句柄作任何实际操作，除非已正确地初始化了它。数组b被初始化成指向由weeble句柄构成的一个数组，但那个数组里实际并未放置任何weeble对象。然而，我们仍然可以查询那个数组的大小，因为b指向的是一个合法对象。这也为我们带来了一个难题：不可知道那个数组里实际包含了多少个元素，因为length只告诉我们可将多少元素置入那个数组。换言之，我们只知道数组对象的大小或容量，不知其实际容纳了多少个元素。尽管如此，由于数组对象在创建之初会自动初始化成null，所以可检查它是否为null，判断一个特定的数组“空位”是否容纳一个对象。类似地，由基本数据类型构成的数组会自动初始化成零（针对数值类型）、null（字符类型）或者false（布尔类型）。
　　
　　数组c显示出我们首先创建一个数组对象，再将weeble对象赋给那个数组的所有“空位”。数组d揭示出“集合初始化”语法，从而创建数组对象（用new命令明确进行，类似于数组c），然后用weeble对象进行初始化，全部工作在一条语句里完成。
　　
　　下面这个表达式：
　　
　　a = d;
　　
　　向我们展示了如何取得同一个数组对象连接的句柄，然后将其赋给另一个数组对象，就象我们针对对象句柄的其他任何类型做的那样。现在，a和d都指向内存堆内同样的数组对象。
　　
　　java 1.1加入了一种新的数组初始化语法，可将其想象成“动态集合初始化”。由d采用的java 1.0集合初始化方法则必须在定义d的同时进行。但若采用java 1.1的语法，却可以在任何地方创建和初始化一个数组对象。例如，假设hide()方法用于取得一个weeble对象数组，那么调用它时传统的方法是：
　　
　　hide(d);
　　
　　但在java 1.1中，亦可动态创建想作为参数传递的数组，如下所示：
　　
　　hide(new weeble[] {new weeble(), new weeble() });
　　
　　这一新式语法使我们在某些场合下写代码更方便了。
　　
　　上述例子的第二部分揭示出这样一个问题：对于由基本数据类型构成的数组，它们的运作方式与对象数组极为相似，只是前者直接包容了基本类型的数据值。
　　
　　1. 基本数据类型集合
　　
　　集合类只能容纳对象句柄。但对一个数组，却既可令其直接容纳基本类型的数据，亦可容纳指向对象的句柄。利用象integer、double之类的“封装器”类，可将基本数据类型的值置入一个集合里。但正如本章后面会在wordcount.java例子中讲到的那样，用于基本数据类型的封装器类只是在某些场合下才能发挥作用。无论将基本类型的数据置入数组，还是将其封装进入位于集合的一个类内，都涉及到执行效率的问题。显然，若能创建和访问一个基本数据类型数组，那么比起访问一个封装数据的集合，前者的效率会高出许多。
　　
　　当然，假如准备一种基本数据类型，同时又想要集合的灵活性（在需要的时候可自动扩展，腾出更多的空间），就不宜使用数组，必须使用由封装的数据构成的一个集合。大家或许认为针对每种基本数据类型，都应有一种特殊类型的vector。但java并未提供这一特性。某些形式的建模机制或许会在某一天帮助java更好地解决这个问题（注释①）。
　　
　　①：这儿是c++比java做得好的一个地方，因为c++通过template关键字提供了对“参数化类型”的支持。