JavaSE 进阶 - 第19章 数组（一）
一、一维数组
1.0、数组
1.1、数组的优点和缺点
1.2、一维数组的静态初始化和动态初始化
1.3、一维数组的遍历
1.4、对数组中存储引用数据类型的情况，要会画它的内存结构图。
1.5、数组的拷贝：System.arraycopy()方法的使用
二、二维数组
0、关于java中的二维数组
1、关于二维数组中元素的：读和改。
2、二维数组的静态初始化和动态初始化
3、二维数组的遍历
传送门
一、一维数组
1.0、数组
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
下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。
1.1、数组的优点和缺点
第一：空间存储上，内存地址是连续的。
第二：每个元素占用的空间大小相同。
第三：知道首元素的内存地址。
第四：通过下标可以计算出偏移量。
通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，
直接通过内存地址定位，效率非常高。优点：检索效率高。
缺点：1、随机增删效率较低
因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
2、数组无法存储大数据量。
因为很难在内存空间上找到一块特别大的连续的内存空间。
注意：数组最后一个元素的增删效率不受影响。
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.println(arr[i]);
}1.4、对数组中存储引用数据类型的情况，要会画它的内存结构图。
package com.yuming.javase.array;
/**
* 一维数组的深入，数组中存储的类型为：引用数据类型
* 对于数组来说，实际上只能存储java对象的“内存地址”。数组中存储的每个元素是“引用”。
*/
public class ArrayTest07 {
public static void main(String[] args) {
// a是一个数组。a[0] 、a[1]、 a[2] 分别是是数组中的第一个、第二个、第三个元素。
int[] a = {100, 200, 300};
System.out.println(a[1]); // 200
int[] array = {1,2,3};
for (int i = 0; i < array.length; i++) { //遍历array数组
System.out.println(array[i]);
}
// 创建一个Animal类型的数组
Animal a1 = new Animal();
Animal a2 = new Animal();
Animal[] animals = {a1, a2};
for (int i = 0; i < animals.length; i++) { // 对Animal数组进行遍历
animals[i].move(); // 这个move()方法不是数组的。是数组当中Animal对象的move()方法。
}
// 动态初始化一个长度为2的Animal类型数组。
Animal[] ans = new Animal[2];
// 创建一个Animal对象，放到数组的第一个盒子中。
ans[0] = new Animal();
// Animal数组中只能存放Animal类型，不能存放Product类型。
//ans[1] = new Product();
// Animal数组中可以存放Cat类型的数据，因为Cat是一个Animal。
// Cat是Animal的子类。
ans[1] = new Cat();
// 创建一个Animal类型的数组，数组当中存储Cat和Bird
Cat c = new Cat();
Bird b = new Bird();
Animal[] anis = {c, b};
//Animal[] anis = {new Cat(), new Bird()}; // 该数组中存储了两个对象的内存地址。
for (int i = 0; i < anis.length; i++){
// 这个取出来的可能是Cat，也可能是Bird，不过肯定是一个Animal
// 如果调用的方法是父类中存在的方法不需要向下转型。直接使用父类型引用调用即可。
//anis[i]
//Animal an = anis[i];
//an.move();
//Animal中没有sing()方法。
//anis[i].sing();
// 调用子对象特有方法的话，需要向下转型！！！
if(anis[i] instanceof Cat){
Cat cat = (Cat)anis[i];
cat.catchMouse();
}else if(anis[i] instanceof Bird){
Bird bird = (Bird)anis[i];
bird.sing();
}
}
}
}
// 商品类
class Product{
}
class Animal{
public void move(){
System.out.println("Animal move...");
}
}
// Cat是子类
class Cat extends Animal {
public void move(){
System.out.println("猫在走猫步！");
}
// 特有方法
public void catchMouse(){
System.out.println("猫抓老鼠！");
}
}
// Bird子类
class Bird extends Animal {
public void move(){
System.out.println("Bird Fly!!!");
}
// 特有的方法
public void sing(){
System.out.println("鸟儿在歌唱！！！");
}
}
/*运行结果：
200
1
2
3
Animal move...
Animal move...
猫抓老鼠！
鸟儿在歌唱！！！
*/
1.5、数组的拷贝：System.arraycopy()方法的使用
数组有一个特点：长度一旦确定，不可变。
所以数组长度不够的时候，需要扩容，扩容的机制是：
新建一个大数组，将小数组中的数据拷贝到大数组，然后小数组对象被垃圾回收。
package com.yuming.javase.array;
/**
* 关于一维数组的扩容。
* 在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？
* 数组满了，需要扩容。
* java中对数组的扩容是：
* 先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。
*
* 结论：数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意：尽可能少的进行数组的拷贝。
* 可以在创建数组对象的时候预估计以下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。
*/
public class ArrayTest08 {
public static void main(String[] args) {
// 拷贝源（从这个数组中拷贝）
int[] src = {1, 11, 22, 3, 4};
// 拷贝目标（拷贝到这个目标数组上）
int[] dest = new int[20]; // 动态初始化一个长度为20的数组，每一个元素默认值0
/* // 调用JDK System类中的arraycopy方法，来完成数组的拷贝
System.arraycopy(src, 1, dest, 3, 2);
// 遍历目标数组
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]); // 0 0 0 11 22 0 ... 0
}*/
System.arraycopy(src, 0, dest, 0, src.length);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]); //1 11 22 3 4 0 ...0
}
// 数组中如果存储的元素是引用，可以拷贝吗？当然可以。
String[] strs = {"hello", "world!", "study", "java", "oracle", "mysql", "jdbc"};
String[] newStrs = new String[20];
System.arraycopy(strs, 0, newStrs, 0, strs.length);
for (int i = 0; i < newStrs.length; i++) {
System.out.println(newStrs[i]); //hello world! study java oracle mysql jdbc null ...null
}
System.out.println("================================");
Object[] objs = {new Object(), new Object(), new Object()};
Object[] newObjs = new Object[5];
// 思考一下：这里拷贝的时候是拷贝对象，还是拷贝对象的地址。（地址。）
System.arraycopy(objs, 0, newObjs, 0, objs.length);
for (int i = 0; i < newObjs.length; i++) {
System.out.println(newObjs[i]);
//java.lang.Object@f6f4d33
//java.lang.Object@23fc625e
//java.lang.Object@3f99bd52
// null
// null
}
}
}
二、二维数组
0、关于java中的二维数组
1、二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。
2、三维数组是什么？
三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。
实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。
3、二维数组静态初始化
int[][] array = {{1,1,1},{2,3,4,5},{0,0,0,0},{2,3,4,5},{2,3,4,5},{2,3,4,5},{2,3,4,5}};
public class ArrayTest09 {
public static void main(String[] args) {
// 一维数组
int[] array = {100, 200, 300};
System.out.println(array.length); // 3
System.out.println("=======================");
// 二维数组
// 以下代码当中：里面的是4个一维数组。
int[][] a = {
{100, 200, 300},
{30, 20, 40, 50, 60},
{6, 7, 9, 1},
{0}
};
System.out.println(a.length); // 4
System.out.println(a[0].length); // 3
System.out.println(a[1].length); // 5
System.out.println(a[2].length); // 4
System.out.println(a[3].length); // 1
// 里面的是5个一维数组。
int[][] a2 = {
{100, 200, 300},
{30, 20, 40, 50, 60},
{6, 7, 9, 1},
{0},
{1,2,3,4,5}
};
}
}
1、关于二维数组中元素的：读和改。
a [二维数组中的一维数组的下标] [一维数组的下标]
a[0][0]：表示第1个一维数组中的第1个元素。
a[3][100]：表示第4个一维数组中的第101个元素。
注意：对于a[3][100]来说，其中 a[3] 是一个整体。[100]是前面a[3]执行结束的结果然后再下标100.
public class ArrayTest10 {
public static void main(String[] args) {
// 二维数组
int[][] a = {
{34,4,65},
{100,200,3900,111},
{0}
};
// 请取出以上二位数中的第1个一维数组。
int[] 我是第1个一维数组 = a[0];
int 我是第1个一维数组中的第1个元素 = 我是第1个一维数组[0];
System.out.println(我是第1个一维数组中的第1个元素); // 34
// 以下代码的由来是因为以上代码的合并导致的。
System.out.println(a[0][0]); //34
// 取出第2个一维数组当中第3个元素
System.out.println("第二个一维数组中第三个元素：" + a[1][2]); //第二个一维数组中第三个元素：3900
// 取出第3个一维数组当中第1个元素
System.out.println("第3个一维数组中第1个元素：" + a[2][0]); //第3个一维数组中第1个元素：0
// 改
a[2][0] = 11111;
System.out.println(a[2][0]); //11111
// 注意别越界。
//java.lang.ArrayIndexOutOfBoundsException
//System.out.println(a[2][1]); //相当于第3个一维数组中第2个元素，但是并不存在
}
}2、二维数组的静态初始化和动态初始化
静态初始化：
int[][] arr = {
{1,2,34},
{54,4,34,3},
{2,34,4,5}
};
Object[][] arr = {
{new Object(),new Object()},
{new Object(),new Object()},
{new Object(),new Object(),new Object()}
};动态初始化：
int[][] arr = new int[3][4];
Object[][] arr = new Object[4][4];
Animal[][] arr = new Animal[3][4];
// Person类型数组，里面可以存储Person类型对象，以及Person类型的子类型都可以。
Person[][] arr = new Person[2][2];
....3、二维数组的遍历
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();
}传送门
上一章：JavaSE 进阶 - 第18章 面向对象（Object和匿名内部类）
下一章：JavaSE 进阶 - 第19章 数组（二）