day23&24 数组

相关概念

day23课堂笔记

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.println(arr[i]);
	}

1.4、二维数组的静态初始化和动态初始化
	静态初始化：
		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];
		....

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、对数组中存储引用数据类型的情况，要会画它的内存结构图。

day24课堂笔记

1、解决昨天的两个作业题：
第一题：数组模拟栈。
第二题：酒店管理系统的模拟。

2、数组

2.1、常见的算法：

	排序算法：
		冒泡排序算法
		选择排序算法

	查找算法：
		二分法查找
	
	以上算法在以后的java实际开发中我们不需要使用的。
	因为java已经封装好了，直接调用就行。
	只不过以后面试的时候，可能会有机会碰上。

2.2、算法实际上在java中不需要精通，因为java中已经封装好了，
要排序就调用方法就行。例如：java中提供了一个数组工具类：
	java.util.Arrays
		Arrays是一个工具类。
		其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。

3、冒泡排序：

参与比较的数据：9 8 10 7 6 0 11
第1次循环：
8 9 10 7 6 0 11 (第1次比较：交换)
8 9 10 7 6 0 11 (第2次比较：不交换)
8 9 7 10 6 0 11 (第3次比较：交换)
8 9 7 6 10 0 11 (第4次比较：交换)
8 9 7 6 0 10 11 (第5次比较：交换)
8 9 7 6 0 10 11 (第6次比较：不交换)
最终冒出的最大数据在右边：11

参与比较的数据：8 9 7 6 0 10
第2次循环：
8 9 7 6 0 10（第1次比较：不交换）
8 7 9 6 0 10（第2次比较：交换）
8 7 6 9 0 10（第3次比较：交换）
8 7 6 0 9 10（第4次比较：交换）
8 7 6 0 9 10（第5次比较：不交换）

参与比较的数据：8 7 6 0 9
第3次循环：
7 8 6 0 9（第1次比较：交换）
7 6 8 0 9（第2次比较：交换）
7 6 0 8 9（第3次比较：交换）
7 6 0 8 9（第4次比较：不交换）

参与比较的数据：7 6 0 8
第4次循环：
6 7 0 8（第1次比较：交换）
6 0 7 8（第2次比较：交换）
6 0 7 8（第3次比较：不交换）

参与比较的数据：6 0 7
第5次循环：
0 6 7（第1次比较：交换）
0 6 7（第2次比较：不交换）

参与比较的数据：0 6
第6次循环：
0 6 （第1次比较：不交换）

for(int i = 6; i > 0; i–){ // 6次
//7条数据比6次
//6条数据比5次
//5条数据比4次
//4条数据比3次
//3条数据比2次
//2条数据比1次
for(int j = 0; j < i; j++){

}

}

4、选择排序：

选择排序比冒泡排序的效率高。
高在交换位置的次数上。
选择排序的交换位置是有意义的。

循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和
最前面的数据“交换位置”。


参与比较的数据：3 1 6 2 5 （这一堆参加比较的数据中最左边的元素下标是0）
第1次循环之后的结果是：
1 3 6 2 5 

参与比较的数据：3 6 2 5 （这一堆参加比较的数据中最左边的元素下标是1）
第2次循环之后的结果是：
2 6 3 5 

参与比较的数据：6 3 5 （这一堆参加比较的数据中最左边的元素下标是2）
第3次循环之后的结果是：
3 6 5 

参与比较的数据：6 5 （这一堆参加比较的数据中最左边的元素下标是3）
第4次循环之后的结果是：
5 6

注意：5条数据，循环4次。

5、二分法查找（折半查找）：

第一：二分法查找建立在排序的基础之上。
第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
第三：二分法查找原理？
	10(0下标) 23 56 89 100 111 222 235 500 600(下标9) arr数组
	
	目标：找出600的下标
		(0 + 9) / 2 --> 4（中间元素的下标）
	
	arr[4]这个元素就是中间元素：arr[4]是 100
	100 < 600
	说明被查找的元素在100的右边。
	那么此时开始下标变成：4 + 1

		(5 + 9) / 2 --> 7（中间元素的下标）
		arr[7] 对应的是：235
		235 < 600
		说明被查找的元素在235的右边。
	
	开始下标又进行了转变：7 + 1
		(8 + 9) / 2 --> 8
		arr[8] --> 500
		500 < 600
		开始元素的下标又发生了变化：8 + 1
		(9 + 9) / 2 --> 9
		arr[9]是600，正好和600相等，此时找到了。

6、介绍一下java.util.Arrays工具类。
所有方法都是静态的，直接用类名调用
主要使用的是两个方法：
二分法查找，排序
以后要看文档，不要死记硬背。

code

ArrayTest08 数组拷贝

package com.bjpowernode.javase.array;

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

        // 拷贝源（从这个数组中拷贝）
        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
        }
         */

        System.arraycopy(src, 0, dest, 0, src.length);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }

        // 数组中如果存储的元素是引用，可以拷贝吗？当然可以。
        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]);
        }

        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]);
        }
    }
}