Java 基础——数组解析

数组对于每一门编辑应语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java语言中提供的数组是用来存储固定大小的同类型元素。 可以声明一个数组变量，如numbers[100]来代替直接声明100个独立变量number0，number1，....，number99。

一、数组基础

下面介绍Java数组的声明、创建和初始化，并给出其对应的代码：

1、声明数组变量

首先必须声明数组变量，才能在程序中使用数组。在声明数组变量时，需要指出数组类型（数组类型紧跟[]）和数组变量的名字。

下面是声明数组变量的语法（以int 型为例）：

int[] a; // 首选的方法

或

int a[]; // 效果相同，但不是首选方法

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

2、创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

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

一、使用dataType[arraySize]创建了一个数组。

二、把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

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

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

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

下面的语句首先声明了一个数组变量myList，接着创建了一个包含10个double类型元素的数组，并且把它的引用赋值给myList变量。

double[] myList = new double[10];

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



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

3.1、foreach循环
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方法打印出 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数组作为函数的返回值。

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[]表示数组名。

基本类型数组的声明有几种形式：

int a[];
int[] a;

这两种形式没有区别，使用效果完全一样，读者可根据自己的编程习惯选择。

　　

2、一维数组的初始化

数组的初始化分为静态初始化和动态初始化：静态初始化是在声明数组的同时进行赋值; 动态初始化是在声明数组后在对其进行赋值。

1)、静态初始化

int intArray[]={1,2,3,4};
String stringArray[]={"abc", "How", "you"};

2)动态初始化

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

程序先作了个数组声明“int[] a”，然后，创建了一个数组对象“a=new int[10]”，最后使用循环语句输出数组中所有数据。

几点说明：

1、数组是对象类型数据，声明数组时注意new的使用。

2、声明数组时，一定要考虑数组的最大容量，防止容量不够的现象。数组一旦被声明，它的容量就固定了，不容改变。如果想在运行程序时改变容量，就需要用到数组列表。数组列表不属于本章的内容，在数据结构一部分会详细讲述。

3、其实数组有一个缺点，就是一旦声明，就不能改变容量，这个也是其使用频率不高的原因。一般存储数据会使用数组列表或 vector，这两种数据结构来存储数据。

三、二维数组

1、二维数组的定义

type arrayName[ ][ ];
type [ ][ ]arrayName;

Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。

2、动态初始化

1) 直接为每一维分配空间，格式如下：

arrayName = new type[arrayLength1][arrayLength2];
int a[ ][ ] = new int[2][3];

2) 从最高维开始，分别为每一维分配空间：

arrayName = new type[arrayLength1][ ];
arrayName[0] = new type[arrayLength20];
arrayName[1] = new type[arrayLength21];
…
arrayName[arrayLength1-1] = new type[arrayLength2n];

3) 例：

　　二维简单数据类型数组的动态初始化如下：

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();
}
}
}