数组的基本概念
1、数组是由多个数据类型相同的元素组成的有顺序的数据集合。
2、数组是属于引用数据类型（复杂数据类型）。
3、数组中的每一个数据叫做数组的一个元素（element）。
4、数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
5、数组是固定的，不能扩展。
6、数组中元素的个数，叫做数组的长度（length）。
7、通过数组名和下标可以访问数组的各元素
8、数组可以分为一维数组和多维数组。
一维数组
1、数组的声明
（1）数组类型 [ ] 数组名 ;
int[ ] a ;
（2）数组类型 数组名[ ] ;
double b[ ] ;
2、数组的创建
利用 new 来给数组型变量分配内存空间
数组名 = new 数据类型 [ 数组长度 ] ;
a = new int [ 8 ] ;
b = new double [ 5 ] ;
3、数组的声明和创建可以同时进行
（1）数组类型[ ] 数组名 = new 数据类型 [ 数组长度 ] ；
int[ ] a = new int [10 ];
（2）数组类型 数组名[ ] = new 数据类型 [ 数组长度 ] ；
double b[ ] = new double [ 5 ] ;
4、数组的内存模型
（1）数组是存储多个相同数据类型变量的对象。数组的所有元素都保存在堆内存中。
（2）创建一个数组就是在堆中创建一个数组对象。
（3）数组创建后立即拥有默认值
（4）数组的索引是从 0 开始。
（5）数组在堆中是连续分配内存。
5、数组的初始化
（1）在创建数组的同时就为数组元素分配内存空间并赋值。
（2）如果数组类型是 int 型，所有元素自动初始化为 0 。
（3）如果数组类型是 boolean型，所有元素自动初始化为 false ；
（1）数组类型[ ] 数组名 = { 元素1 , 元素2 , ... } ；
int[ ] a = { 1 , 2 , 3 , 4 , 5 } ;
（2）数组类型[ ] 数组名 = new 数据类型 [ ] { 元素1 , 元素2 , ... } ；
int[ ] a = new int[ ] { 1 , 2 , 3 , 4 , 5 } ;
（3）使用循环初始化
int[ ] a = new int[ 5 ] ;
for (int i = 0 ; i < a.length ; i ++) { // length：表示数组的长度
a[i] = i;
}
//Arrays.toString()：一次性将数组中所有的数据全部输出
System.out.println(Arrays.toString(a));
二维数组
1、数组的声明
（1）数组类型 [ ][ ] 数组名 ;
int[ ][ ] a ;
（2）数组类型 数组名[ ][ ] ;
double b[ ][ ] ;
（3）数组类型[ ] 数组名[ ] ;
double[ ] c[ ] ;
2、数组的创建
利用 new 来给数组型变量分配内存空间
（1）数组名 = new 数据类型 [ 行数 ][ 列数 ] ;
a = new int [ 8 ][ 9 ] ;
（2）数组名 = new 数据类型 [ 行数 ][ ] ;
b = new double [ 5 ][ ] ;
！注：必须声明行的个数。
3、数组的初始化
（1）数组类型[ ][ ] 数组名 = {{元素11, 元素12, ... },{元素21, 元素22 , ...} , ... } ；
int[ ][ ] a = { {1 , 2 , 3} ,{ 4 , 5},{ 6, 7, 8, 9 } } ;
（2）数组类型[ ] 数组名 = new 数据类型[ ]{{元素11,元素12, ...},{元素21,元素22 , ...} , ... } ；
int[ ][ ] a = new int[ ][ ] {{1 , 2 , 3} ,{ 4 , 5},{ 6, 7, 8, 9 } } ;
（3）普通初始化
int[ ][ ] a = new a[3][ ];
a[0] = new int[2];
a[1] = new int[3];
a[2] = new int[4];
a[0][0] = 1;
a[0][1] = 2;
a[1][0] = 3;
a[1][1] = 4;
a[2][0] = 5;
a[2][1] = 6;
（4）使用循环初始化
int[ ][ ] a = new int[ 5 ][ 6 ] ;
for (int i = 0 ; i < a.length ; i ++) { // a.length：表示数组行的长度
for (int j = 0; j < a[i].length; j++) { // a[i].length：表示数组列的长度
a[i][j] = i + j ;
}
}
// 二维数组的输出
for (int i = 0 ; i < a.length ; i ++) {
System.out.println(Arrays.toString(a[i])); //a[ i ]：每次循环输出一维数组
}
4、二维数组的内存表示
数组操作
1、数组的遍历
利用循环语句和数组下标。
int a[10] = {1,2,3,4,5,6,7,8,9,10}
for (int i = 0; i < a.length; i++) {
System.out.print(arr[i]+" ");
}
//输出结果：1 2 3 4 5 6 7 8 9 10
2、数组的复制 — System.arraycopy()
System.arraycopy ( src, srcPos, dest, destPos, length ) ;
复制 src 数组中从下标 srcPos 开始的 length 个元素到目标数组 dest，并从目标数组的下标为 destPos 的位置开始复制存储。
（1）src ：源数组
（2）srcPos：源数组的起始位置
（3）dest：目标数组
（4）destPos：目标数组中的起始位置
（5）length：要复制的源数组的元素个数
//数组copy的方法
int array1[] = {11,23,4,5,6,22,34,67,56,54,54,2};
int array2[] = new int[array1.length];
System.out.println(array1.length);
System.out.println("copy 前 " + Arrays.toString(array2));
System.arraycopy(array1, 0, array2, 1, 6);
System.out.println("copy 后 " + Arrays.toString(array2));
//输出结果：
12
copy 前 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
copy 后 [0, 11, 23, 4, 5, 6, 22, 0, 0, 0, 0, 0]
3、数组的排序
（1）Arrays.sort( arr_name );
对数组 arr_name 进行升序排序。
（2）Arrays.sort( arr_name，fromIndex , toIndex);
对数组 arr_name 中，从下标为 fromIndex 到 toIndex 的元素（不包含toIndex ）进行升序排序。
int[] a = {1,6,8,5,3,9,4,7,2};
java.util.Arrays.sort(a);
System.out.println(Arrays.toString(a));
//输出结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
nt[] b = {1,6,8,5,3,9,4,7,2};
java.util.Arrays.sort( b , 1 , 5 );
System.out.println(Arrays.toString(b));
//输出结果：[1, 3, 5, 6, 8, 9, 4, 7, 2]
4、数组的扩容
数据的扩容：实际上是创建了一个新的数组，将原来数组的数据复制过来。
Arrays.copyOf(原数组, 原数组长度+1);
int[] a = {1,2,3,4,5};
a = Arrays.copyOf(a, a.length+1); //a.length：原数组长度
a[a.length-1] = 6; //a[a.length-1]：表示新数组的最后一位
System.out.println(Arrays.toString(a));
//输出结果：[1, 2, 3, 4, 5, 6]
