虽然随着Java版本的演变，数组的分量在慢慢减弱，日常使用时大多使用List进行替代。但ArrayList底层依旧采用数组来进行实现，而数组依旧有很多应用的场景。在使用数组的过程中，你是否汇总过数组的特性及功能，并停下来思考几个为什么呢？如果没有，本篇文章将带领大家从头梳理一下数组，一定会为你带来一些未曾发掘的特性和功能。
何谓数组
学习数组，我们最先要知道的就是它是什么，能做什么？
数组，就是相同类型的对象或基本类型数据的集合。也可以理解为把有限个类型相同的元素按一定顺序排列的集合，然后用一个名字命名，用编号区分具体的元素。而这个名字称为数组名，编号称为下标。
数组在内存中是连续存储的，所以索引速度是非常的快，数组的赋值与修改元素也很简单。但是数组也有不足的地方，那就是如果想在两个相邻元素之间插入新的元素会非常麻烦。
另外，数组声明的时候必须指定数组的长度，而数组的长度是不可变的。在此，数组长度过长会造成内存浪费，长度过短则会造成溢出。
数组的应用场景
上面提到了数组的那么多缺点，但我们知道“存在即合理”，下面看看哪些场景适合数组的使用。
1、数据比较少，能够确定长度；存取或修改操作较多，插入和删除较少的情况。
2、使用（遍历）时，经常需要按照序号来进行访问数据元素或做运算的情况。
3、对性能要求较高时，数组是首选。
也正是由于性能较高，所以我们在阅读源码时经常会看到数组的身影。特别是针对基础类型进行操作，效率提升甚至可以达到基于List等集合性能的10倍。
以下面一段遍历数组和List求和的场景来做对比。
// 对数组求和 public static int sum(int[] datas) { int sum = 0; for (int data : datas) { sum += data; } return sum; } // 对List求和 public static int sum(List<Integer> datas) { int sum = 0; for (Integer data : datas) { // 拆箱操作 sum += data; } return sum; }
在上述两个方法中，影响性能的最大地方便是List中的Integer对象的拆箱和装箱操作，特别是数据量比较大的时候。我们都知道基础类型是在栈内存中操作的，而对象是在堆内存中操作的。栈内存的特点是速度快、容量小，堆内存的特点是速度慢、容量大，因此从性能上来讲，基本类型的处理占优势。
有同学可能会说了有整型缓存池的存在。但整型缓存池容纳的是﹣128到127之间的Integer对象，超过这个范围便需要创建Integer对象了，而超过这个容纳范围基本上是大概率事件。
数据变量定义
下面来说说数组的名称定义，我们可以通过两种形式来进行声明数组：
int[] a;
int b[];
1
2
3
其中后一种格式符合C和C++程序员的习惯，如果你是Java开发人员，建议统一使用前一种。为什么呢？因为前一种从语义上来说更合理，它表示“一个int型数组”。
拓展一下：如果你懂一些其他编程语言，比如C语言，你会看到类似如下的声明。
int A[10];
1
Java中却不能如此声明。思考一下为什么？
这个要回到Java的“引用”问题上。我们在上述代码中声明的只是数组的一个引用，JVM会为该引用分配存储空间。但是，这个引用并没有指向任何对象，也就是说没有给数组对象本身分配任何空间。只有在数组真正创建时才会分配空间。因此，编译器不允许在此指定数组的大小。
数组的创建与初始化
数组的创建与初始化有两种形式：
// 方式一的创建 int[] a = new int[5]; // 方式一的初始化 a[1] = 1; a[2] = 2; a[3] = 3; a[4] = 4; // 方式二（创建+初始化） int[] b = {0, 1, 2, 3, 4};
第一种方式通过new关键字创建一个指定长度（为5）的数组，然后通过数组下标对内容进行逐一初始化。那么，如果不进行逐一初始化会怎样？默认会采用int类型的默认值，也就是0进行初始化。
第二种方式，创建与初始化融为一体，其实也采用了new关键字进行创建，只不过是编译器负责来做，更加方便一些。
拓展一下：我们可以通过方式二的形式进行数组的创建和初始化，那么为什么还提供了int[] a这种基于数组引用的声明呢？
这是因为在Java中，可以将一个数组的引用赋值给另外一个数组。比如，我们可以如下方式使用：
int[] c;
int[] b = {0, 1, 2, 3, 4};
c = b;
1
2
3
经过c=b的操作，数组c的引用同样指向了b。这里又会出现一个我们常见的面试题。看看下面代码打印的结果是什么：
public static void main(String[] args) { String[] strings = {"a","b","c"}; String string = "abc"; change(strings,string); System.out.println(strings[1]); System.out.println(string.charAt(1)); } public static void change(String[] strings,String string){ strings[1] = "e"; string = "aec"; }
想好答案了吧？现在公布答案：第一行打印的是“e”，第二行打印的“b”。这与上面所说的数组的引用有密切关联，数组传递进入change方法的是引用，而String类型的参数传递的只是值的copy。
数组的存储结构
这里我们再以一张简单的图展示一下，数组在内存中存储的形式。
上图需注意的是数组使用的存储空间是连续的。其中创建的对象通常位于堆中，上图对堆中的数据存储进行了简化示意。
数组的长度
在很久之前，面试的时候还出现这样的面试题：如何获取数组的长度？
当然，我们知道该面试题考察的就是通过length属性获取数组长度与通过size()方法获取集合长度的区别。
所有的数组都有一个固定的成员，可以通过它来获取数组的长度，这便是length属性。在使用的过程中我们需要注意的是数组的下标是从0开始计算的。因此，我们在遍历或修改数组的时候，需要注意数组的下标最大值是length-1，否则，会出现数组越界的问题。
数组的处理
针对数组，Java标准类库里特意提供了Arrays类，我们可以通过该类提供的方法进行数组的处理。
数组的打印
可通过Arrays.toString()方法对数组的内容进行打印。下面通过示例我们来对比一下通过toString方法和直接打印的区别。
String[] strings = {"a","b","c"};
System.out.println(strings);
System.out.println(Arrays.toString(strings));
1
2
3
打印结果：
[Ljava.lang.String;@36baf30c
[a, e, c]
1
2
可以看到，如果直接打印则打印出来的是strings数组的引用，而并不是真实的内容。
数组的排序
可通过Arrays.sort()方法对数组进行排序，但对于数组中的元素有一定的要求，要实现Comparable接口。看下面的实例：
String[] sorts = {"c","b","a"};
Arrays.sort(sorts);
System.out.println(Arrays.toString(sorts));
1
2
3
打印结果：
[a, b, c]
1
很明显已经进行正常排序了。为什么String可以直接进行排序？那是因为String已经实现了Comparable接口。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {}
1
2
另外，对于数组的排序还有常见的：冒泡排序、快速排序、选择排序、插入排序、希尔（Shell）排序、堆排序等。面试过程中的排序往往也是基于数组来进行展开的。感兴趣的朋友可拿数组来练习一下排序的算法。
数组转集合
通过Arrays.asList()方法，可将数组转化为列表。
String[] sorts = {"程序","新","视界"};
List<String> list = Arrays.asList(sorts);
System.out.println(list);
1
2
3
打印结果：
[程序, 新, 视界]
1
关于asList的源码如下：
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
1
2
3
看到asList源码，你能想到什么？是不是发现该方法的参数为可变参数，并且支持数组作为参数传入。关于可变参数，下篇文章我们会详细讲一下，别忘记关注公众号“程序新视界”学习。
当然，这里也可以转化为Set集合，但需创建一个Set的实现类（这里用HashSet），将asList的结果作为参数传入：
Set<String> sets = new HashSet<>(Arrays.asList(sorts));
1
数组内容查找
可以通过Arrays.binarySearch()方法来对数据中的元素进行查找，顾名思义，这里是通过二分查找法进行查找的。
String[] sorts = {"c","a","b"};
Arrays.sort(sorts);
int index = Arrays.binarySearch(sorts,"b");
System.out.println(index);
System.out.println(sorts[index]);
1
2
3
4
5
打印结果：
1
b
1
2
结果中的"1"指的是字符串所在的下标值，通过下标可以获得对应位置的值。这里需要注意的是，既然是二分查找法，那么在查找之前必定需要进行排序，不然二分查找的意义便不存在了。
数组的拷贝
可以通过Arrays.copyOf()方法对数组进行复制，其中第一个参数是被复制数组，第二个参数为新数组的长度，返回的结果为新的数组。示例如下：
int[] sourceArray = {1, 3, 5, 7, 0};
int[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);
System.out.println(Arrays.toString(newArray));
1
2
3
打印结果：
[1, 3, 5, 7, 0]
1
此时，需要思考一个问题Arrays.copyOf()复制的功能是一个什么层次的复制。也就说，如果修改新数组的值，是否会影响到原有数组。
先猜测一下，下面看示例代码：
int[] sourceArray = {1, 3, 5, 7, 0};
int[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);
newArray[1] = 8;
System.out.println(Arrays.toString(newArray));
System.out.println(Arrays.toString(sourceArray));
打印结果：
[1, 8, 5, 7, 0]
[1, 3, 5, 7, 0]
结果能说明什么？说明Arrays.copyOf()的复制功能是创建一个全新的数组及数组元素吗？NO，NO，NO！
我们再来看另外一个示例，先创建一个User对象，源码如下：
public class User { private String userNo; public User(String userNo){ this.userNo = userNo; } public String getUserNo() { return userNo; } public void setUserNo(String userNo) { this.userNo = userNo; } }
然后创建数组进行复制操作，复制完成之后对新数组的数据进行修改。
User[] sourceArray = {new User("N1"), new User("N2"),new User("N3")}; User[] newArray = Arrays.copyOf(sourceArray, sourceArray.length); newArray[1].setUserNo("N4"); System.out.println(newArray[1].getUserNo()); System.out.println(sourceArray[1].getUserNo());
打印结果如下：
N4
N4
1
2
我们在代码中只是修改了新数组中的User的属性，结果原有数组的值也同样被修改了。
上面的两个示例说明数组的copy操作只是一个浅拷贝。这与序列化的浅拷贝完全相同：基本类型是直接拷贝值，其他都是拷贝引用地址。
同样，数组和集合的clone也是如此，同样是浅拷贝，使用时需多加留意。
基于数组浅拷贝实现变长数组
关于List是如何实现变长的，大家可以参考List的源码进行学习。这里基于上面提到的Arrays.copyOf()方法的功能来实现动态变长。
实现原理很简单，就是基于Arrays.copyOf()方法的第二个参数来进行扩容。
相关方法如下：
public static <T> T[] expandCapacity(T[] datas, int newLen) { // 校验长度值，如果小于0，则为0 newLen = Math.max(newLen, 0); // 生成一个新数组，并拷贝原值，指定新的数组长度 return Arrays.copyOf(datas, newLen); }
在上述方法中除了校验部分，核心机制便是利用了Arrays.copyOf()方法来实现一个可变长的数组。
小结
关于数组部分，我们就讲这么多，其实数组还有多维数组以及通过Arrays.asList()方法转换为List之后基于List的更多操作，在这里我们就不进行拓展了。感兴趣的朋友可自行实践。
