概述
是什么
通过new关键字创建并组装他们，通过使用整形索引值访问它的元素，并且它的尺寸是不可变的！
数组是一个简单的复合数据类型，它是一系列有序数据的集合，它当中的每一个数据都具有相同的数据类型，我们通过数组名加上一个不会越界下标值来唯一确定数组中的元素。
数组是一个特殊的对象
不管在其他语言中数组是什么，在java中它就是对象。一个比较特殊的对象。
public class Test {
public static void main(String[] args) {
int[] array = new int[10];
Class clazz = array.getClass();
System.out.println(array.length);
System.out.println(clazz.getSuperclass());
System.out.println(clazz.getName());
System.out.println(Object[].class);
System.out.println(Object[][].class);
System.out.println("-------------------------------");
System.out.println(clazz.getDeclaredFields().length);
System.out.println(clazz.getDeclaredMethods().length);
System.out.println(clazz.getDeclaredConstructors().length);
System.out.println(clazz.getDeclaredAnnotations().length);
System.out.println(clazz.getDeclaredClasses().length);
}
}
/*
输出：
10 //数组的长度
class java.lang.Object //数组的父类是Object
[I //一维整型数组的类名是[I
class [Ljava.lang.Object; //一维对象数组类名[L
class [[Ljava.lang.Object; //二维对象数组类名[[L
\-------------------------------
0
0
0
0
0
*/
从第二部分输出可以看到：数组没有生命任何成员变量、成员方法、构造函数、Annotation甚至连length成员变量这个都没有，它就是一个彻彻底底的空类
没有声明length，那么我们array.length时，编译器怎么不会报错呢？确实，数组的length是一个非常特殊的成员变量。我们知道数组的是Object的直接子类，但是Object是没有length这个成员变量的，那么length应该是数组的成员变量，但是从上面的示例中，我们发现数组根本就没有任何成员变量，这两者不是相互矛盾么？
public class Test {
public static void main(String[] args) {
int a[] = new int[2];
int i = a.length;
}
}使用SUN JDK 1.6编译上述代码，并使用jclasslib打开Test.class文件，得到main方法的字节码：
0 iconst_2 //将int型常量2压入操作数栈
1 newarray 10 (int) //将2弹出操作数栈，作为长度，创建一个元素类型为int, 维度为1的数组，并将数组的引用压入操作数栈
3 astore_1 //将数组的引用从操作数栈中弹出，保存在索引为1的局部变量(即a)中
4 aload_1 //将索引为1的局部变量(即a)压入操作数栈
5 arraylength //从操作数栈弹出数组引用(即a)，并获取其长度(JVM负责实现如何获取)，并将长度压入操作数栈
6 istore_2 //将数组长度从操作数栈弹出，保存在索引为2的局部变量(即i)中
7 return //main方法返回在这个字节码中我们还是没有看到length这个成员变量，但是看到了这个:arraylength ,这条指令是用来获取数组的长度的，所以说JVM对数组的长度做了特殊的处理，它是通过arraylength这条指令来实现的。
使用方法
数组的使用方法无非就是四个步骤：声明数组、分配空间、赋值、处理。
声明数组：就是告诉计算机数组的类型是什么。有两种形式：int[] array、int array[]。
分配空间：告诉计算机需要给该数组分配多少连续的空间，记住是连续的。array = new int[10];
赋值：赋值就是在已经分配的空间里面放入数据。array[0] = 1 、array[1] = 2……其实分配空间和赋值是一起进行的，也就是完成数组的初始化。有如下三种形式：
int a[] = new int[2]; //默认为0,如果是引用对象类型就为null
int b[] = new int[] {1,2,3,4,5};
int c[] = {1,2,3,4,5};
性能
数组与其他种类的容器之间的区别有三个方面：效率、类型和保存基本类型的能力。在java中，数组是一种效率最高的存储和随机访问对象引用序列的方式。
在项目设计中数组使用的越来越少了，而且它确实是没有List、Set这些集合使用方便，但是在某些方面数组还是存在一些优势的，例如：速度，而且集合类的底层也都是通过数组来实现的。
因为在list中，list.add(5),要进行装箱操作，而list.get(i)，进行拆箱动作，Integer对象通过intValue方法自动转换成一个int基本类型，在这里就产生了不必要的性能消耗。
数组的扩容
public class ArrayUtils {
public static <T> T[] expandCapacityMul(T[] datas,int mulitiple){
mulitiple = mulitiple < 0 ? 1 : mulitiple;
int newLen = datas.length * mulitiple;
return Arrays.copyOf(datas,newLen );
}
}
public class Test {
public static void main(String[] args) {
int sum=0;
Integer [] arr ={1,2,3,4,5,6,7,8,9,10,11};
System.out.println(arr.length);
arr=ArrayUtils.expandCapacityMul(arr, 2);
System.out.println(arr.length);
System.out.println(arr[4]);
System.out.println(arr[14]);
}
}
输出：
11
22
5
null
数组转换为Arraylist
我们经常需要使用到Arrays这个工具的asList()方法将其转换成列表.但有需要注意的地方
public class Test {
public static void main(String[] args) {
int[] datas = new int[]{1,2,3,4,5};
List list = Arrays.asList(datas);
System.out.println(list.size());
Integer[] datas2 = new Integer[]{1,2,3,4,5};
List list2 = Arrays.asList(datas2);
System.out.println(list2.size());
list2.add(10);
System.out.println(list2.size());
}
}
输出:
1
5
Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.AbstractList.add(Unknown Source)
at java.util.AbstractList.add(Unknown Source)
at java_interview.Test.main(Test.java:36)
数组中可以放基本数据类型和对象
集合中只能放放对象
基本数据类型是不可能泛型化的，也是就说8个基本数据类型是不可作为泛型参数的
编译没错，但是运行竟然出现了异常错误！UnsupportedOperationException ，当不支持请求的操作时，就会抛出该异常。从某种程度上来说就是不支持add方法
asList()源码：
@SafeVarargs
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}再进一步ArrayList源码：
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
if (array==null)
throw new NullPointerException();
a = array;
}
public int size() {...}
public Object[] toArray() {...}
public <T> T[] toArray(T[] a) {...}
public E get(int index) {..}
public E set(int index, E element) {...}
public int indexOf(Object o) {... }
public boolean contains(Object o) {...}
}再看它的父类AbstractList：
public void add(int index, E element) {
throw new UnsupportedOperationException();
}这里父类仅仅只是提供了方法，方法的具体实现却没有，所以具体的实现需要子类自己来提供，但是非常遗憾这个内部类ArrayList并没有提供 add的实现方法
而在ArrayList中，它主要提供了如下几个方法：
1、size：元素数量
2、toArray：转换为数组，实现了数组的浅拷贝。
3、get：获得指定元素。
4、contains：是否包含某元素。
所以综上所述，asList返回的是一个长度不可变的列表。数组是多长，转换成的列表是多长，我们是无法通过add、remove来增加或者减少其长度的。
java.util.Arrays的数组工具类的使用
数组对象的方法只有.length(),其余就是从Object类来的方法
其余对数组操作的函数都在Arrays工具类中
包括排序，二分查找(一定是对有序的数组查找)，数组的复制，数组值的填充
public class Test {
public static void main(String[] args) {
//一维数组
int[] datas = new int[]{5,3,2,4,1,4};
Integer [] data_integer=new Integer[]{3,8,3,2,4};
//二维数组
int[][] datas2=new int[][]{
{1,8,3,7},
{5,2,6,9},
{3}
};
//数组转为list,数组中的类型必须是引用数据类型
List list=Arrays.asList(data_integer);//
System.out.println(list.toString());
//数组的行列
System.out.println("数组的行："+datas2.length);
System.out.println("数组的列："+datas2[0].length);
System.out.println("数组的列："+datas2[2].length);
//数组排序和遍历
Arrays.sort(datas);
System.out.print("sort:");
for(int x:datas)
System.out.print(x);//数组的遍历
//二分查找
System.out.println("\n"+"查到了："+Arrays.binarySearch(datas, 4));//返回要查找数的第一个位置
System.out.println("没查到："+Arrays.binarySearch(datas, 6));//查不到则返回-(length+1)
//toString()
String str=Arrays.toString(datas);
System.out.println("字符串："+str);
//复制
int newdata[] = Arrays.copyOf(datas, 10);
System.out.println("copyOf:"+Arrays.toString(newdata));
//按范围复制
System.out.println("原字符串："+Arrays.toString(datas));
int newdata2[] =Arrays.copyOfRange(datas, 0, 3);
System.out.println("copyOfRange:"+Arrays.toString(newdata2));
int newdata3[] =Arrays.copyOfRange(datas, 3, datas.length);
System.out.println("copyOfRange:"+Arrays.toString(newdata3));
//填充一个数组
Arrays.fill(newdata2, 20);
System.out.println("fill:"+Arrays.toString(newdata2));
//判断两个数组相等
int data_copy[]=Arrays.copyOf(datas, 6);
System.out.println(Arrays.equals(datas, data_copy));//两个数组长度一样，其中元素也相同，则相等
}
}输出：
[3, 8, 3, 2, 4]
数组的行：3
数组的列：4
数组的列：1
sort:123445
查到了：4
没查到：-7
字符串：[1, 2, 3, 4, 4, 5]
copyOf:[1, 2, 3, 4, 4, 5, 0, 0, 0, 0]
原字符串：[1, 2, 3, 4, 4, 5]
copyOfRange:[1, 2, 3]
copyOfRange:[4, 4, 5]
fill:[20, 20, 20, 20]
true