一、数组的定义与使用
知识点：
1、数组的基本作用与定义语法；
2、二维数组的使用；
3、数组与方法的互操作；
4、与数组有关的类库方法使用；
5、对象数组。
在所有的开发之中，数组是一个非常重要的概念，所有的项目都使用数组，但它使用的数组与本次内容是有出入的，后面会更换数组的使用形式，但是其基本概念不会改变。
1.1 数组的基本概念
数组指的就是一组相关变量的集合。
数组的定义：
- 声明并开辟数组 数据类型 数组名称 [] = new 数据类型 [长度]； 数据类型 [] 数组名称 = new 数据类型 [长度];
- 分步完成 声明数组：数据类型 数组名称 [] = null; 开辟数组: 数组名称 = new 数据类型 [长度];
1、当数组开辟空间后，可以采用 "数组名称 [下标]" 的形式进行访问。如果超出数组长度，那么会出现数组越界异常（ArrayIndexOutOfBoundsException）。
2、以上给出的数组定义结构采用的是动态初始化方式，即：数组会首先开辟内存空间，数据内容为其数据类型的默认值。
3、由于数组是一种顺序的结构，并且数组的长度都是固定的，那么可以使用循环的方式输出，很明显 for 循环，而且 java 里为了方便数组的输出提供有一个 “数组名称.length” 的属性，可以取得数组的长度。
for(int i=0; i<data.length; i++){
System.out.println( data[i]);
}
1.2 内存空间
虽然数组比较简单，但是其麻烦的问题在于，它也属于引用类型，也有内存分配，与对象保存唯一的区别在于：对象中的堆内存保存的是属性内容，数组对象中的堆内存保存的是数组里的内容。
举例：用内存关系来描述下面的关系
int data [] = new data[3];
data[0] = 10;
data[1] = 20;
data[2] = 30;
以上是第一种数组定义的语法，下面更换第二种：
int data [] = null;
data = new data[3];
data[0] = 10;
data[1] =20;
data[2] =30;
1.3 数组的引用传递
既然数组属于引用数据类型，那么数组一定可以发生引用传递。
举例：数组的引用传递
int data [] = new data[3];
data[0] = 10;
data[1] =20;
data[2] =30;
int temp [] = data;
temp[0] =99;
1.4 数组的静态初始化
以上数组的定义格式严格来讲是属于动态初始化，它的操作特点：先开辟数组空间，而后为数组中的内容进行赋值。
和对象初始化相比，对象可以在定义时通过构造函数进行初始化。类似的：
在数组定义之中还提供有静态初始化的操作，即数组定义的同时就设置好了数组内容。
- 格式一，简化格式： 数据类型 数组名称 [] = {值，值，值，...}
- 格式二， 完整格式： 数据类型 数组名称 [] = new 数据类型 [] {值，值，值，...}
int data [] = new int[]{10,20,30};
for(int i=0; i<data.length; i++){
System.out.println( data[i]);
}
在实际工作中，数组是会存在的，但是它的内容大部分情况下是通过传递的数据而动态生成的，很少使用这种先开辟数组而后去使用的情况。
虽然数组支持顺序的数据访问操作，但是数组有一个最大的缺点——长度不能被改变，所以在开发之中才不会去应用数组，但是会使用到数组的概念。
二、数组与方法参数的传递
2.1 数组的引用传递
如果方法传递的是数组，请千万要记住，观察内存分配图。
举例：一个数组传递的程序
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int []{1,2,3};
change(data);
for(int i=0; i<data.length; i++){
System.out.println(data[i]);}
}
public static void change(int temp[]){
for(int i=0; i<temp.length; i++){
temp[i] *=2;}
}
}
2.2 数组排序
实现一个数组排序 经典面试、笔试题。
下面给出（升序）排序的基本原理（冒泡排序）：每次取一个数与其他数比较，如果大于则交换位置。
- 原始数据：2、1、9、0、5、3、7、6、8；
- 第一次排序：1、2、0、5、3、7、6、8、9 ；
- 第二次排序：1、0、2、3、5、6、7、8、9；
- 第三次排序：0、1、2、3、5、6、7、8、9。 以上只是给出了排序的基础原理过程，但是会根据数据的不同会出现不同的排序次数，但是不管有多少个数据，总的排序次数不会超过数组的长度。所以只要排序的次数达到 长度 * 长度，那么所要排序的数组一定会排序成功。
基础的实现：
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int []{2,1,9,0,5,3,7,6,8};
// 外层控制排序的次数
for (int x = 0; x <data.length -1; x++){
// 内层控制每次的排序
for(int i=0; i<data.length-1; i++){
if(data[i] > data[i+1]){
int temp = data[i];
data[i] = data[i+1];
data[i+1] =temp;
}
}
}
print(data);
}
public static void print(int temp[]){
for(int i=0; i< temp.length; i++){
System.out.print(temp[i] + ",");
}
System.out.println();
}
}
改善设计：主方法是作为程序的起点存在，那么所有程序的起点都可以称为客户端。 既然是客户端，所有的代码编写一定要简单，可以 采用方法进行封装。
public class ArrayDemo{
public static void main(String args[]){
int data [] = new int []{2,1,9,0,5,3,7,6,8};
sort(data);
print(data);
}
public static void sort(int arr []){
// 外层控制排序的次数
for (int x = 0; x <arr.length -1; x++){
// 内层控制每次的排序
for(int i=0; i<arr.length-1; i++){
if(arr[i] > arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] =temp;
}
}
}
}
public static void print(int temp[]){
for(int i=0; i< temp.length; i++){
System.out.print(temp[i] + ",");
}
System.out.println();
}
}
三、数组操作方法
java 本身针对于数组是有提供类库支持的。下面有两个与数组有关的操作：
3.1 数组拷贝
可以将一个数组的部分内容拷贝到另一数组中
语法： System.arraycopy(源数组名称，源数组拷贝开始索引，目标数组名称，目标数组拷贝开始索引，长度)；
举例：实现数组拷贝
数组 A： 1、2、3、4、5、6、7、8；
数组 B： 11、22、33、44、55、66、77、88；
要求拷贝后的数组： 11、22、5、6、7、66、77、88
代码为
int data [] = new int []{1,2,3,4,5,6,7,8};
int arr [] = new int []{11,22,33,44,55,66,77,88};
print(arr);
System.arraycopy(data,4,arr,2,3);
print(arr);
3.2 数组排序
之前给出了排序的基本操作，但是在开发里面如果要进行排序，只需要使用如下代码即可。
语法: Arrays.sort();
int data [] = new int []{3,6,1,8,0};
Arrays.sort(data);
如果是笔试题写 2.2 中的代码。
四、对象数组（重点）
数组是引用类型，对象也是引用类型，所以如果是对象数组的话表示一个引用类型里面嵌套了引用类型。
在之前使用的数组都基于基本数据类型的数组，但是所有的引用数据类型也同样可以定义数组，这样的数组称为对象数组。
如果要想定义对象数组（以类为例），可以采用如下的形式完成：
4.1 动态初始化
- 声明并开辟对象数组： 类名称 对象数组名称 [] = new 类名称 [长度];
- 分步完成：
- 先声明对象数组： 类名称 对象数组名称 [] = null;
- 开辟对象数组： 对象数组名称 = new 类名称 [长度]；
举例：对象数组的动态初始化
Employee emp[] = new Employee[3];
emp[0] = new Employee("Alice","Java 开发", 1000);
emp[1] = new Employee("Bob","JSP 开发", 1000);
emp[2] = new Employee("Candy","Android 开发", 1000);
对象数组实际上就是将多个对象交给数组管理。
4.2 静态初始化
类名称 对象数组名称 [] = new 类名称 []{实例化对象,...}；
举例：对象数组的静态初始化
Employee emp[] = new Employee[]{
new Employee("Alice","Java 开发", 1000),
new Employee("Bob","JSP 开发", 2000),
new Employee("Candy","Android 开发", 3000)
};
注意，这里不要写数组长度。
4.3 一段总结
- 数组用的很少，但是一定会用，而且数组的相关逻辑关系比较麻烦；
- 把数组的排序与转置弄明白
- 要明白数组的定义语法与内存关系
- 对象数组的定义语法，对象数组 = 多个对象。
- 数组有一个最大的天生短板：长度固定，这个限制了数组在开发中的出现。
- 数组的排序：Arrays.sort()。