数组对于每一门编辑应语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java语言中提供的数组是用来存储固定大小的同类型元素。 可以声明一个数组变量，如numbers[100]来代替直接声明100个独立变量number0，number1，....，number99。
一、数组基础
下面介绍Java数组的声明、创建和初始化，并给出其对应的代码：
1、声明数组变量
首先必须声明数组变量，才能在程序中使用数组。在声明数组变量时，需要指出数组类型（数组类型紧跟[]）和数组变量的名字。
下面是声明数组变量的语法（以int 型为例）：
- int[] a; // 首选的方法
- int a[]; // 效果相同，但不是首选方法
2、创建数组
Java语言使用new操作符来创建数组，语法如下：
- arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事：
一、使用dataType[arraySize]创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
- dataType[] arrayRefVar = new dataType[arraySize];
另外，你还可以使用如下的方式创建数组。
- Type[] arrayRefVar = {value0, value1, ..., valuek};
实例
下面的语句首先声明了一个数组变量myList，接着创建了一个包含10个double类型元素的数组，并且把它的引用赋值给myList变量。
- double[] myList = new double[10];
3、处理数组
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者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
- Total is 11.7
- Max is 3.5
JDK 1.5 引进了一种新的循环类型，被称为foreach循环或者加强型循环，它能在不使用下标的情况下遍历数组。
示例
该实例用来显示数组myList中的所有元素：
- public class TestArray {
- public static void main(String[] args) {
- double[] myList = {1.9, 2.9, 3.4, 3.5};
- //打印所有数组元素
- for (double element: myList) {
- System.out.println(element);
- }
- }
- }
- 1.9
- 2.9
- 3.4
- 3.5
4、数据拷贝
在Java中，允许讲一个数组变量拷贝给另一个数组变量。这里有两种方法：
1）将一个数组所有值拷贝到新的数组中去，使用Arrays 类的copyOf 方法：
- int[] copiedLucyNumbers = Arrays.coyOf (luclyNumbers, luckyNumbers.length);
2）用System类的arraycopy方法讲一个数组的元素拷贝到另一个数组中。其语法格式为：
- System.arraycopy (from, fromIndex, to, toIndex, count );
参数：
from - 源数组。
fromIndex - 源数组中的起始位置。
to- 目标数组。
toIndex- 目标数据中的起始位置。
count- 要复制的数组元素的数量。
5、数组作为函数的参数
数组可以作为参数传递给方法。例如，下面的例子就是一个打印int数组中元素的方法。
- public static void printArray(int[] array) {
- for (int i = 0; i < array.length; i++) {
- System.out.print(array[i] + " ");
- }
- }
- 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数组作为函数的返回值。
6、Arrays 类
java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：
1、给数组赋值：通过fill方法。
2、对数组排序：通过sort方法,按升序。
3、比较数组：通过equals方法比较数组中元素值是否相等。
4、查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作
具体说明请查看下表：
| 序号 | 方法和说明 |
|---|---|
| 1 | public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 |
| 2 | public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 3 | public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 4 | public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
二、一维数组
1、一维数组的声明
使用一个数据时，必须要对其进行声明，这个道理对于数组来说也一样，数组在使用之前也必须先声明。先看下面的代码，是如何声明一个变量的。
- int a;
- int a[];
基本类型数组的声明有几种形式：
- int a[];
- int[] a;
2、一维数组的初始化
数组的初始化分为静态初始化和动态初始化：静态初始化是在声明数组的同时进行赋值; 动态初始化是在声明数组后在对其进行赋值。
1)、静态初始化
- int intArray[]={1,2,3,4};
- String stringArray[]={"abc", "How", "you"};
- intArray = new int[5];
- String stringArray[ ];
- String stringArray = new String[3];/*为数组中每个元素开辟引用空间(32位) */
- stringArray[0]= new String("How");//为第一个数组元素开辟空间
- stringArray[1]= new String("are");//为第二个数组元素开辟空间
- stringArray[2]= new String("you");// 为第三个数组元素开辟空间
3、一维数组元素的引用
一维数组元素的引用方式为：
- arrayName[index]
index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。
在编写程序的过程中，如果要引用数组的长度，一般是使用变量“length”，在程序中一般是使用下列格式：
数组名.length
示例：创建一个拥有 10 个元素的整数型数组 a，并通过 a[i]=i*i 为每个数组元素赋值，最后将结果输出。
- public class arrary1{
- public static void main(String[] args){
- int[] a;
- a = new int[10];
- int i;
- for(i=0;i<10;i++){
- System.out.println("a[i]="+(i*i));
- }
- }
- }
- a[0]=0
- a[1]=1
- a[2]=4
- a[3]=9
- a[4]=16
- a[5]=25
- a[6]=36
- a[7]=49
- a[8]=64
- a[9]=81
几点说明：
1、数组是对象类型数据，声明数组时注意new的使用。
2、声明数组时，一定要考虑数组的最大容量，防止容量不够的现象。数组一旦被声明，它的容量就固定了，不容改变。如果想在运行程序时改变容量，就需要用到数组列表。数组列表不属于本章的内容，在数据结构一部分会详细讲述。
3、其实数组有一个缺点，就是一旦声明，就不能改变容量，这个也是其使用频率不高的原因。一般存储数据会使用数组列表或 vector，这两种数据结构来存储数据。
三、二维数组
1、二维数组的定义
- type arrayName[ ][ ];
- type [ ][ ]arrayName;
2、动态初始化
1) 直接为每一维分配空间，格式如下：
- arrayName = new type[arrayLength1][arrayLength2];
- int a[ ][ ] = new int[2][3];
- arrayName = new type[arrayLength1][ ];
- arrayName[0] = new type[arrayLength20];
- arrayName[1] = new type[arrayLength21];
- …
- arrayName[arrayLength1-1] = new type[arrayLength2n];
二维简单数据类型数组的动态初始化如下：
- int a[ ][ ] = new int[2][ ];
- a[0] = new int[3];
- a[1] = new int[5];
对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。而且，必须为每个数组元素单独分配空间。例如：
- String s[ ][ ] = new String[2][ ];
- s[0]= new String[2];//为最高维分配引用空间
- s[1]= new String[2]; //为最高维分配引用空间
- s[0][0]= new String("Good");// 为每个数组元素单独分配空间
- s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
- s[1][0]= new String("to");// 为每个数组元素单独分配空间
- s[1][1]= new String("You");// 为每个数组元素单独分配空间
3、二维数组元素的引用
对二维数组中的每个元素，引用方式为：
- arrayName[index1][index2]
- public class MatrixMultiply{
- public static void main(String args[]){
- int i,j,k;
- int a[][]=new int [2][3]; //动态初始化一个二维数组
- int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化一个二维数组
- int c[][]=new int[2][4]; //动态初始化一个二维数组
- for (i=0;i<2;i++)
- for (j=0; j<3 ;j++)
- a[i][j]=(i+1)*(j+2);
- for (i=0;i<2;i++){
- for (j=0;j<4;j++){
- c[i][j]=0;
- for(k=0;k<3;k++)
- c[i][j]+=a[i][k]*b[k][j];
- }
- }
- System.out.println("*******Matrix C********");//打印Matrix C标记
- for(i=0;i<2;i++){
- for (j=0;j<4;j++)
- System.out.println(c[i][j]+" ");
- System.out.println();
- }
- }
- }
