学完复杂的泛型，来学点简单的。本文介绍 Java 数组的相关知识。
1. 基本概念
数组是一个容器对象，它包含固定数量的单个类型的值。 创建数组时，将建立数组的长度。 创建后，其长度是固定的。
数组中的每个项成为元素，每个元素由其数组索引访问。
举个简单例子：
class ArrayDemo {
public static void main(String[] args) {
// 声明一个整数数组
int[] anArray;
// 为10个整数分配内存
anArray = new int[10];
// 初始化第一个元素
anArray[0] = 100;
// 初始化第2个元素
anArray[1] = 200;
// 以此类推
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
System.out.println("Element at index 0: " + anArray[0]);
System.out.println("Element at index 1: " + anArray[1]);
System.out.println("Element at index 2: " + anArray[2]);
System.out.println("Element at index 3: " + anArray[3]);
System.out.println("Element at index 4: " + anArray[4]);
System.out.println("Element at index 5: " + anArray[5]);
System.out.println("Element at index 6: " + anArray[6]);
System.out.println("Element at index 7: " + anArray[7]);
System.out.println("Element at index 8: " + anArray[8]);
System.out.println("Element at index 9: " + anArray[9]);
}
}
/*输出
Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
*/
1.1 声明数组
通过以下代码声明一个数组：
int[] anArray;
可以看出，与其他类型的变量声明相似，数组声明有两个部分：数组类型和数组名称。数组类型写法为 "type[]"，数组名称可以是任意合法名称。
同样的，声明实际上并不创建数组，只是告诉编译器该变量是指定类型的数组。
对于其他类型的数组，创建方式也是如此：
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
另外，还有另外一种不常用写法，将[]放在后面：
float anArrayOfFloats[];
1.2 创建、初始化以及访问
创建数组的一种方法是使用 new 操作符。
anArray = new int[10];
之后，通过索引访问数组元素，并初始化：
anArray[0] = 100;
anArray[1] = 200;
anArray[2] = 300;
System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);
或者，可以在创建的时候同时进行初始化：
int[] anArray = {
100, 200, 300,
400, 500, 600,
700, 800, 900, 1000
};
另外，还可以使用两个或多个括号[] 如String[][] names 声明一个多维数组。同样的每个元素必须由相应的索引值访问。
class MultiDimArrayDemo {
public static void main(String[] args) {
String[][] names = {
{"Mr. ", "Mrs. ", "Ms. "},
{"Smith", "Jones"}
};
// Mr. Smith
System.out.println(names[0][0] + names[1][0]);
// Ms. Jones
System.out.println(names[0][2] + names[1][1]);
}
}
/*输出
Mr. Smith
Ms. Jones
*/
然后，可以通过数组的 length 属性来确定数组的大小。
未初始化时，引用类型为 null，基本数据类型为零：
| 基本类型 | 默认值 |
|---|---|
| boolean | false |
| char | '\uoooo'(null) |
| byte | (byte)0 |
| short | (short)0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
2. 数组为什么特殊
数组和其他种类的容器之间的区别：
- 效率
- 类型
- 保存基本类型的能力
补充一些特性：
-
数组是一种效率最高的存储和随机访问对象引用序列的方式。
数组本身就是一个简单的线性序列，这使得元素访问非常快。当然代价是数组对象的大小被固定，并且不可改变。
数组之所以优于泛型之前的容器，就是因为可以创建一个数组去持有某种具体类型，这意味着可以通过编译器检查，来防止插入错误类型和抽取不当类型。
数组可以持有基本类型，而泛型之前的容器则不能，有了泛型之后，通过自动包装机制，容器看起来能够持有基本类型。
3. 数组与泛型
能实例化具有参数化类型的数组
Peel<Banana>[] peels = new Peel<Banana>[10];// 编译错误
擦除会移除参数类型信息，而数组本身必须知道它们所持有的确切类型，以强制保证类型安全
但是，可以参数化数组本身的类型：
public <T> T[] f(T[] arg) {
return arg;
}
编译器虽然不允许实例化泛型数组，但是可以创建这种数组的引用：
List<String>[] ls; //合法
ls = new ArrayList<String>[10]; //编译错误
尽管不能黄建始及的持有泛型的数组对象，但是可以创建非泛型的数组，然后将其转型：
public class ArrayOfGenerics {
@SupressWarning("unchecked")
public static void main(String... args) {
List<String> ls;
List[] la = new List[10];
ls = (List<String>[]) la; //unchecked warning
ls[0] = new ArrayList<String>();
}
}
数组是协变类型的， 因此 List<String>[] 也是一个 Object[]，可以将一个 ArrayList<String> 赋值到数组中。
4. 数组操作
本小节介绍以下 Java 内置的一些对数组操作的方法
4.1 复制数组
System类有一个arraycopy方法，可以使用它来有效地将数据从一个数组复制到另一个数组：
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
两个Object参数指定要从中复制的数组和要复制到的数组。 三个int参数指定源数组中的起始位置，目标数组中的起始位置以及要复制的数组元素的数量。
class ArrayCopyDemo {
public static void main(String[] args) {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd' };
char[] copyTo = new char[7];
System.arraycopy(copyFrom, 2, copyTo, 0, 7);
System.out.println(new String(copyTo));
}
}
/*输出
caffein
*/
4.2 Arrays 类
java.util.Arrays类中的方法提供的一些有用的操作是：
- 在数组中搜索特定值以获取其所在的索引（
binarySearch方法）。 - 比较两个数组以确定它们是否相等（
equals方法）。 - 填充数组以在每个索引处放置特定值（
fill方法）。 - 按升序对数组进行排序。 这可以使用
sort方法顺序完成，也可以使用Java SE 8中引入的parallelSort方法同时完成。在多处理器系统上对大型数组进行并行排序比顺序数组排序更快。
