Java提供了一个数据结构：数组，用于存储相同类型的元素的一个固定大小的连续集合。数组是用于存储数据的集合，但它往往是更有助于认为数组为相同类型的变量的集合。
在节将介绍如何使用索引变量声明数组变量，创建数组，并处理数组。
声明数组变量：
要使用一个程序的数组，必须声明一个变量来引用数组，必须指定数组的变量可以引用的类型。下面是语法来声明一个数组变量：
dataType[] arrayRefVar; // preferred way.
or
dataType arrayRefVar[]; // works but not preferred way.
注：风格 dataType[] arrayRefVar 是首选的。风格 dataType arrayRefVar[] 来自于C/C++语言，并采用了在Java中容纳C/C++编程。
例子:
下面的代码片段是这种语法的例子：
double[] myList; // preferred way.
or
double myList[]; // works but not preferred way.
String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};
创建数组:
可以通过使用new运算符使用以下语法创建一个数组：
arrayRefVar = new dataType[arraySize];
上面的语句做了两件事：
它创建一个数组使用 new dataType[arraySize];
它分配新创建的数组变量 arrayRefVar 的引用。
声明数组变量，建立一个数组，并分配阵列的参考变量可以在一个语句中被组合，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
另外，可以创建数组，如下所示：
dataType[] arrayRefVar = {value0, value1, ..., valuek};
数组元素通过索引访问。数组的下标是从0开始的，也就是说，它们从0开始到 arrayRefVar.length-1.
例子：
下面的语句声明一个数组变量 myList，创建 double 类型10个元素的数组，并把它的引用到 myList ：
double[] myList = new double[10];
以下图片代表数组 myList。在这里，myList 有10个 double 值，索引是从0到9。
打印数组
int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
// print directly will print reference value
System.out.println(intArray);
// [I@7150bd4d
System.out.println(intArrayString);
// [1, 2, 3, 4, 5]
这里的重点是说明了Java中数组的引用和值得区别，第三行直接打印intArray，输出的是乱码，因为intArray仅仅是一个地址引用。第4行输出的则是真正的数组值，因为它经过了Arrays.toString()的转化
处理数组：
当处理数组元素，经常使用的是loop循环或foreach循环，因为所有的对数组中的元素是相同类型和数组的大小是已知的。
例子：
下面是一个演示如何创建，初始化和处理数组的完整例子：
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// Summing all elements
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// Finding the largest element
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.92.93.43.5Total is 11.7Max is 3.5
foreach循环：
JDK 1.5 引入了一个新的 for循环被称为foreach循环或增强的for循环，它无需使用一个索引变量来遍历数组的顺序完成。
例子：
下面的代码显示遍历数组myList 中的所有元素：
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (double element: myList) {
System.out.println(element);
}
}
}
这将产生以下结果:
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;
}
Arrays 类:
ava.util.Arrays中的类包含各种静态方法用于排序和搜索数组，数组的比较和填充数组元素。这些方法被重载的所有基本类型。
SN
方法和描述
1
public static int binarySearch(Object[] a, Object key)搜索对象的指定数组（字节，整数，双精度等）使用二进制搜索算法来指定值。该数组必须在进行此调用之前对分类。这将返回索引搜索关键字，如果它被包含在列表 (-(insertion point + 1).
2
public static boolean equals(long[] a, long[] a2)如果多头的两个指定数组彼此相等返回true。两个数组认为是相等判定方法：如果两个数组包含相同的元素数目，并在两个数组元素的所有相应对相等。如果两个数组相等，返回true。同样的方法可以用于所有其它的原始数据类型 (Byte, short, Int, etc.)
3
public static void fill(int[] a, int val)将指定的int值到指定的int型数组中的每个元素。同样的方法可以用于所有其它的原始数据类型(Byte, short, Int etc.)
4
public static void sort(Object[] a)排序对象指定的数组升序排列，根据其元素的自然顺序。同样的方法可以用于所有其它的原始数据类型( Byte, short, Int, etc.)
import java.util.Arrays;
public class JavaFiles{
public static void main(String[] args) {
// 实例化字符串数组
String[] bArray = {"a","b","c"};
System.out.print(bArray[0]);
// new
String[] aArray = new String[8];
String[] cArray = new String[]{"a","c"};
//打印数组
int[] list = {1,2,3};
System.out.print(Arrays.toString(list));
//循环打印数组
double[] myList = {1.2,3.9,4.8};
for (int k = 0;k < myList.length; k++ ) {
System.out.println(myList[k]);
}
int total = 0;
for (int i = 1;i <= 100 ; i++) {
// total = total + i;
total += i; // 加赋
}
System.out.print(total);
double[] dList = {1,2,9.8,100.6,87,93};
double max = dList[0];
for (int j = 1;j<dList.length ;j++ ) {
if (dList[j]>max)
max = dList[j];
}
System.out.print(max);
int[] eachList = {1,2,3,4,5};
for (int abc : eachList) {
System.out.println(abc);
}
int[] reverse = {1,2,3,4,5};
int[] result = new int[reverse.length];
for (int i = 0, j = reverse.length-1; i < reverse.length ;i++, j-- ) {
result[j] = reverse[i];
}
System.out.println(Arrays.toString(result));
// 方法的调用
int[] aList = {1,2,3,4,5};
int[] res = JavaFiles.reverse(aList);
System.out.println(Arrays.toString(res));
}
public static int[] reverse(int[] list) {
int[] re = new int[list.length];
for (int i = 0, j = re.length - 1; i < list.length; i++, j--) {
re[j] = list[i];
}
return re;
}
}
