前言：前面两章我们详细讲解了Java基本程序设计结构中的基本知识，，包括：一个简单的Java应用，注释，数据类型，变量与常量，运算符，字符串，输入输出，控制流，大数值。 本篇将介绍最后一环——“数组”，带领大家更全面透彻地了解Java中数组的相关知识。

一.数组的基本概念

数组：即存储着相同类型值的序列。
从定义中我不可以得到以下结论：

1.数组是一种数据结构，是用来存储同一类型值的集合；
2.数组中存放的值连续的;
3.每个空间有自己的编号，其实位置的编号为0，即数组的下标。

举个例子：在java中，包含6个整形类型元素的数组，就相当于下图中连在一起的6个车位，从下图中可以看到：

那么，我们如何定义，使用一个数组呢？

二.数组的声明和初始化

2.1数组的声明

俗话说：变量先声明后使用。首先我们看看如何声明一个数组。
通过以下方式我们可以声明一个Java数组，在声明数组变量的时候，需要指出数组类型和数组变量的名字：

int[] array1;//array:英文单词表示数组
double[] array2;
boolean[] array3;
//...

这时我们就成功声明了一个array数组。看到这里，一些有C语言基础的小伙伴就会有一种“熟悉的陌生人”的感受，因为C语言是这样声明一个数组的：

int arr[];//C语言实现方式

两者看上去非常相似，仅仅只是“[ ]”的位置不同，实际上，在Java中，这两种形式都可以定义声明一个数组变量。只不过，大多数Java程序员更倾向于第一种方式，因为这样可以清晰地将变量类型和变量名区分开来，显得更加有逻辑性。(相当于我创建了一个名为array的变量，变量的类型是int[ ]).

2.2数组的初始化【重要】

在Java中，数组的初始化方式相对比较灵活，接下来我们一一讲解不同的初始化方式：
方法一：直接法

//对于一中我们声明的数组我们仅仅声明了变量array，并没有将它初始化为一个真正的数组
//方法一：直接初始化法
int[] array={1,2,3,4,5}；
//这种方式直接指明了数组中元素的值

这种方式对于C小伙伴们是最熟悉不过的，优点是简便直接，缺点是如果数组中元素个数过多，就显得比较麻烦了。
补充:这种初始化语法中不需要使用new(后文讲解)，甚至不用指定长度。最后一个值后面允许有逗号，如果你要不断为数组增加值，这很方便：

String[] names={"彭于晏”,
"陈冠希",
"刘德华”,
//...
//可以在这之后添加更多的name，这个逗号是被允许的
}

方法二:新创建法

//方法二：new int[元素个数]；
int[] array=new int[100];
//等价于var array=new int[100];

new int[n]语句会创建一个长度为n的数组，一旦创建了数组，就不能再改变它的长度（不过，可以改变单个数组元素）。如果程序运行过程中需要经常扩展数组大小，就应当使用另一种数据结构——“数组列表”（array list），以后会讲解。

方法三:匿名数组法

//方法三：
int[] array=new int[]{1,2,3,4,5};

这种方式会分配一个新数组并填入大括号中提供的值。它会统计初始值个数，所以new int[]中不需要指定数组个数。

补充：在Java中，允许有长度为0的数组。如果在编写一个结果为数组的方法时，这样一个长度为0的数组就很有用。可以如下创建长度为0的数组:
new elementType[0]
或
new elementType[] {}
注意：长度为0的数组与null并不相同！

三.访问数组元素

3.1数组下标/索引

我们以及成功声明并初始化好了一个数组，即我们准备工作已经完成，那么如何去使用一个数组呢？这时我们就需要学会去访问数组元素。
访问数组元素就需要我们找到数组元素“下标/索引”。

array[index];//通过下标/索引找到了对应数组元素

同其它程序设计语言一样，Java数组元素下标也是从0开始的，例如我们创建一个元素个数为100的数组，那么它的下标就是从0到99(而不是1到100）。一旦创建了数组，我们就可以在数组中填入元素：

int[] arrary=new int[100];
for (int i = 0; i < 100; i++) {arrary[i]=i+1;//向数组中填入数组1到100}

创建一个数字数组的时候，所有元素均初始化为0。boolean数组元素会初始化为false。对象数组元素则初始化为一个特殊值null，表示这些元素还未存放任何对象。初学者可能不解i，例如：

String[] names=new String[10];

会创建一个包含10个字符串的数组，所有的字符串均为null。如果希望这个数组包含空串，必须为元素指定空串：

 for (int i = 0; i < 10; i++) {names[i]="";
}

3.2 for循环访问数组元素

此外，在访问数组元素的时候如果需要向数组中添加或删除一个值，第一步就是要改变数组内容，第二步在访问新数组元素的时候我们还需要修改数组元素个数。在Java中提供了一种array.length方法可以获取数组中元素个数，再通过for循环访问数组元素,例如：

 int[] a=new int[]{12,3,46,5,5,5,2,879};for (int i = 0; i < a.length; i++) {System.out.println(a[i]);
}

最后就是一个老生常谈的bug了——数组不能越界访问！
例如：我们创建了一个100个元素的数组，并试图访问array100，就会引发如下异常：

即表明你访问了一个越界的数组元素，这是不被允许的。

3.3 for each循环

虽然上一篇中我们已经提到了for each循环,但是由于它在数组中是一种较为新颖的循环，我们再次在这里提及它。
for each循环是Java中一种功能很强的循环结构，可以用来依次处理数组（或者其它元素集合）中的每个元素，==而不必考虑指定下标值。==这也是它区别与普通for循环最大的不同。
其格式为下：

for(变量：集合) statement

它定义一个变量用于暂存集合中的每一个元素，并执行相应语句（或语句块）。集合的表达式必须是一个数组或者是一个实现了Iterable接口的类对象（例如ArrayList，以后会讲解）。例如：

int[] a=new int[]{1,2,3,4,5};
for(int element:a)System.out.println(element);/*12345*/

打印数组a的每一个元素，一个元素占一行。
实际上，这个循环应该读作“循环a中的每一个元素”（for each element in a）这也是它名字由来。
相比于传统for循环，for each循环语句显得更加简洁，更不易出错，因为你不必因为下标的起始值和终止而操心。以下是二者对比：

//二维数组 就是一个特殊的一维数组
for (int i = 0; i < array.length; i++) {for (int j = 0; j < array[i].length; j++) {System.out.print(array[i][j]+" ");}System.out.println();
}/**/System.out.println("=====");for(int[] tmpArray : array) {for(int x : tmpArray) {System.out.print(x+" ");}System.out.println();
}

注意：for each循环语句的循环变量会遍历数组中的每个元素，而不是下标值。

此外，如果你仅仅想打印出数组中的所有值，那么Java中有一个更加简单的方式，即利用Array类中的toString方法，调用Array.toString(a)，返回一个包含数组元素的字符串，这些元素包含在中括号内，并用逗号分隔开。例如：

结果如下：

注意引入包：import java.util.Arrays;

此外，我们还可以自我实现一个myToString方法：

   public static String myToString(int[] array) {String ret = "[";for (int i = 0; i < array.length; i++) {ret = ret + array[i];if(i != array.length-1) {ret += ", ";}}ret += "]";return ret;}

四.命令行参数

前面已经看到多个使用Java数组的示例。每一个Java应用程序都有一个带String[] args参数的main方法。这个参数表明main方法将接收一个字符串数组，也就是命令行参数。例如，看一看下面这个程序：

public class Test{public static void main(String[] args){if (args[0]. equals("-h"))System.out. print("Hello, ");else if (args[0]. equals("-g"))System. out.print("Goodbye, ");// print the other command-line argumentsfor (int i = 1; i < args. length; i++)System.out. print(" "+ args[i]);System.out.println("!");}
}

如果使用java Test -g cruel world命令调用这个程序,args数组将会包含一下内容：args[0]=“-g” args[1]=“cruel” args[2]=“world”。这个程序就会显示下面这个信息：

五.初始JVM的内存分布

在深入了解数组的使用之前，我们现要了解一下JVM的内存分布，可是我们为什么要了解这个东西呢？
我们知道，Java的程序是跑在虚拟机（即JVM）上，我们要想理解数组这一引用类型是如何引用变量的，就必须了解其它JVM上的内存是如何分配的。
首先，JVM对所使用的内存按照功能的不同进行了划分：

解释一下里面的各个部分：

• 程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址
• 虚拟机栈(JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
• 本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的
• 堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3,4,5} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销
  毁。
• 方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域

简单解释一下这里为什么会出现两个栈区：我们知道JVM底层是由C/C++实现的，而本地方法栈中就包含了一些由C/C++程序实现的方法。而虚拟机栈才是我们平时所说的栈区。
现在我们只简单关心堆 和 虚拟机栈这两块空间，后序JVM中还会更详细介绍。

六.数组中常见的各类方法

6.1数组拷贝

在Java中，允许将一个数组变量拷贝到另一个数组变量中去，这时，两个变量将引用同一个数组：

        int[] smallPrimes=new int[10]; int[] luckyNumbers=new int[10];luckyNumbers[5]=12;luckyNumbers=smallPrimes;//smallPrimes[5]==12

正常来说我们自己是可以很轻松实现一个数组拷贝的方法的：

   public static int[] copyArray(int[] array) {int[] copy = new int[array.length];for (int i = 0; i < array.length; i++) {copy[i] = array[i];}return copy;}

但Java中提供了更便捷的Arrays类的copyOf方法:

luckyNumbers=Arrays.copyOf(luckyNumbers,luckyNumbers.length);
//第一个参数是要拷贝的原始数组
//第二个参数是新数组的长度

这个方法通常用来增加数组大小。

luckyNumbers=Arrays.copyOf(luckyNumbers,2*luckyNumbers.length);

如果数组元素是数值型，那么额外的元素将被赋值为0；如果数组元素是布尔型，则将赋值为false。相反，如果长度小于原始数组的长度，则只拷贝前面的值。
此外，还有类似的Arrays类的copyOfRange方法:

public static void main(String[] args) {int[] array = new int[] { 1,2,3,4 };int[] ret = Arrays.copyOfRange(array,2,4);//第一个参数：要拷贝的原始数组//第二个参数from:表示要拷贝的起始位置//第三个参数to:表示要拷贝的终止位置System.out.println(Arrays.toString(ret));//[3,4]
}

Java数组与堆栈上的C++数组有很大的不同，但基本上与在**堆（heap)**上分配的数组指针一样，也就是说:
int[] a=new int[100];//Java
不同于
int[] a[100];//C++
而等同于
int* a=new int[100];//C++
表明Java中数组变量存储的本质上是一个地址，通过这个地址“引用”到堆区上的目标对象。
同时，Java中的[ ]运算符被预定义为会完成 越界检查，而且没有指针运算，即不能通过a+1得到数组中的下一个元素。

6.2数组排序

我们之前对数组常用的排序是冒泡排序，这里我们再次回顾一下：

public static void bubbleSort(int[] array){//i表示循环的趟数for (int i = 0; i < array.length-1; i++) {boolean flag=false;for (int j = 0; j < array.length-1-i; j++) {//从小到大排序if(array[j]>array[j+1]) {int tempArray = array[j];array[j]=array[j+1];array[j+1]=tempArray;flag=true;}}if(flag==false)return;}}public static void main(String[] args) {int[] a=new int[]{1,3,2,6,0,9};bubbleSort(a);for (int b:a) {System.out.print(b+" ");}//0 1 2 3 6 9}

要想对数值型数组进行排序，我们还可以使用Java中Arrays类的sort方法:

int[] a=new int[10000];
Arrays.sort(a);

这个方法使用了优化的快速排序算法。快速排序算法对于大多数数据集合来说都是效率比较高的。
接下来，我们通过一个经典案例练习一下——“抽彩游戏”：

问题描述：
抽彩是从多个数字中随机抽取几个不重复的值，进行排序输出且判断是否中奖。若中奖则输出中奖次数，若未中奖则给出提示。

示例代码如下：

import java.util.Arrays;
import java.util.Scanner;public class LotteryDrawing {public static void main(String[] args) {int count = 0;//定义一个计量数，计算中奖了几次Scanner sc = new Scanner(System.in);System.out.println("请输入您要抽取数字的最高数：");int n = sc.nextInt();//设定一个n存放最高位数值int n1 = n;//定义了一个n1与n的数值相同System.out.println("请输入您要抽取几个数字(1~"+n+"):");int k = sc.nextInt();//设定了抽取数if(k>n){System.out.println("对不起，您输入的数字不符合规范！");//若此时抽取数比最高数要高则报错}else{int[] numbers1 = new int[n];int[] numbers2 = new int[n1];//定义了两个数组，其长度分别与n和n1相同for (int i = 0; i < numbers1.length; i++) {numbers1[i] = i+1;//对数组numbers进行从1~n的赋值;}for (int i = 0; i < numbers2.length; i++) {numbers2[i] = i+1;//对数组numbers2进行从1~n1的赋值;}int[] result = new int[k];//抽取结果//定义了result数组使其长度等于抽取数kfor (int i = 0; i < result.length; i++) {int r =(int) (Math.random()*n);//Math.random()*n会得到一个0到n-1之间的随机数，左闭右开！//抽取随机数的本质是抽取随机下标result[i] = numbers1[r];//选择随机数numbers[r]赋值给result[i]numbers1[r] = numbers1[n - 1];n--;//这里确保了不会再次抽取到同一个值}int[] winning = new int[k];//中奖结果for (int i = 0; i < winning.length; i++) {int w = (int) (Math.random()*n);winning[i] = numbers2[w];numbers2[w] = numbers2[n1 - 1];n1--;}Arrays.sort(result);//对数组进行排序System.out.println("抽取完成，您抽取的数为：");for(int r :result){System.out.print(r+" ");}//使用foreach循环对数组进行遍历System.out.println("");//换行Arrays.sort(winning);System.out.println("中奖数为：");for (int w:winning){System.out.print(w+" ");}for (int x = 0; x < result.length; x++) {for (int y = 0; y < winning.length; y++) {if(result[x] == winning[y]){count++;}}}//使用两个for循环且利用if语句对数组的值进行判断//若有相同值则count计数值自增System.out.println();if(count == 0){System.out.println("对不起，您未中奖，请再接再厉！");}else{System.out.println("恭喜您，您中奖了"+count+"次");}}}
}

这个案例综合了数组排序的相关内容，仔细研读定会有所收获。

6.3数组查找

在数组使用中，有时我们需要在数组中找到目标元素，这时候我们就需要了解一些数组查找的方法：
方法一：直接暴力查找

  public static int findNum(int[] array,int key) {for (int i = 0; i < array.length; i++) {if(array[i] == key) {return i;}}return -1;//因为直接法是挨个查找，所以效率很低}

这种方式是最直接最简单但效率最为低下的方式，仅限数组大小较小时使用。
方法一：二分查找

 public static int binarySearch(int[] array,int key) {int left = 0;int right = array.length-1;while (left <= right) {int mid = (left+right) / 2;if(array[mid] == key) {return mid;}else if(array[mid] > key) {right = mid - 1;}else {left = mid + 1;}}return -1;}

这个方法相比于方法一效率还是提升了不少的。
对于数组查找，当然Java也提供了相应的方法Arrays类的binarySearch方法:

Arrays.binarySearch(int[] a,key);

具体使用方法就不必多说了，直接用！
Java当然不止提供了这一种排序方法，借助Java帮助手册我们可以自行查询相应方法和参数，结合实际情况和对应具体功能合理选择。

6.4数组填充

有时我们定义完数组后想要对其初始化一般是用for循环解决。
而Java中提供了Arrays类的fill方法:
功能：对数组内容进行指定填充。

public static void main(String[] args) {int[] array = new int[10];Arrays.fill(array,5);Arrays.fill(array,4,6,10);System.out.println(Arrays.toString(array));//[5, 5, 5, 5, 10, 10, 5, 5, 5, 5]
}

6.5数组比较

在上一篇中我们提到了数组之间的比较一定不能使用“ ==”比较 ，如果相等仅仅只能表明两个数组存储在相同的位置，而不能表示两个数组存储的内容是完全等同的。
而Java中提供的Arrays类的equals方法实现了数组的比较:

public static void main(String[] args) {int[] arr1 = new int[] { 5,4,3,2,1 };int[] arr2 = new int[] { 1,2,3,4,5 };int[] arr3 = new int[] { 1,2,3,4,5};System.out.println(Arrays.equals(arr1, arr2));//falseSystem.out.println(Arrays.equals(arr2, arr3));//true
}

七.多维数组【二维数组】

多维数组中我们主要围绕最常见的二维数组展开讨论，这里我们就不详细一一解释了，因为它和一维数组大同小异：

      //二维数组的声明和初始化//以Int为例,//法一：静态初始化int[][] list={{1，2，3}，{4,5,6},{7,8,9}};//法二：动态初始化int[][] list=new int[5][10];//法三：列数不确定int[][] list=new int[5][];//此时所有的一维数组都没有开辟内存空间，它们的地址都为 null；

这里举一个案例，观察一下二维数组在JVM中的内存分布：

实际上，二维数组的本质就是一个存储着一维数组的数组，它的各个一维数组的内存大小可以相同，也可以不相同。（不规则数组）
对于二维数组的访问我们跟一维数组类似，也有两种实现方式：

int[][] list={{1,2,3},{4,5,6},{7,8,9}};
//法一：for (int i = 0; i < list.length; i++) {for (int j = 0; j < list[0].length; j++) {System.out.print(list[i][j]+" ");}System.out.println();
}System.out.println("==================");
//法二：
for (int[] x :list) {for (int y:x) {System.out.print(y+" ");}System.out.println();
}
/*
1 2 3 
4 5 6 
7 8 9 
==================
1 2 3 
4 5 6 
7 8 9 */}

八.不规则数组

刚才我们提及了二维数组可以省略行初始化，即：

int[][] list=new int[5][];

为什么可以这样呢？我们知道，二维数组本质上是一个存储着一维数组的数组。列数的不确定可以使我们对数组进行更加灵活的处理，即可以方便地构造一个“不规则”数组，即数组的每一行都有不同的长度。
下面我们通过一个杨辉三角案例具体了解一下不规则数组的实现：

问题描述：

示例代码如下：

    public static void main(String[] args) {int[][] a = new int[10][];for (int i = 0; i < a.length; i++) {// 给二维数组中每一个一维数组在堆上开辟内存空间a[i] = new int[i + 1];// 遍历每一个一维数组，赋值for (int j = 0; j < a[i].length; j++) {// 每一行的第一个元素和最后一个元素都是1if (j == 0 || j == a[i].length - 1) {a[i][j] = 1;} else {// 每一行非第一个元素和最后一个元素的值 = 上一行的同一列 + 上一行的上一列a[i][j] = a[i - 1][j] + a[i - 1][j - 1];}}}// 输出杨辉三角for (int i = 0; i < a.length; i++) {for (int k = 0; k < a[i].length; k++) {System.out.print(a[i][k] + "\t");}System.out.println();}
}

总结：本篇详细讲解了Java中数组的使用，我们不能发现，其实许多功能和方法Java中都有相应的封装好的类方法供你使用，一方面我们要去了解怎么实现，但更重要的是要学会去自行检索各类方法然后快速上手使用。本篇到此结束，看到这里实属不易，您的支持与鼓励是我前进最大的动力！也希望屏幕前的你能有所收获。