java数组声明语句代码,Java 数组（学习 Java 编程语言 013-014）

数组存储相同类型的序列。

1. 数组声明

数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标(index，或称索引)可以访问数组中的每一个值。

在声明数组变量时，需要指出数组类型(数据元素类型紧跟 [])和数组变量的名字。

一旦创建了数组，就不能再改变它的长度，可以改变单个的数组元素。如果程序运行中需要经常扩展数组的长度，就应该使用另一种数据结构——数组列表(array list)。

下面声明了整型数组 a:

int[] a;

这条语句只声明了变量 a，并没有将 a 初始化为一个真正的数组。

使用 new 运算符创建数组:

int[] a = new int[100];

这条语句声明并初始化了一个可以存储 100 个整数的数组。

数组长度不要求是常量：new int[n] 会创建一个长度为 n 的数组。

可以使用下面两种形式声明数组

int[] a;

或

int a[];

大多数 Java 应用程序员喜欢使用第一种风格，因为它将类型 int[] (整型数组)与变量名清晰的分开了。

Java 还提供了一种创建数组对象并同时提供初始值的简写形式：

int[] arr = {1, 2, 3, 4, 5, 6, 7};

这个语法中不需要使用 new，甚至不需要指定长度。

最后一个值后面允许有逗号，如果你要不断为数组增加值，这会很方便：

String[] authors = {

"James Gosling",

"Bill Joy",

"Guy Steele",

// add more names here and put a comma after each name

};

声明一个匿名数组：

new int[] {7, 8, 9};

会分配一个新数组并填入大括号中提供的值。它会统计初始值得个数，并相应的设置数组大小。

使用匿名数组重新初始化一个数组而无需创建新变量：

int[] arr = {1, 2, 3, 4, 5, 6, 7};

arr = new int[] {7, 8, 9};

是下列语句的简写:

int[] arr = {1, 2, 3, 4, 5, 6, 7};

int[] arr2 = {7, 8, 9};

arr = arr2;

注释：在 Java 中，允许有长度为 0 的数组。在编写一个结果为数组的方法时，如果碰巧结果为空，这样一个长度为 0 的数组就很有用。

创建长度为 0 的数组：

new elementType[0];

或

new elementTyp[]{}

注意，长度为 0 的数组与 null 并不不同。

2. 访问数组

int[] arr = new int[100];

数组 arr 的数组元素的下标为从 0~99(不是 1~100)。

各类型数组创建后的初始值：

创建一个数字数组时，所有元素都初始化为 0。

创建一个 boolean 数组的元素会初始化为 false。

创建一个对象数组的元素则初始化为一个特殊值 null, 表示这些元素(还)未存放任何对象。

一旦创建了数组，就可以在数组中填入元素。例如，使用一个循环：

int[] arr = new int[100];

for(int i = 0; i < 100; i++) {

arr[i] = i;

}

要想获得数组中的元素个数，可以使用 array.length:

int[] arr = new int[7];

for(int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

如果创建了一个 100 个元素的数组，并且试图访问元素 arr[100] (或在 0 ~ 99 之外的任何下标)，就会引发 “array index out of bounds” 异常。

3. for each 循环

Java 有一种功能很强的循环结构，可以用来依次处理数组(或者其他元素集合)中的每个元素，而不必考虑指定下标值。

这种增强的 for 循环的语句格式为：

for (variable : collection) statement

它定义一个变量用于暂存集合中的每一个元素，并执行相应的语句(当然，也可以是语句块)。collection 这一集合表达式必须是一个数组或者是一个实现了 Iterable 接口的类对象(例如 ArrayList)。例如：

int [] a = {1, 2, 3};

for (int element : a) {

System.out.println(element);

}

这个循环应该读作“循环 a 中的每一个元素”(for each element in a)。Java 语言的设计者认为应该使用诸如 foreach、in 这样的关键字，但这种循环语句并不是最初就包含在 Java 语言中的，而是后面添加进去的，而且没有人希望破坏已经包含同名(例如 System.in)方法或变量的旧代码。

当然，使用传统的 for 循环也可以获得同样的效果：

int [] a = {1, 2, 3};

for (int i = 0; i < a.length; i++) {

System.out.println(a[i]);

}

但是，for each 循环语句显得更加简洁、更不易出错，因为你不必为下标的起始值和终止值而操心。

注释，for each 循环语句的循环变量将会遍历数组中的每个元素，而不是下标值。

如果需要处理一个集合中的所有元素，for each 循环语句相对于传统循环语句所做的改进让人欣喜。然而，在很多情况下还是需要使用传统的 for 循环。例如，如果不希望遍历整个集合，或者在循环内部需要使用下标值。

提示：有一个更加简单的方式可以打印数组中的所有值，即利用 Arrays 类的 toString 方法。调用 Arrays.toString(a)，返回一个包含数组元素的字符串，这些元素包围在中括号内，并用逗号分隔，例如，“[2, 3, 5, 7, 11, 13]”。要想打印数组，只需要调用

System.out.println(Arrays.toString(a));

4. 数组拷贝

在 Java 中，允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组。

int[] arr1 = new int[] {1, 2, 3, 4, 5, 6, 7};

int[] arr2 = arr1;

arr1[0] = 2;

System.out.println("arr1: " + Arrays.toString(arr1));

System.out.println("arr2: " + Arrays.toString(arr2));

输出结果:

arr1: [2, 2, 3, 4, 5, 6, 7]

arr2: [2, 2, 3, 4, 5, 6, 7]

如果希望将一个数组的所有值拷贝到一个新的数组中去，就要使用 Arrays 类的 copyOf 方法。如果数组元素是数值型，那么多余的元素将被赋值为 0；如果数组元素是布尔型，则将赋值为 false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。

int[] arr1 = new int[] {1, 2, 3, 4, 5, 6, 7};

int[] arr2 = Arrays.copyOf(arr1, arr1.length);

int[] arr3 = Arrays.copyOf(arr1, 2 * arr1.length);

arr1[0] = 2;

System.out.println("arr1: " + Arrays.toString(arr1));

System.out.println("arr2: " + Arrays.toString(arr2));

System.out.println("arr3: " + Arrays.toString(arr3));

输入结果:

arr1: [2, 2, 3, 4, 5, 6, 7]

arr2: [1, 2, 3, 4, 5, 6, 7]

arr3: [1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0]

5. 命令行参数

每一个 Java 应用程序都有一个带 String arg[] 参数的 main 方法。这个参数表明 main 方法将接收一个字符串数组，也就是命令行上指定的参数。

来看下面的例子：

public class Message {

public static void main(String[] args) {

if(args.length == 0 || args[0].equals("-h")) {

System.out.print("Hello,");

} else if(args[0].equals("-g")){

System.out.print("Goodbye,");

}

for(int i = 1; i < args.length; i++) {

System.out.print(" " + args[i]);

}

System.out.println("!");

}

}

使用下面的命令：

java Message -g cruel world

此时 args 数组将包含下列内容：

args[0]: "-g"

args[1]: "cruel"

args[2]: "world"

这个程序会显示下面这个消息：

Goodbye, cruel world!

在 Java 应用程序的 main 方法中，程序名并没有存储在 args 数组中。例如，当从命令行使用以下命令运行程序时

java Message -h world

args[0] 是 “-h”，而不是 “Message” 或 “java”。

6. 数组排序

可以使用 Arrays 类中的 sort 方法对数组进行排序。这个方法使用了优化的快速排序(QuickSort)方法。快速排序算法对于大多数数据集合来说都是效率比较高的。Arrays 还提供了另外一些很便捷的方法。

int[] arr = {3, 1, 7, 5, 2, 4, 6};

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));

// 打印 [1, 2, 3, 4, 5, 6, 7]

java.util.Arrays 1.2

static String toString(xxx[] a) 5

返回包含 a 中元素的一个字符串，这些元素用中括号包围，并用逗号分隔。

数组元素类型 xxx 可以是任何类型。

static type copyOf(xxx[] a, int length) 6

static type copyOfRange(xxx[] a, int start, int end)

返回与 a 类型相同的一个数组，其长度为 length 或者 end-start，数组元素为 a 的值。如果 end 大于 a.length，结果会填充 0、false 或 null。

数组元素类型 xxx 可以是任何类型。

* 参数 start: 起始下标(包含这个值)

* 参数 end: 终止下标(不包含这个值)。这个值可能大于 a.length 。在这种情况下，结果为 0、false 或 null。

* 参数 length: 拷贝的数组长度。如果 length 值大于 a.length，结果为 0、false 或 null 值；否则，数组中只有前面 length 个数据元素的拷贝值。

static void sort(xxx[] a)

使用优化的快速排序算法对数组进行排序。

数组元素类型 xxx 可以是任何类型。

static int binarySearch(xxx[] a, xxx v)

static int binarySearch(xxx[] a, int stat, int end, xxx v)

使用二分搜索算法在有序数组 a 中查找值 v。如果找到 v，则返回相应的下标值；否则，返回一个负数值 r。-r-1 是 v 应插入的位置(为保持 a 有序)。

数组元素类型 xxx 可以是任何类型。

* 参数 start: 起始下标(包含这个值)

* 参数 end: 终止下标(不包含这个值)

* 参数 v 同 a 的元素类型相同的值

static void fill(xxx[] a, xxx v)

将数组的所有数据元素设置为 v。

数组元素类型 xxx 可以是任何类型。

* 参数 v 与 a 数据元素类型相同的一个值。

static boolean equals(xxx[] a, xxx[] b)

如果两个数组大小相同，并且下标相同的元素都对应相等，返回true。

数组元素类型 xxx 可以是任何类型。

7. 多维数组

多维数组将使用多个下标访问数组元素，它适用于表示表格或更加复杂的排列方式。

在 Java 中，声明一个二维数组：

double[][] balances;

对数组初始化前是不能使用的。下面是完成初始化的代码：

balances = new double[10][10];

一旦数组初始化，就可以利用两个中括号访问各个元素，例如，balances[i][j]。

如果事先知道数组的元素，可以不调用 new，直接使用简写形式对多维数据进行初始化：

int[][] a = {

{16, 3, 2, 13},

{5, 10, 11, 8},

{9, 6, 7, 12},

{4, 15, 14, 1}

};

for each 循环语句不能自动处理二维数组的每一个元素。它会循环处理行，而这些行本身就是一维数组。要访问二维数组 a 的所有元素，需要使用两个嵌套的循环：

for (double[] row : a)

for(double value : row)

do something with value

要想快速打印一个二维数组元素列表，可以调用：

System.out.println(Arrays.deepToString(a));

输出格式为:

[[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]]

8. 不规则数组

Java 实际上没有多维数组，只有一维数组。多维数组被解释为“数组的数组”。

可以方便地构造一个“不规则”数组，即数组的每一行有不同的长度。

要想创建一个不规则数组：

首先需要分配这个数组包含的这行。

int[][] odds = new int[SIZE][];

然后分配这些行。

for(int n = 0; n < SIZE; n++) {

odds[n] = new int[n + 1];

}

利用不规则数组打印 99 乘法表：

int size = 9;

String[][] arr = new String[size][];

for(int i = 0; i < size; i++) {

arr[i] = new String[i + 1];

for(int j = 0; j < arr[i].length; j++) {

arr[i][j] = String.format("%d*%d=%d", j + 1, i + 1, (i+ 1) * (j + 1));

}

}

for(String[] row : arr) {

for(String value : row) {

System.out.printf("%-8s", value);

}

System.out.println();

}

打印结果：

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

1*4=4 2*4=8 3*4=12 4*4=16

1*5=5 2*5=10 3*5=15 4*5=20 5*5=25

1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36

1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49

1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64

1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81