Java 数组

Array
1、java 语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是 Object。
2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。）
数组：字面意思是“一组数据”
3、数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。
4、数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的）
5、数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储 java 对象。
6、数组一旦创建，在 java 中规定，长度不可变。（数组长度不可变）
7、数组的分类：一维数组、二维数组、三维数组、多维数组 . . . .
8、所有的数组对象都有 length 属性（java 自带的），用来获取数组中元素的个数。
9、Java 中的数组要求数组中元素的类型统一。
比如 int 类型数组只能存储 int 类型，Person 类型数组只能存储 Person 类型。
例如：超市购物，购物贷中只能装苹果，就不能同时装橘子，意思就是不能同时装苹果和橘子。
（数组中存储的元素类型统一）
10、数组在内存方面存储的时候，数组中的元素内存地址（存储的每一个元素都是有规则的挨着排列的）是连续的。
内存地址连续。这是数组存储元素的特点（特色）。数组实际上是一种简单的数据结构。
11、所有的数组都是那“第一个小方框的内存地址”作为整个数组对象的内存地址。
（数组中首元素的内存地址作为整个数组对象的内存地址）
12、数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length-1
下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。
13、数组结构的优点和缺点是什么？
优点：查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构。
为什么检索效率高？
第一：每一个元素的内存地址在空间存储上是连续的。
第二：每一个元素类型相同，所以占用空间大小一样。
第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，
所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，
所以数组的检索效率是最高 。
数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，
因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的。
（算出一个内存地址，直接定位的。 ）
缺点：
第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，
因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
第二：数组不能存储大数据量，为什么？
因为很难在内存空间上找到一块特别大的连续的内存空间。
注意：对于数组中最后一个元素的增删，是没有效率影响的。

14、怎么声明/定义一个一维数组？
语法格式：
int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;

int array6[];

15、怎么初始化一个一维数组呢？
包括两种方式：静态初始化一维数组，动态初始化一维数组。
静态初始化语法格式：
int[] array = {100, 2100, 300, 55};
动态初始化语法格式：
int[] array = new int[5]; // 这里的 5 表示数组的元素个数。
// 初始化一个 5 个长度的 int 类型数组，每个元素默认值 0。
String[] names = new String[6]; // 初始化 6 个长度的 String 类型数组，每个元素默认值 null。

当一个方法的参数是一个数组的时候，我们还可以采用这种方式传参。
// 静态初始化一维数组
int[] a = {1, 2, 3};
printArray(a); // 遍历一维数组方法（自己写）

// 没有这种语法
// printArray({1, 2, 3});
// 如果直接传递一个静态数组的话，语法必须这样写。
printArray(new int[]{1, 2, 3});

// 动态初始化一维数组
int[] a2 = new int[4];
printArray(a2);		

printArray(new int[3]);

ArrayIndexOutOfBoundsException 下角标越界

什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？
当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。
当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间。

为什么要使用静态方法？方便呀，不需要 new 对象啊。

1、main 方法上面的“String[] args”有什么用？
JVM 负责调用 main 方法，JVM 调用 main 方法的时候，会自动传一个 String 数组过来。

// 这个方法程序员负责写出来，JVM 负责调用。JVM 调用的时候一定会传一个 String 数组过来。
public static void main(String[] args){
// JVM默认传递过来的这个数组对象的长度？args.length 默认0，args 不是 null

// 以下两行代码表示的含义：数组对象创建了，但是数组没有任何数据。
// String[] strs = new String[0];
String[] strs = {};	// 静态初始化数组，里面没东西。

/*
这个数组什么时候里面会有值呢？
其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为“String[] args”
例如这样运行程序：java ArrayTest05 abc def xyz
那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，
	分离完成之后，自动放到“String[] args”数组当中
所以 main 方法上面的 String[] args 数组主要是用来接收用户输入参数的。
把 abc def xyz 转换成字符串数组：{"abd","def","xyz"}
*/	

}

关于一维数组的扩容。
在 java 开发中，数组长度一旦确定不可变，那么数组满了怎么办？
数组满了，需要扩容。
java 中对数组的扩容是：
先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。
结论：数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意：尽可能少的进行数组的拷贝。
可以在创建数组对象的时候预估计以下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。

关于java中的二维数组：
1、二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中每一个元素是一个一维数组。
2、三维数组是什么？
三维数组是一个特殊的二维数组，特殊在在这个二维数组中每一个元素是一个一维数组。
实际开发中使用最多的就是一维数组。二维数组也很少用。三维数组几乎不用。
3、二维数组静态初始化
int[][] array = {{1, 1, 1}, {2, 3, 4, 5}, {0, 0, 0, 0}, , , , , , , };

// 一维数组
int[] array = {100, 200, 300};

// 二维数组，以下代码当中：里面是4个一维数组
int[][] a = {
{100, 200, 300},
{30, 20, 40, 50, 60},
{6, 7, 9, 1},
{0}
};

int[][] a2 = {
{100, 200, 300},
{30, 20, 40, 50, 60},
{6, 7, 9, 1},
{0},
{1, 2, 3, 4, 5}
};

动态初始化二维数组：
// 3个一维数组，每一个一维数组当中4个元素。
int[][] array = new int[3][4];

int[][] a = {{1, 2, 3, 4}, {4, 5, 6, 76}, {1, 23, 4}};
printArray(a); // 遍历二维数组方法（自己写）

// 没有这种语法
// printArray({{1, 2, 3, 4}, {4, 5, 6, 76}, {1, 23, 4}});

// 可以这样写。
printArray(new int[][]{{1, 2, 3, 4}, {4, 5, 6, 76}, {1, 23, 4}});

1、数组
1.1、数组的优点和缺点，并且要理解为什么。
第一：空间存储上，内存地址是连续的。
第二：每个元素占用空间大小相同。
第三：知道首元素的内存地址。
第四：通过下标可以计算出偏移量。
通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，直接通过内存地址定位，效率非常高。
优点：检索效率高。
缺点：随机增删效率较低，数组无法存储大数据量。
注意；数组最后一个元素的增删效率不受影响。

1.2、一维数组的静态初始化和动态初始化
静态初始化：
int[] arr = {1, 2, 3, 4};
Object[] objs = {new object(), new Object(), new Object()};
动态初始化：
int[] arr = new int[4]; // 4 个长度，每个元素默认值 0
Object[] objs = new Object[4]; // 4 个长度，每个元素默认值 null

1.3、一维数组遍历
for(int i = 0; i < arr.length; i++){
System.out.printl(arr[i]);
}

1.4、二维数组的静态初始化和动态初始化
静态初始化：
int[][] arr = {
{1, 2, 34},
{54, 4, 34, 3},
{2, 34, 4, 5}
};
Object[][] objs = {
{new Object(), new Object()},
{new Object(), new Object()},
{new Object(), new Object(), new Object()},
};
动态初始化：
int[][] arr = new int[3][4];
Object[][] objs = new Object[4][4];
Animal[][] anis = new Animal[4][6];
// Person 类型数组，里面可以存储 Person 类型对象，以及 Person 类型的子类型都可以。
Person ps = new Person[2][2];

1.5、二维数组的遍历
for(int i = 0; i < arr.length; i++){ // 外层for循环负责遍历外面的一维数组。
// 里面这个 for 循环负责遍历二维数组里面的一维数组。
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j]);
}
// 换行。
System.out.println();
}

1.6、main 方法上“String[] args”参数的使用（以后一般都是有界面的）
1.7、数组的拷贝：System.arraycopy() 方法的使用
数组有一个特点：长度一旦确定，不可变。
所以数组长度不够的时候，需要扩容，扩容的机制是：新建一个大数组，
将小数组中的数据拷贝到大数组当中，然后小数组对象被垃圾回收。

1.8、对数组中存储引用数据类型的情况，要会画它的内存结构图。
例：“abc”，字符串也是 java 对象，属于 String 类型。字符串在 java 中有优待，不需要 new 也是一个对象。
Object[] 这是一个万能的口袋，这个口袋中可以装任何引用数据类型的数据。

所有的 System.out.println() 方法执行时，如果输出引用的话，自动调用引用的 toString() 方法。

2、数组
2.1、常见的算法：
排序算法：
冒泡排序算法
选择排序算法

查找算法：
二分法查找

2.2、算法实际上在 java 中已经封装好了。
排序可以调用方法。例如：java 中提供了一个数组工具类：
java.util.Arrays
Arrays 是一个工具类。
其中有一个 sort() 方法，可以排序。静态方法，直接使用类名调用就行。
工具类当中的方法大部分都是静态的。
java 有一套庞大的类库。