数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。 Java语言中提供的数组是用来存储固定大小的同类型元素。 你可以声明一个数组变量，如numbers[100]来代替直接声明100个独立变量number0，number1，…，number99。 Java数组的声明、创建和初始化，并给出其对应的代码。

声明数组变量

dataType[] arrayRefVar; // 首选的方法 //或 dataType arrayRefVar[]; // 效果相同，但不是首选方法 double[] myList; // 首选的方法 double myList[]; // 效果相同，但不是首选方法

注意: 建议使用dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

创建数组

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

一、使用dataType[arraySize]创建了一个数组。二、把新创建的数组的引用赋值给变量 arrayRefVar。 数组变量的声明，和创建数组可以用一条语句完成，如下所示： dataType[] arrayRefVar = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从0开始，所以索引值从0到arrayRefVar.length-1。 实例:

public class TestArray { public static void main(String[] args) { // 数组大小 int size = 10; // 定义数组 double[] myList = new double[size]; myList[0] = 5.6; myList[1] = 4.5; myList[2] = 3.3; myList[4] = 4.0; myList[5] = 34.33; myList[6] = 34.0; myList[7] = 45.45; myList[8] = 99.993; myList[9] = 11123; // 计算所有元素的总和 double total = 0; for (int i = 0; i < size; i++) { total += myList[i]; } System.out.println("总和为： " + total); } }

以上实例输出结果为：

总和为： 11354.173

下面的图片描绘了数组myList。这里myList数组里有10个double元素，它的下标从0到9。

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者foreach循环。

示例 public class TestArray { public static void main(String[] args) { double[] myList = {1.9, 2.9, 3.4, 3.5}; // 打印所有数组元素 for (int i = 0; i < myList.length; i++) { System.out.println(myList[i] + " "); } // 计算所有元素的总和 double total = 0; for (int i = 0; i < myList.length; i++) { total += myList[i]; } System.out.println("Total is " + total); // 查找最大元素 double max = myList[0]; for (int i = 1; i < myList.length; i++) { if (myList[i] > max) max = myList[i]; } System.out.println("Max is " + max); } }

以上实例编译运行结果如下：

1.9 2.9 3.4 3.5

数组作为函数的参数

数组可以作为参数传递给方法。例如，下面的例子就是一个打印int数组中元素的方法。

public static void printArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } }

下面例子调用printArray方法打印出 3，1，2，6，4和2

printArray(new int[]{3, 1, 2, 6, 4, 2});

数组作为函数的返回值

public static int[] reverse(int[] list) { int[] result = new int[list.length]; for (int i = 0, j = result.length - 1; i < list.length; i++, j--) { result[j] = list[i]; } return result; }

以上实例中result数组作为函数的返回值。

Arrays 类

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

给数组赋值：通过fill方法。

对数组排序：通过sort方法,按升序。

比较数组：通过equals方法比较数组中元素值是否相等。

查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

序号方法说明1public static int binarySearch(Object[] a, Object key)用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。2public static boolean equals(long[] a, long[] a2)如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。3public static void fill(int[] a, int val)将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。4public static void sort(Object[] a)对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

二维数组

获取全部元素

假设有一个矩阵为 5 行 5 列，该矩阵是由程序随机产生的 10 以内数字排列而成。下面使用二维数组来创建该矩阵，代码如下：

public class Test11 { public static void main(String[] args） { //创建一个二维矩阵 int[][] matrix=new int[5][5]; //随机分配值 for(int i=0;i<matrix.length;i++) { for(int j=0;j<matrix[i].length;j++) { matrix[i][j]=(int)(Math.random()*10); } } System.out.println("下面是程序生成的矩阵\n"); //遍历二维矩阵并输出 for(int k=0;k<matrix.length;k++) { for(int g=0;g<matrix[k].length;g++) { System.out.print(matrix[k][g]+""); } System.out.println(); } } }

在该程序中，首先定义了一个二维数组，然后使用两个嵌套的 for 循环向二维数组中的每个元素赋值。其中，Math.random() 方法返回的是一个 double 类型的数值，数值为 0.6、0.9 等，因此乘以 10 之后为 10 以内的整数。最后又使用了两个嵌套的 for 循环遍历二维数组，输出二维数组中的值，从而产生矩阵。

运行该程序的结果如下所示。

34565 96033 48741 10583 63985

获取整行元素

除了获取单个元素和全部元素之外，还可以单独获取二维数组的某一行中所有元素的值，或者二维数组中某一列元素的值。获取指定行的元素时，需要将行数固定，然后只遍历该行中的全部列即可。 例如：编写一个案例，接收用户在控制台输入的行数，然后获取该行中所有元素的值。代码如下：

public static void main(String[] args) { double[][] class_score={{100,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5}}; Scanner scan=new Scanner(System.in); System.out.println("当前数组只有"+class_score.length+"行，您想查看第几行的元素？请输入："); int number=scan.nextInt(); for(int j=0;j<class_score[number-1].length;j++) { System.out.println("第"+number+"行的第["+j+"]个元素的值是："+class_score[number-1][j]); } } 执行上述代码进行测试，输出结果如下所示。 当前数组只有4行，您想查看第几行的元素？请输入： 3 第3行的第[0]个元素的值是：100.0 第3行的第[1]个元素的值是：100.0 第3行的第[2]个元素的值是：99.5

获取整列元素

例如：编写一个案例，接收用户在控制台中输入的列数，然后获取二维数组中所有行中该列的值。代码如下：

public static void main(String[] args) { double[][] class_score={{100,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5}}; Scanner scan=new Scanner(System.in); System.out.println("您要获取哪一列的值？请输入："); int number=scan.nextInt(); for(int i=0;i<class_score.length;i++) { System.out.println("第 "+(i+1)+" 行的第["+number+"]个元素的值是"+class_score[i][number]); } }

执行上述代码进行测试，如下所示。

您要获取哪一列的值？请输入：

2 第 1 行的第[2]个元素的值是99.0 第 2 行的第[2]个元素的值是97.0 第 3 行的第[2]个元素的值是99.5 第 4 行的第[2]个元素的值是98.5

数组排序

Java sort()方法

使用 java.util.Arrays 类中的 sort() 方法对数组进行排序分为以下两步：

导入 java.util.Arrays 包。使用 Armys.sort(数组名) 语法对数组进行排序，排序规则是从小到大，即升序。

例 1 假设在数组 scores 中存放了 5 名学生的成绩，现在要实现从低到高排列的功能。在这里使用 Arrays.sort() 方法来实现，具体代码如下：

import java.util.Arrays; public class Test23 { public static void main(String[] args) { //定义含有5个元素的数组 double[] scores=new double[]{78,45,85,97,87}; System.out.println("排序前数组内容如下："); //对scores数组进行循环遍历 for(int i=0;i<scores.length;i++) { System.out.print(scores[i]+"\t"); } System.out.println("\n排序后的数组内容如下："); //对数组进行排序 Arrays.sort(scores); //遍历排序后的数组 for(int j=0;j<scores.length;j++) { System.out.print(scores[j]+"\t"); } } }

如上述代码所示，要对一个数组进行升序排列，只需要调用 Arrays.sort() 方法即可。运行后的输出结果如下所示。

排序前数组内容如下： 78.0 45.0 85.0 97.0 87.0 排序后的数组内容如下： 45.0 78.0 85.0 87.0 97.0

Java冒泡排序法（Bubble Sort）

/* * 冒泡排序 * @author 晓宇码匠 */ public class BubbleSort { 　　public static void main(String[] args) { 　　　　int[] arr={6,3,8,2,9,1}; 　　　　System.out.println("排序前数组为："); 　　　　for(int num:arr){ 　　　　　　System.out.print(num+" "); 　　　　} 　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数 　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次 　　　　　　　　if(arr[j]>arr[j+1]){ 　　　　　　　　　　int temp=arr[j]; 　　　　　　　　　　arr[j]=arr[j+1]; 　　　　　　　　　　arr[j+1]=temp; 　　　　　　　　} 　　　　　　} 　　　　} 　　　　System.out.println(); 　　　　System.out.println("排序后的数组为："); 　　　　for(int num:arr){ 　　　　　　System.out.print(num+" "); 　　　　} 　　} }

Java数组排序：Java快速排序（Quicksort）法

public void quickSort(int[] arr, int low, int high) { // low,high 为每次处理数组时的首、尾元素索引 //当low==high是表示该序列只有一个元素，不必排序了 if (low >= high) { return; } // 选出哨兵元素和基准元素。这里左边的哨兵元素也是基准元素 int i = low, j = high, base = arr[low]; while (i < j) { //右边哨兵从后向前找 while (arr[j] >= base && i < j) { j--; } //左边哨兵从前向后找 while (arr[i] <= base && i < j) { i++; } swap(arr,i,j); //交换元素 } swap(arr,low,j); //基准元素与右哨兵交换 //递归调用，排序左子集合和右子集合 quickSort(arr,low,j-1); quickSort(arr,j+1,high); } private void swap(int[] arr, int i, int j) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; }

Java数组排序：Java选择排序法

package sorting; /** * 选择排序 * 平均O(n^2),最好O(n^2),最坏O(n^2);空间复杂度O(1);不稳定;简单 * @author 晓宇码匠 * */ public class SelectionSort { public static void selectionSort(int[] a) { int n = a.length; for (int i = 0; i < n; i++) { int k = i; // 找出最小值的下标 for (int j = i + 1; j < n; j++) { if (a[j] < a[k]) { k = j; } } // 将最小值放到未排序记录的第一个位置 if (k > i) { int tmp = a[i]; a[i] = a[k]; a[k] = tmp; } } } public static void main(String[] args) { int[] b = { 49, 38, 65, 97, 76, 13, 27, 50 }; selectionSort(b); for (int i : b) System.out.print(i + " "); } }

Java数组排序：Java直接插入法

package sort; /** * 直接插入排序 的实现 * 稳定算法 * @author 晓宇码匠 * */ public class InsertSort { public static void main(String[] args) { // TODO Auto-generated method stub int a[] = {3,1,5,7,2,4,9,6}; new InsertSort().insertSort(a); } /** * 直接插入排序算法的实现 * @param a */ private void insertSort(int[] a) { // TODO Auto-generated method stub System.out.println("———————————————————直接插入排序算法—————————————————————"); int n = a.length; int i,j; for(i=1;i<n;i++){ /** * temp为本次循环待插入有序列表中的数 */ int temp = a[i]; /** * 寻找temp插入有序列表的正确位置 */ for(j=i-1;j>=0 && a[j]>temp;j--){ /** * 元素后移，为插入temp做准备 */ a[j+1] = a[j]; } /** * 插入temp */ a[j+1] = temp; print(a,n,i); } printResult(a,n); } /** * 打印排序的最终结果 * @param a * @param n */ private void printResult(int[] a, int n){ System.out.print("最终排序结果："); for(int j=0;j<n;j++){ System.out.print(" "+a[j]); } System.out.println(); } /** * 打印排序的每次循环的结果 * @param a * @param n * @param i */ private void print(int[] a, int n, int i) { // TODO Auto-generated method stub System.out.print("第"+i+"次："); for(int j=0;j<n;j++){ System.out.print(" "+a[j]); } System.out.println(); } }

总结，数组具有以下特点：

数组可以是一维数组、二维数组或多维数组。数值数组元素的默认值为 0，而引用元素的默认值为 null。交错数组是数组的数组，因此，它的元素是引用类型，初始化为 null。交错数组元素的维度和大小可以不同。数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。数组元素可以是任何类型，包括数组类型。数组类型是从抽象基类 Array 派生的引用类型。

Java设计基础及面向对象导向