Java学习笔记——数组
简介
Java和许多高级语言都提供了一种称作数组的数据结构，可以用它来存储一个元素个数固定且元素类型相同的有序集。
单个的数组变量可以引用一个大的数据集合。
数组基础知识
数组是用来存储数据的集合，通常可以把数组看作一个存储具有相同类型的变量集合。
一旦数组被创建，它的大小是固定的。使用一个数组引用变量，通过下标来访问数组中的元素。
声明数组变量
为了在程序中使用数组，必须声明一个引用数组的变量，并指明数组的元素类型。
声明数组变量的语法：
elementType[] arrayRefVar;(元素类型[] 数组引用变量;)elementType可以是任意数据类型，但是数组中所有的元素都必须具有相同的数据类型。
注意： 也可以用 elementType arratRefVar[] 声明数组变量。
创建数组
不同于基本数据类型的声明，声明一个数组变量时并不在内存中给数组分配任何空间。它只是创建一个对数组的引用的存储位置。如果变量不包含对数组的引用，那么这个变量的值为null。除非数组已经被创建，否则不能给它分配任何元素。
声明数组变量后，可以使用下面的语法用new操作符创建数组：
arratRefVar = new elementType[arratSize];声明一个数组变量、创建数组、然后将数组引用赋值给变量这三个步骤可以合并为一个步骤：
elementType[] arrayRefVar = new elementType[arraySize];
或
elementType arrayRefVar[] = new elementType[arraySize];注意： 一个数组变量看起来似乎是存储了一个数组，但实际上它存储的是指向数组的引用。
数组的大小和默认值
当给数组分配空间时必须指定该数组能够存储的元素个数，从而确定数组大小。创建数组之后，就不能再修改它的大小。可以使用arrayRefVar.length得到数组的大小。
当创建数组后，它的元素被赋予默认值，数值型基本数据类型的默认值为0，char型的默认值为‘\u0000’，boolean型的默认值为false。
访问数组元素
数组元素可以用过下标访问。数组下标是基于0的，即其范围从0开始到arrayRefVar.length - 1结束。
数组中的每个元素都可以使用下面的语法表示，称为下标变量：
arrayRefVar[index];注意： 一些语言使用圆括号引用数组元素，例如arrayRefVar(9)。而Java语言使用方括号，例如arrayRefVar[9]。
创建数组后，下标变量与正常变量的使用方法相同。例如：下面代码将 myList[0] 和 myList[1] 的值相加赋给 myList[2]。
myList[2] = myList[0] + myList[1];数组初始化语法
Java有一个简捷的标记，称作数组初始化语法，它使用下面的语法将声明数组、创建数组和初始化数组结合到一条语句中：
elementType[] arratRefVar = {value0, value1, value2, ..., valuek};注意： 数组初始化语法中不使用操作符new。使用数组初始化语法时，必须将声明、创建和初始化数组都放在一条语句中。将它们分开会产生语法错误。因此，下面语句是错误的：
double[] myList;
myList = {1.9, 2.9, 3, 4};处理数组
处理数组时，经常会用到for循环，理由如下：
① 数组中所有元素都是同一类型的。可以使用循环以同样的方式反复处理这些元素。
②由于数组的大小是已知的，所以很自然地就使用for循环。
假设创建如下数组：
double[] myList = new double[10];下面是一些处理数组的例子：
① 使用输入值初始化数组
Scanner input = new Scanner(System.in);
System.out.println("Enter " + myList.length + " value: ");
for (int i = 0; i < myList.length; i++)
myList[i] = input.nextDouble();② 使用随机数初始化数组
for(int i = 0; i < myList.length; i++) {
myList[i] = Math.random() * 100;
}③ 显示数组
for(int i = 0; i < myList.length; i++) {
System.out.prin(myList[i] + " ");
}注意： 对于char[]类型的数组，可以使用一条打印语句打印。例如下面的代码显示Dallas：
char[] city = {'D', 'a', 'l', 'l', 'a', 's'};
System.out.println(city);④ 对所有元素求和
double total = 0;
for(int i = 0; i < myList.length; i++) {
total += myList[i];
}⑤ 找出最大元素
double max = myList[0];
for(int i = 0; i < myList.length; i++) {
if(myList[i] > max) max = myList[i];
}⑥ 找出最大元素的最小下标值
double max = myList[0];
int indexOfMax = 0;
for(int i = 1; i < myList.length; i++) {
if(myList[i] > max) {
max = myList[i];
indexOfMax = i;
}
}⑦ 随机打乱
for(int i = myList.length - 1; i > 0; i--) {
int j = (int)(Math.random() * (i + 1));
double temp = myList[i];
myList[i] = myList[j];
myList[j] = temp;
}⑧ 移动元素
double temp = myList[0];
for(int i = 1; i < myList.length; i++) {
myList[i - 1] = myList[i];
}
myList[myList.length - 1] = temp;⑨ 简化编码
String[] months = {"January", "February", ..., "December"};
System.out.print("Enter a month number(1 to 12): ");
int monthNumber = input.nextInt();
System.out.println("The month is " + months[monthNumber - 1]);如果不使用 month 数组，则需要使用一个很长的多分支if-else语句来确定月份名称：
if(monthNumber == 1)
System.out.println("The month is January");
else if(monthNumber == 2)
System.out.println("The month is February");
...
else
System.out.println("The month is December");foreach循环
Java支持一个简便的for循环，称为foreach循环，即不使用下标变量就可以顺序地遍历整个数组。例如：
for (double e : myList) {
System.out.println(e);
}此代码可读作“对myList中每个元素e进行以下操作”。
注意： 变量e必须声明为与myList中元素相同的数据类型。
通常，foreach循环的语法为：
for(elementType element : arrayRefVar) {
//执行语句
}注意： 当需要以其他顺序遍历数组或改变数组中的元素时，还是需要使用下标变量。
注意： 越界访问数组是经常出现的程序设计错误，它会抛出一个运行错误ArrayIndexOutOfBoundException。为了避免错误发生，使用时应确保所使用的下标不超过arrayRefVar.length - 1。
经常会出现错误地使用下标1引用数组的第一个元素，但实际上第一个元素的下标应该是0。这称为下标过1错误。它是循环中该使用 < 的地方误用 <= 时发生的错误。例如：
for(int i = 0; i <= list.length; i++)
System.out.println(list[i]);应该把 <= 替换为 < 。
实例学习：分析数字
编写一个程序，找到大于所有项平均值的那些项。
public class AnalyzeNumbers {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter the number of items: ");
int n = input.nextInt();
double[] numbers = new double[n];
double sum = 0;
//输入数字
System.out.print("Enter the number: ");
for(int i = 0; i < n; i++) {
numbers[i] = input.nextDouble();
sum += numbers[i];
}
//计算平均值
doubel average = sum / n;
//记录大于平均值的数的个数
int count = 0;
for(int i = 0; i < n; i++) {
if(number[i] > average) {
count++;
}
}
System.out.println("Average is " + average);
System.out.println("Number of elements above the average is " + count);
}
}实例学习：一副扑克
编写一个程序，从一副扑克中随机选出4张牌
public class DeckOfCards {
public static void main(String[] args) {
int[] deck = new int[52];
String[] suits = {"Spades", "Hearts", "Diamonds", "Clubs"};
String[] ranks = {"Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"};
//初始化deck，为deck的元素赋值：0到51
for(int i = 0; i < deck.length; i++)
deck[i] = i;
//洗牌
for(int i = 0; i < deck.length; i++) {
int index = (int)(Math.random() * deck.length);
int temp = deck[i];
deck[i] = deck[index];
deck[index] = temp;
}
//显示前四张扑克
for(int i = 0; i < 4; i++) {
String suit = suits[deck[i] / 13];
String rank = ranks[deck[i] % 13];
System.out.println("Card number " + deck[i] + ": " + rank + " of " + suit);
}
}
}
//输出：
//Card number 6: 7 of Spades
//Card number 48: 10 of Clubs
//Card number 11: Queen of Spades
//Card number 24: Queen of Hearts数组的复制
要将一个数组中的类容复制到另一个数组中，需要将数组的米格元素复制到另外一个数组中。
在程序中经常需要复制一个数组或数组的一部分。这种情况下可以选择使用赋值语句（=）：
list2 = list1;这条语句并不是把 list1 引用的数组内容复制给 list2， 而是将 list1 的引用赋值给 list2。这条语句之后，list1 和 list2 都指向同一个数组。
在Java中，赋值语句可以复制基本数据类型的变量，但不能复制数组。将一个数组变量赋值给另一个数组变量，实际上是将一个数组的引用复制给另一个变量，使两个变量都指向相同内存地址。
复制数组的三个方法：
① 使用循环语句，逐个元素进行复制操作。
② 使用 System 类中的静态方法 arraycopy。
③ 使用 clone 方法复制数组。
可以使用循环将源数组中的每个元素复制到目标数组中的对应元素。例如：
int[] sourceArray = {2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];
for(int i = 0; i < sourceArray.length; i++) {
targetArray[i] = sourceArray[i];
}另一种方法是使用 java.lang.System 类的 arraycopy 方法复制数组，而不是使用循环。arraycopy 语法如下：
arraycopy(sourceArray, srcPos, targetArray, tarPos, length);其中，参数 srcPos 和 tarPos 分别表示在源数组 sourceArray 和目标数组 targetArray 中的起始位置。从 sourceArray 复制到 targetArray 中的元素个数由参数 length 指定。所以，可以改写上述循环：
System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);arraycopy 方法没有给目标数组分配内存空间。复制前必须创建目标数组以及为它分配内存空间。复制完成后，sourceArray 和 targetArray 具有相同内容，但占有独立的内存空间。
注意： arraycopy 方法违反了 Java 命名习惯。根据命名习惯，该方法应该命名为 arrayCopy。
将数组传递给方法
当将一个数组传递给方法时，数组的引用被传递给方法。
正如给方法传递基本数据类型的值一样，可以给方法传递数组。例：
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});注意： 前面的语句使用下述语法创建数组：
new elementType[] {value0, value1, ..., valuek};该数组没有显式地引用变量，这样的数组被称为匿名数组。
Java使用按值传递的方式将实参传递给方法。传递基本数据类型变量的值与传递数组值有很大的不同。
1. 对于剧本数据类型参数，传递的是实参的值
2. 对于数组类型参数，参数值是数组的引用，给方法传递的是这个引用。从语义上来讲，最好的描述就是参数传递的是共享信息，即方法中的数组和传递的数组是一样的。所以，如果改变方法中的数组，将会看到方法外的数组也发生了变化。
public class Test {
public static void main(String[] args) {
int x = 1;
int[] y = new int[10];
m[x, y];
System.out.println("x is " + x);
System.out.println("y[0] is " + y[0]);
}
public static void m(int number, int[] numbers) {
number = 1001;
numbers[0] = 5555;
}
}
//输出
//x is 1
//y[0] is 5555注意： 数组在Java中是对象。JVM将对象存储在一个称作堆的内存区域中，堆用于动态内存分配。
从方法中返回数组
当从方法中返回一个数组时，数组的引用被返回。
可以在调用方法时向方法传递一个数组。方法也可以返回一个数组。例：
public static int[] revers(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;
}可变长参数列表
具有同样类型的可变长度的参数可以传递给方法，并将作为数组对待。可以把类型相同但个数可变的参数传递给方法。方法中的声明如下：
typeName... parameterName在方法声明中，指定类型后紧跟着省略号（…）。只能给方法中指定一个可变长参数，同时该参数必须是最后一个参数。任何常规参数必须在它之前。
Java 将可变长参数作为数组对待。可以将一个数组或数目可变的参数传递给可变长参数。
public class VarArgsDemo {
public static void main(String[] args) {
printMax(34, 3, 3, 2, 56);
printMax(new double[]{1, 2, 3, 4});
}
public static void printMax(double... numbers) {
if(numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double resule = numbers[0];
for(int i = 1; i < numbers.length; i++)
if(numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
}数组查找
查找是在数组中寻找特定元素的过程，查找是计算机程序设计中经常要完成的任务。有很多用于查找的算法和数据结构，经常使用的有：线性查找和二分查找。
线性查找
线性查找法将要查找的关键字 key 与数组中的元素逐个进行比对。这个过程持续到在列表中找到与关键字匹配的元素，或者查完列表也没有找到关键字为止。
public class LinearSeach {
public static int linearSearch(int[] list, int key) {
for(int i = 0; i < list.length; i++) {
if(key == list[i])
return i;
}
}
}线性查找法把关键字和数组中的每个元素进行比较。数组中的元素可以按任意顺序排列。如果关键字存在，那么在找到关键字之前，这种算法必须与数组中一半的元素进行比较。由于线性查找法的执行时间随着数组元素个数的增长而线性增长，所以对于大数组而言，线性查找法的效率不高。
二分查找法
二分查找法是另一种常见的对数值列表的查找方法。使用二分查找法的前提条件是数组中的元素必须已经排序完成。
二分查找法首先将关键字与数组的中间元素进行比较，考虑三种情况：
① 如果关键字小于中间元素，只需要在数组的前一半元素中继续查找。
② 如果关键字和中间元素相等，则匹配成功，查找结束。
③ 如果关键字大于中间元素，只需要在数组的后一半元素中继续查找关键字。
显然，二分法在每次比较之后就排除一半的数组元素。因此，对于一个有 1024（2^10） 个元素的数组，在最坏情况下，二分法只需要比较11次，而线性查找则需要1023次。
public class BinarySearch {
public static int binarySearch(int[] list, int key) {
int low = 0;
int high = list.length - 1;
while (high >= low) {
int mid = (low + high) / 2;
if(key < list[mid])
high = mid - 1;
else if(key == list[mid])
return mid;
else
low = mid + 1;
}
return -low - 1;
}
}注意： 线性查找法适用于在较小的数组或没有排序的数组中查找，但是对大数组而言效率不高。二分查找法的效率较高，但它要求数组已经排好序。
数组排序
如同查找一样，排序是计算机编程中非常普遍的一个任务。对于排序已经开发出很多不同的算法。
选择排序
假设要按升序排列一个数组。选择排序法先找到数列中最小的数，然后将它和第一个元素交换。接下来，在剩下的数中找到最小数，将它和第二个元素交换，直到数列剩下一个数为止。
public class SelectionSort {
public static void selectionSort(double[] list) {
for (int i = 0; i < list.length - 1; i++) {
double currentMin = list[i];
int currentMinIndex = i;
for(int j = i + 1; j < list.length; j++) {
if(currentMin > list[j]) {
currentMin = list[j];
currentMinIndex = j;
}
}
if(currentMinIndex != i) {
list[currentMinIndex] = list[i];
list[i] = currentMin;
}
}
}
}