java输入数组arrays格式_Java 数组

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

数组声明

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

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

int[] a;

这条语句只声明了变量 a，并没有将 a 初始化为一个真正的数组。应该使用 new 运算符创建数组。

int[] a = new int[100];

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

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

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

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

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

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

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

int[] a;

或

int a[];

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

匿名数组

可以声明一个匿名数组：

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;

创建长度为 0 的数组：

new elementType[0];

或

new elementTyp[]{}

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

访问数组

int[] arr = new int[100];

数组 arr 的数组元素的下标为从 0~99(不是 1~100)。一旦创建了数组，就可以在数组中填入元素。例如，使用一个循环：

int[] arr = new int[100];

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

arr[i] = i;

}

创建一个数字数组时，所有元素都初始化为0。boolean 数组的元素会初始化为 false。 对象数组的元素则初始化为一个特殊值 null, 这表示这些元素(还)未存放任何对象。

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

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

int[] arr = new int[7];

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

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

}

数组拷贝

在 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]

命令行参数

每一个 Java 应用程序都有一个带 String arg[] 参数的 main 方法。这个参数表明 main 方法将接收一个字符串数组(程序名没有存储在 args 数组中)，这就是命令行上指定的参数。来看下面的例子：

public class Message {

public static void main(String[] args) {

if(args.length == 0) {

System.out.println("没有命令行参数！");

} else {

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

System.out.println("第 " + (i + 1) + " 参数: " + args[i]);

}

}

}

}

使用下面的命令：

java Message Hello Xiang017 !

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

args[0]: "Hello"

args[1]: "Xiang017"

args[2]: "!"

这个程序将输出：

第 1 参数: Hello

第 2 参数: Xiang017

第 3 参数: !

数组排序

在 Java 中，可以实用 Arrays 类中的 sort 方法对数组进行排序。这个方法使用了优化的快速排序(QuickSort)方法。快速排序算法对于大多数数据集合来说都是效率比较高的。

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(type[] a) 5

返回包含 a 中数据元素的字符串，这些数据元素被放在括号内，并用逗号分隔。

* 参数 a 类型为 int、long、short、char、byte、boolean、float 和 double 的数组。

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

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

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

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

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

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

static void sort(type[] a)

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

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

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

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

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

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

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

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

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

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

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

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

多维数组

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

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

double[][] balances;

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

balances = new double[NYEARS][NARTES];

如果事先知道数组的元素，可以不调用 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]]

不规则数组

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("%-12s", 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