第十九章 数组

1 数组

1.1 一维数组的相关知识点

1、Java语言中的数组是一种引用数据类型。不属于基本数据类型，数组的父类是Object
​
2、数组实际上是一个容器，可以同时容纳多个元素。
    数组：字面意思是“一组数据”
    
3、数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。
​
4、数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的）
​
5、数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”
​
6、数组一旦创建，在java中规定，长度不可变。
​
7、数组的分类：一维数组、二维数组、三维数组、多维数组...（一维数组使用较多，二维数组偶尔使用）
​
8、所有的数据对象都有length属性，用来获取数组中元素的个数。
​
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;
​
15、怎么初始化一个一维数组呢？
    包括两种方式：静态初始化一维数组。动态初始化一维数组。
    静态初始化语法格式：
        int[] array = {100, 200,231};
    动态初始化语法格式：
        int[] array = new int[5];  // 这里的5表示数组的元素个数。初始化一个5个长度的int类型的数组，每个元素默认值为0
​
​
public class ArrayTest01 {
    public static void main(String[] args) {
        // 声明一个int类型的数组，使用静态初始化的方式
        int[] a = {1, 100 , 10, 20, 55, 8382};
        // 这是c++风格，不建议java中使用。
        // int a[] = {1, 100 , 10, 20, 55, 8382};
​
        // 所有的数组对象都有length属性
        System.out.println(a.length);
​
        // 数组中每一个元素都有下标
        // 通过下标对数组中的元素进制存和取。
        // 取
        System.out.println("第一个元素: " + a[0]);
        System.out.println("第一个元素: " + a[a.length-1]);
​
        // 存（改）
        // 把第一个元素修改为111
        a[0] = 111;
        // 把最后一个元素修改为0
        a[a.length - 1] = 0;
        System.out.println("第一个元素: " + a[0]);
        System.out.println("第一个元素: " + a[a.length-1]);
​
        // 一维数组怎么遍历呢？
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]);
        }
​
        // 下标为6青第7个元素，第7个元素没有，越界了，会出现什么异常？
        // System.out.println(a[6]);  // ArrayIndexOutOfBoundsException（比较著名的异常）
​
        // 从最后一个元素遍历到第一个元素
        for (int i = a.length-1; i >= 0; i--){
            System.out.println(a[i]);
        }
    }
}
​

 

1.2 动态初始化一维数组

关于每个类型的默认值还有印象吗？
    数据类型        默认值
    -------------------------
    byte            0
    short           0
    int             0
    long            0L
    float           0.0F
    double          0.0
    boolean         false
    char            \u0000
    引用数据类型     null
​
什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？
    当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。
    当你创建数组的时候，不确定数组中存储哪些具体数据，你可以采用动态初始化的方式，预先分配内存空间。
​
​
public class ArrayTest02 {
    public static void main(String[] args) {
        // 声明/定义一个数组，采用动态初始化的方式创建
        int[] a = new int[4];  // 创建长度为4的int数组，数组中每个元素的默认值是0
​
        // 后期赋值
        a[0] = 111;
        a[1] = 222;
        a[2] = 333;
        a[3] = 444;
​
        // 遍历数组
        for(int i = 0; i < a.length; i++){
            System.out.println("数组中下标为" + i + "的元素是" + a[i]);
        }
​
        // 初始化一个Object类型的数组，采用动态初始化方式
        Object[] objs = new Object[3];  // 3个长度，动态初始化，所以每个元素默认值是null
        for(int i = 0; i < objs.length; i++){
            System.out.println(objs[i]);
        }
​
        String[] strs = new String[3];
        for(int i = 0; i < strs.length; i++){
            System.out.println(strs[i]);
        }
​
        // 采用静态初始化的方式
        String[] strs2 = {"abc", "def", "xyz"};
        for(int i = 0; i < strs2.length; i++){
            System.out.println(strs[i]);
        }
​
        // 采用静态初始化的方式存储Object
        /*
        Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();
        Object[] objects = {o1, o2, o3};
         */
        Object[] objects = {new Object(), new Object(), new Object()};
        for (int i = 0; i < objects.length; i++){
            System.out.println(objects[i]);
        }
​
    }
}
​

 

1.3 方法的参数是数组如何传参

ArrayTest03.java

package com.bjpowernode.javase.array;
​
public class ArrayTest03 {
    public static void main(String[] args) {
        System.out.println("Hello World");
​
        // java的风格。
        int[] a1 = {1, 23, 33};
        for(int i = 0; i < a1.length; i++){
            System.out.println(a1[i]);
        }
​
        // c++的写法，不建议
        int a2[] = {3, 432, 11};
        for(int i = 0; i < a2.length; i++){
            System.out.println(a2[i]);
        }
​
        // 调用方法时传一个数组
        int[] x = {1, 2, 3, 4};
        printArray(x);
​
        // 创建String数组
        String[] strs = {"abc", "def", "hehe", "hello"};
        printArray(strs);
​
        String[] strArray = new String[10];
        printArray(strArray);
​
        printArray(new String[3]);
        printArray(new int[3]);
​
    }
​
    public static void printArray(int[] array){
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }
​
    public static void printArray(String[] array){
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }
​
}
​

ArrayTest04.java

package com.bjpowernode.javase.array;
​
// 当一个方法的参数是一个数组时候，我们还可以采用这种方式传。
​
public class ArrayTest04 {
    public static void main(String[] args) {
        // 静态初始化一维数组
        int[] a = {1, 2, 3};
        printArray(a);
​
        // 动态初始化一维数组
        int[] a2 = new int[4];
        printArray(a2);
​
        printArray(new int[5]);
        // 经过测试没有这种语法
        // printArray({1, 2, 3});
        // 如果直接传递一个静态数组的话，语法必须这样写。
        printArray(new int[]{1, 2, 3});
    }
​
    public static void printArray(int[] array){
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }
}
​

 

1.4 main方法的String数组

ArrayTest05.java

package com.bjpowernode.javase.array;
​
/*
main方法上面的“String[] args”有什么用？
    分析一下：谁负责调用main方法（JVM）
    JVM调用main方法的时候，会自动传一个String数组过来。
 */
​
public class ArrayTest05 {
    // 这个方法程序员负责写出来，JVM负责调用，JVM调用的时候一定会传一个String数组过来
    public static void main(String[] args) {
        // JVM默认传递过来的这个数组的长度。默认0
        // 通过测试得出：args不是null
        System.out.println("JVM给传递过来的String数组参数，它这个数组的长度是多少？" + args.length);
​
        // 以下这一行代码表示的含义：数组对象创建了，但是数组中没有任何数据。
        // String[] strs = new String[0];
        // String[] strs = {};
        // printLength(strs);
​
        // 这个数组什么时候里面会有值呢？
        // 其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为String[] args
        // 例如这样运行程序：java ArrayTest05 a b c
        // 那么这个时候JVM会自动将a b c通过空格的方式进行分离，分离完成之后，自动放到String[] args数组当中。
        // 所以main方法上面的String[] args数组主要是用来接收用户输入的参数的。
        // 把a b c转换成字符串数组：{"a", "b", "c"}
        // 遍历数组
        for(int i = 0; i < args.length; i++){
            System.out.println(args[i]);
        }
    }
​
    public static void printLength(String[] args){
        System.out.println(args.length);  // 0
    }
}
​

ArrayTest06.java

package com.bjpowernode.javase.array;
​
/*
模拟一个系统，假设这个系统要使用，必须输入用户名和密码。
 */
​
public class ArrayTest06 {
    // 用户名和密码输入到String[] args数组当中
    public static void main(String[] args) {
        if(args.length != 2){
            System.out.println("使用该系统时请输入程序参数，参数中包含用户名和密码信息，例如：zhangsan 123");
            return;
        }
​
        // 程序执行到此处说明用户确实提供了用户名和密码
        // 接下来你应该判断用户名和密码是否正确
        // 取出用户名
        String username = args[0];
        // 取出密码
        String password = args[1];
        // 假设用户名是xiaohong，密码是123的时候表示登录成功，其它的一律失败
        // 判断两个字符串是否相等，需要使用equals方法。
        // if(username.equals("xiaohong") && password.equals("123")){
        if("xiaohong".equals(username) && "123".equals(password)){  // 这样编写可以避免空指针异常
            System.out.println("登录成功，欢迎[" + username + "]回来");
        }else{
            System.out.println("验证失败，用户名不存在或密码错误!");
        }
    }
}
​

 

1.5 数组中存储引用数据类型

package com.bjpowernode.javase.array;
​
/*
一维数组的深入，数组中存储的类型为：引用数据类型
对于数组来说，实际上只能存储java对象的“内存地址”。数组中存储的每个元素都是“引用”。
 */
​
public class ArrayTest07 {
    public static void main(String[] args){
        //创建一个Animal类型的数组
        Animal a1 = new Animal();
        Animal a2 = new Animal();
        Animal[] animals = {a1, a2};
​
        // 对Animal数组进制遍历
        for(int i = 0; i < animals.length; i++){
            /*
            Animal a = animals[i];
            a.move();
             */
            // 代码合并
            animals[i].move();
        }
​
        // 动态初始化一个长度为2的Animal类型数组。
        Animal[] ans = new Animal[2];
        // 创建一个Animal类型的对象放到数组的第一个位置
        ans[0] = new Animal();
​
        // Animal数组中只能存放Animal类型，不能存放Product类型。
        // ans[1] = new Product();
​
        // Animal数组中可以存放Cat类型的数据，因为Cat是一个Animal。是Animal的子类
         ans[1] = new Cat();
​
         // 创建一个Animal类型的数组，数组当中存储Cat和Bird
        Animal[] anis = {new Cat(), new Bird()};  // 该数组中存储了两个对象的内存地址。
        for(int i = 0; i < anis.length; i++){
            // 这个取出来的可能是Cat，也可能是Bird，不过肯定是一个Animal
            // 如果调用的方法是父类中存在的方法不需要向下转型，直接使用父类引用调用即可。
            // Animal an = anis[i];
            // an.move();
​
            // 调用子对象特有的方法，需要向下转型
            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 Animal{
    public void move(){
        System.out.println("Animal move...");
    }
}
​
// 商品类
class Product{
​
}
​
// 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("Birds are singing");
    }
}
​

 

1.6 数组扩容和拷贝

关于一维数组的扩容。
在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？
    数组满了，需要扩容。
    java中对数组的扩容是：
        先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中
​
结论：数组扩展效率较低，因为涉及到拷贝的问题，所以在以后的开发中请注意，尽可能少的使用数组拷贝。
    可以在创建数组对象的时候预估以下多长合适，最好预估准确，这样可以减少数组的扩容次数，提高效率。
​
​
public class ArrayTest08 {
    public static void main(String[] args) {
        // java中数组是怎么进制拷贝的呢？
        // System.out.println();
​
        // 拷贝源
        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]);
        }
         */
​
        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]);
        }
​
        Object[] objs = {new Object(), new Object(), new Object()};
        Object[] newObjs = new Object[10];
        // 思考一下，这里拷贝的时候是拷贝对象，还是拷贝对象的地址。（地址）
        System.arraycopy(objs, 0, newObjs, 0, objs.length);
        for(int i = 0; i < newObjs.length; i++){
            System.out.println(newObjs[i]);
        }
    }
}
​

 

 

 

 

2 二维数组

2.1 对二维数组的理解

1、二维数组其实是一个特殊的二维数组，特殊在这个一维数组当中的每一个元素都是一个一维数组。
​
2、三维数组是什么？
    三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。
    实际开发中使用最多的是一维数组，二维数组也很少使用，三维数组几乎不用。
​
3、二维数组静态初始化
    int[][] array = {{1,2,3}, {4,5,6}, {7,8,9}};
​
​
public class ArrayTest09 {
    public static void main(String[] args) {
        // 一维数组
        int[] array = {100, 200, 300};
​
        // 二维数组
        int[][] a = {
                {100, 200, 300},
                {30, 20, 40, 50, 60},
                {6, 7, 9, 1},
                {0}
        };
        
    }
}
​

 

2.2 二维数组元素的访问

关于二维数组中元素的：读和改
    a[二维数组中的一维数组的下标][一维数组的下标]
    a[0][0]: 表示第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[] a0 = a[0];
        // 取出这个二维数组中第一个一维数组中的第一个元素。
        System.out.println(a0[0]);
        System.out.println(a[0][0]);
​
        // 取出第2个一维数组当中的第3个元素
        System.out.println(a[1][2]);
​
        // 改
        a[2][0] = 1111;
        System.out.println(a[2][0]);
    }
}
​

 

2.3 遍历二维数组

package com.bjpowernode.javase.array;
​
/*
二维数组的遍历
 */
​
public class ArrayTest11 {
    public static void main(String[] args) {
​
        // 二维数组
        String[][] array = {
                {"java", "oracle", "c++", "python", "c#", "go"},
                {"张三", "小宏", "小花"},
                {"luck", "jack", "rose"}
        };
​
        // 遍历二维数组
        for(int i = 0; i < array.length; i++){  // 外层循环3次。（负责纵向）
            // 内层循环负责输出一行
            for(int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + " ");
            }
            // 换行
            System.out.println();
        }
    }
}
​

 

2.4 方法的参数是一个二维数组

package com.bjpowernode.javase.array;
​
public class ArrayTest12 {
    public static void main(String[] args) {
        // 3行4列
        // 3个一维数组，每一个一维数组当中有4个元素。
        int[][] array = new int[3][4];
​
        /*
        // 二维数组遍历
        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
         */
​
        // 静态初始化
        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}});
    }
​
    public static void printArray(int[][] array){
        // 遍历二维数组
        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
​
}
​

 

3 数组总结

1 数组的优点和缺点，并且要理解为什么。
    第一：空间存储上，内存地址是连续的。
    第二：每个元素占用的空间大小相同。
    第三：知道首元素的内存地址。
    第四：通过下标可以计算出偏移量。
    第五：通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，直接通过内存地址定位，效率非常高。
    
    优点：
        检索效率误高。
        缺点：随机增删效率较低，数组无法存储大数据量。
        注意：数组最后一个元素的增删效率不受影响。
        
        
2 一维数组的静态初始化和动态初始化
    静态初始化：
        int[] arr = {1, 2, 3, 4};
        Object[] objs = {new Object(), new Object()};
`   动态初始化：
        int[] arr = new int[4];
        Objectp[] objs = new Object[4];
​
​
3、一维数组的遍历
    for(int i = 0; i < arr.length; i++){
        System.out.println(arr[i]);
    }
    
​
4、二维数组的静态初始化和动态初始化
    静态初始化：
        int[][] arr = {{1, 2}, {3, 4}, {5, 6}};
        Object[][] arr = {{new Object(), new Object()}}, {new Object(), new Object()}}, {new Object(), new Object()}};
    动态初始化：
        int[][] arr = new int[3][4];
        Object[][] arr = new Object[3][4];
        // Person类型数组，里面可以存储Person类型对象，以及Person类型的子类型
        Person[][] arr = new Person[3][4];
​
​
5、二维数组的遍历
    for(int i = 0; i < arr.length; i++){  // 外层for循环负责遍历里面的一维数组
        for(int j = 0; j < arr[i].length; j++){  // 内层for循环负责遍历一维数组里面的元素
            System.out.print(arr[i][j]);
        }
        System.out.println();
    }
    
​
6、main方法上“String[] args”参数的使用（非重点，了解一下，以后一般都是有界面的，用户可以在界面上输入用户名和密码等参数信息）
​
​
7、数组的拷贝：System.arraycopy()方法的使用
    数组有一个特点：长度一旦确定，不可变。
    所以数组长度不够的时候，需要扩容，扩容的机制是：新建一个大数组，
    将小数组中的数据拷贝到大数组，然后小数组对象被垃圾回收。
    
    
8、对数组中存储引用数据类型的情况，要会画它的内存结构图。
​

 

 

4 解决昨天的两个作业题：

4.1 数组模拟栈

MyStack.java

package com.bjpowernode.javase.array.homework;
​
/*
编写程序，使用一维数组，模拟栈数据结构。
要求：
    1、这个栈可以存储java中的任何引用类型的数据。
    2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息）
    3、在栈中提供pop方法模拟弹栈。（栈空了，也有提示信息）
    4、编写测试程序，new栈对象，调用push pop方法来模拟压栈和弹栈的动作。
    5、假设栈的默念初始化容量是10。（请注意无参构造方法的编写方式）
 */
​
public class MyStack {
    // 向栈当中存储元素，我们这里使用一维数组模拟。存到栈中，就表示存储到数组中。
    // 因为数组是我们学习java的第一个容器。
    // 为什么选择Object类型的数组？因为这个栈可以存储java中任何引用类型的数据
​
    private Object[] elements;
​
    // 栈帧，永远指向栈顶部元素
    // 那么这个默认初始值应该是多少。注意：最初的栈是空的，一个元素都没有。
    // private int index = 0;  // 如果index采用0，表示栈帧指向了顶部元素的上方。
    private int index;  // 如果index采用-1，表示栈帧指向了顶部元素。
​
    // 无参数构造方法。默认初始化栈容量10
    public MyStack() {
        // 一维数组动态初始化
        // 默认初始化容量是10
        this.elements = new Object[10];
        this.index = -1;
    }
​
    // 压栈的方法
    public void push(Object obj){
        if(this.index >= this.elements.length-1){
            System.out.println("栈已满");
            return;
        }
        // 程序能够走到这里，说明栈没满
        // 向栈中加1个元素，栈帧账上移动一个位置
        this.elements[++index] = obj;
        System.out.println("压栈" + obj + "成功，栈帧指向" + index);
    }
​
    // 弹栈的方法
    public void pop(){
        if(index < 0){
            System.out.println("弹栈失败，栈里已经没有东西了");
            return;
        }
        System.out.println("弹栈" + elements[index--] + "成功，栈帧指向" + index);
​
    }
​
    // set和get也许用不上，但是你必须写上，这是规矩。
    public Object[] getElements(){
        return elements;
    }
    public void setElements(Object[] elements){
        this.elements = elements;
    }
​
    public int getIndex() {
        return index;
    }
​
    public void setIndex(int index) {
        this.index = index;
    }
}
​

MyStackTest.java

package com.bjpowernode.javase.array.homework;
​
public class MyStackTest {
    public static void main(String[] args) {
        // 创建一个栈对象，初始化容量是10个
        MyStack stack = new MyStack();
​
        // 调用方法压栈
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        // 压这个元素失败了
        stack.push(new Object());
​
        // 弹栈
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
    }
}
​

 

4.2 酒店管理系统的模拟

Room.java

package com.bjpowernode.javase.array.homework;
​
// 酒店的房间
​
public class Room {
    /*
    房间编号
        1楼：101 102 103 104...
        2楼：201 202 203 204...
        3楼：301 302 303 304...
     */
    private int no;
​
    /*
    房间类型：标准间 单人间 总统套房
     */
    private String type;
​
    /*
    房间状态
        true表示空闲，房间可以被预定
        false表示占用，房间不能预定
     */
    private boolean status;
​
    // 构造方法
    public Room() {
    }
​
    public Room(int no, String type, boolean status) {
        this.no = no;
        this.type = type;
        this.status = status;
    }
​
    // setter and getter
    public int getNo() {
        return no;
    }
​
    public void setNo(int no) {
        this.no = no;
    }
​
    public String getType() {
        return type;
    }
​
    public void setType(String type) {
        this.type = type;
    }
​
    // IDEA工具对于boolean类型的变量，生成的get方法的方法名是：isXxx()
    // 如果你不喜欢，可以修改为getXxx()
    public boolean getStatus() {
        return status;
    }
​
    public void setStatus(boolean status) {
        this.status = status;
    }
​
    // equals方法重写
    // equals是用来比较两个对象是否相同的。
    // 至于怎么比较，这个还是程序自己定。
    public boolean equals(Object obj){
        if(obj == null || !(obj instanceof Room)) return false;
        if(this == obj) return true;
        Room room = (Room)obj;
        // 当前房间编号 等于 传过来的房间对象的房间编号。认为是同一个房间
        return this.no == room.getNo();
    }
​
    // toString方法重写
    // toString方法的目的就是将java对象转换成字符串形式。
    // 怎么转，转换成什么格式，程序员自己定。目的就是：简单、清晰、明了。
    public String toString(){
        // return "[102, 单人间，空闲]";  // 写死了
​
        // 动态
        return "[" + no + "," + type + "," + (status?"空闲":"占用") + "]";
    }
​
    /*
    // 编写一个临时程序测试一下
    public static void main(String[] args) {
        Room room = new Room(101, "单人间", false);
        // System.out.println(room.toString());
        // room是一个引用
        // println(引用)，会自动调用引用的toString()方法。
        System.out.println(room);
    }
     */
}
​

Hotel.java

package com.bjpowernode.javase.array.homework;
​
/*
酒店对象，酒店中有二维数组，二维数组模拟大厦
 */
public class Hotel {
        /*
        二维数组，模拟大厦所有的房间
         */
        private Room[][] rooms;
​
        // 盖楼通过构造方法来盖楼。
    public Hotel(){
        // 一共有几层，每层的房间类型是什么，每个房间的编号是什么。
        // 我们可以先写死。一共三层、一层单人间、二层标准间、三层总统套房，每层有10个房间
        /*
        房间编号
            1楼：101 102 103 104...
            2楼：201 202 203 204...
            3楼：301 302 303 304...
            ...
         */
        // 动态初始化
        rooms = new Room[3][10];
​
        // 创建30个Room对象，放到数组当中
        // 怎么放？二维数组的遍历
        for(int i = 0; i < rooms.length; i++){  // i是下标：0 1 2， i+1是楼层：1 2 3
            for(int j = 0; j < rooms[i].length; j++){
                if(i == 0){
                    // 一层
                    rooms[i][j] = new Room((i+1)*100 + j + 1, "单人间", true);
                }else if(i == 1){
                    // 二层
                    rooms[i][j] = new Room((i+1)*100 + j + 1, "标准间", true);
                }else if(i == 2){
                    // 三层
                    rooms[i][j] = new Room((i+1)*100 + j + 1, "总统套房", true);
                }
            }
        }
    }
​
    // 在酒店对象上提供一个打印房间列表的方法
    public void print(){
        // 打印所有房间状态，就是遍历二维数组
        for(int i = 0; i < rooms.length; i++){
            for(int j = 0; j < rooms[i].length; j++){
                // 里面for循环负责输出一层
                System.out.print(rooms[i][j] + "  ");
            }
            // 换行
            System.out.println();
        }
    }
​
    /*
    订房方法
        调用引方法时需要传递一个房间编号过来，这个房间编号是前台人员输入的。
     */
    public void order(int roomNo){
        // 订房最主要的是将房间对象的status修改为false
        // 假设房间编号207（下标是[1][6]）
        // 通过房间编号演算出下标，获取房间对象
        Room room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
        room.setStatus(false);
        System.out.println(roomNo + "已订房");
    }
​
    /*
    退房
     */
    public void exit(int roomNo){
        Room room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
        room.setStatus(true);
        System.out.println(roomNo + "已退房");
    }
​
}
​

HotelMgtSystem.java

package com.bjpowernode.javase.array.homework;
​
/*
为某个酒店编写程序酒店管理系统，模拟订房、退房、打印所有房间状态等功能。
    1、该系统的用户是：酒店前台。
    2、酒店中所有的房间使用一个二维数组来模拟。
    3、酒店中的每一个房间应该是一个java对象：Room
    4、每一个房间Room应该有：房间编号、房间类型属性、房间是否空闲
    5、系统应该对外提供的功能：
        可以预定房间：用户输入房间编号，订房
        可以退房：用户输入房间编号，退房
        可以查看所有房间的状态：用户输入某个指令应该可以查看所有房间状态
 */
​
import java.util.Scanner;
​
public class HotelMgtSystem {
    public static void main(String[] args) {
        // 创建酒店对象
        Hotel hotel = new Hotel();
        // 打印房间状态
        // hotel.print();
​
        /*
        首先输出一个欢迎页面
         */
        System.out.println("欢迎使用酒店管理系统，请认真阅读以下使用说明");
        System.out.println("功能编号对应功能编号：[1]表示查看房间列表; [2]表示订房; [3]表示退房; [0]表示退出系统");
        Scanner s = new Scanner(System.in);
​
        while(true){
            System.out.print("请输入功能编号: ");
            int i = s.nextInt();
            if(i == 1){
                // 查看房间列表
                hotel.print();
            }else if(i == 2){
                // 订房
                System.out.print("请输入订房房间编号: ");
                int roomNo = s.nextInt();
                hotel.order(roomNo);
            }else if(i == 3){
                // 退房
                System.out.print("请输入退房房间编号: ");
                int roomNo = s.nextInt();
                hotel.exit(roomNo);
            }else if(i == 0){
                // 退出系统
                System.out.println("再见，欢迎下次再来");
                return;
            }else{
                // 出错了
                System.out.println("输入功能有误，请从新输入");
            }
        }
​
    }
}
​

 

 

5 算法

5.1 常见的算法

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

 

5.2 数组工具类

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

 

5.3 冒泡排序法

冒泡排序算法
    1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。
    2、核心：
        拿着左边的数字和右边的数据比对
​
原始数据：
3, 2, 7, 6, 8
第1次循环：（最大的跑到最右边）
2, 3, 7, 6, 8  (3和2比较， 2 < 3, 所以2和3交换位置）
2, 3, 7, 6, 8  (虽然不需要交换位置：但是3和7还是需要比较一次）
2, 3, 6, 7, 8  (7和6交换位置）
2, 3, 6, 7, 8  (虽然不需要交换位置：但是7和8还是需要比较一次）
​
经过第1次循环，此时剩下参与比较的数据：2, 3, 6, 8
第2次循环：
2, 3, 6, 7  (2和3比较，不需要交换位置）
2, 3, 6, 7  (3和6比较，不需要交换位置）
2, 3, 6, 7  (6和7比较，不需要交换位置）
​
经过第2次循环，此时剩下参与比较的数据：2, 3, 6
第3次循环：
2, 3, 6  (2和3比较，不需要交换位置）
2, 3, 6  (3和6比较，不需要交换位置）
​
经过第3次循环，此时剩下参与比较的数据：2, 3
第4次循环：
2, 3  (2和3比较，不需要交换位置）
​
​
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次比较：不交换)
​
参与比较的数据：
第5次循环：
0 6 7  (1次比较：交换)
0 6 7  (2次比较：不交换)
​
参与比较的数据：0 6
第6次循环：
0 6  (1次比较：不交换)
​
// for(int i = 0; i < 数组.length - 1; i++){
for(int i = 6; i > 0; i--){
    // 7条数据比6次
    // 6条数据比5次
    // 5条数据比4次
    // 4条数据比3次
    // 3条数据比2次
    // 2条数据比1次
    for(int j = 0; j < ???; j++){
​
    }
}
       
       
public class BubbleSort {
    public static void main(String[] args) {
        // 这是int类型的数组对象
        // int[] arr = {3, 2, 7, 6, 8};
        int[] arr = {9, 8, 10, 7, 6, 0, 11};
​
        // 经过冒泡排序算法对以上数组中元素进制排序
        // 冒泡排序算法的核心是什么？
        // 7条数据，循环6次，以下可以循环6次
        /*
        for(int i = 0; i < arr.length-1; i++){
            System.out.println(i);
        }
         */
​
        // 7条数据，循环6次，以下代码可以循环6次。
        int count = 0;
        for(int i = arr.length-1; i > 0; i--){
            for(int j = 0; j < i; j++){
                // 不管是否需要交换位置，总之是要比较一次的。
                count++;
                if(arr[j] > arr[j+1]){
                    // 交换位置
                    // arr[j] 和 arr[j+1]交换
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
​
        System.out.println("比较次数: " + count);
        // 输出结果
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}
       

 

5.4 选择排序

选择排序比冒泡排序的效率高
高在交换位置的次数上
选择排序交换位置是有意义的。
​
循环一次，然后找出参与比较的这坑数据中最小的，拿着这个最小的值和最前面的数据交换位置。
​
参与比较的数据：3 1 6 2 5
第1次循环之后的结果是：
1 3 6 2 5
​
参与比较的数据：3 6 2 5
第2次循环之后的结果是：
2 6 3 5
    
参与比较的数据：6 3 5
第3次循环之后的结果是：
3 6 5 
    
参与比较的数据：6 5
第4次循环之后的结果是：
5 6
    
注意：5条数据，循环4次    
​
每一次从这堆参与比较的数据当中找出最小值，
拿着这个最小值和最前面的元素交换位置。
选择排序比冒泡排序好在：每一次的交换位置都是有意义的。
关键点：选择排序中的关键在于，你怎么找出一堆数据中最小的。
    3 2 6 1 5
    假设：
        第一个3是最小的。
        3和2比较，发现12更小，所以此时最小的是2
        继续拿着2往下比对，2和6比较，2仍然是最小的
        继续拿着2住下比对，2和1比对，发现1更小，所以此时最小的是1
        继续拿着1往下比对，1和5比对，发现1还是小的，所以1就是最小的。
        拿着1和最左边的3交换位置。
    2 6 3 5
    假设：
        第一个2是最小的。
        ...
    6 3 5
    假设：6是最小的
        6和3比对，发现3更小，所以此时最小的是3
        ...
​
    
public class SelectSort {
    public static void main(String[] args) {
        // int[] arr = {3, 1, 6, 2, 5};
        int[] arr = {9, 8, 10, 7, 6, 0, 11};
        // 选择排序
        // 5条数据循环4次。（外层循环4次）
        int count = 0;
        int count2 = 0;
        for(int i = 0; i < arr.length-1; i++){
            // i的值是0 1 2 3
            // i正好是“参与比较的这堆数据中”最左边那个元素的下标。
            // System.out.println(i);
            // i是一个参与比较的这堆数据中的起点下标。
            // 假设起点i下标位置上的元素是最小的。
            int min = i;
            for(int j = i + 1; j < arr.length; j++){
                count++;
                // System.out.println("===>" + j);
                if(arr[j] < arr[min]){
                    min = j;  // 最小值的元素下标是j
                }
                // 当i和min相等时，表示最初猜测是对的
                // 当i和min不相等时，表示最初的猜测是错的，有比这个元素更小的元素，需要拿着这个更小的元素和最左边的元素交换位置。
            }
            if(min != i){
                // 表示存在更小的数据
                // arr[min] 最小的数据
                // arr[i] 最前面的数据
                count2++;
                int temp;
                temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
​
        // 冒泡排序和选择排序的比较次数没变，但是交换次数变少了。
        System.out.println("比较数据" + count);
        System.out.println("交换数据" + count2);
        // 排序之后遍历
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
​
    }
}
    

 

5.5 二分法查找

第一：二分法查找建立在排序的基础之上。
​
第二：二分浍查找 效率要高于“一个挨着一个”的这种查找方式
​
第三：二分法查找原理？
    10 23 56 89 100 111 222 235 500 600
    
    目标：找出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相等，此时找到了。    
    

1、数组工具类：自己写的。不是SUN的
​
2、关于查找算法中的：二分法查找
    10 11 12 13 14 15 16 17 18 19 20
​
    通过二分法查找，找出18这个元素的下标
        (0 + 10) / 2 --> 中间元素的下标：5
​
    拿着中间这个元素和目标要查找的元素进制对比：
        中间元素是：arr[5] --> 15
        15 < 18(被查找的元素)
        被查找的元素18在目前中间元素15的右边。
        所以开始元素的下标从0变成5+1
​
    再重新计算一个中间元素的下标：
        开始下标是：5+1
        结束下标是：10
        (6+10) / 2 --> 8
​
    8 下标对应的元素arr[8]是18
        找到的中间元素正好和被找的元素18相等，表示找到了：下标为8
​
    二分法查找的终止条件：一直折半，直到中间的那个元素恰好是被查找的元素就结束。
​
3、二分法查找算法是基于排序的基础之上。（没有排序的数据是无法查找的）
​

ArraySearch.java

package com.bjpowernode.javase.array;
​
/*
数组的元素查找
    数据元素查找有两种方式：
        第一种方式：一个一个挨着找，直到找到为止。
        第二种方式：二分法查找（算法），这个效率比较高
 */
​
import org.w3c.dom.ls.LSOutput;
​
import java.sql.SQLOutput;
​
public class ArraySearch {
    public static void main(String[] args) {
        // 这个例子演示一下第一种方式
        int[] arr = {4, 5, 6, 87, 8};
​
        /*
        // 需求找出87的下标，如果没有返回-1
        // 一个一个挨着找。
        for(int i = 0; i < arr.length; i++){
            if(arr[i] == 87){
                System.out.println("87元素的下标是: " + i);
                return;
            }
        }
        // 程序执行到此处，表示没有87
        System.out.println("87不存在该元素");
         */
​
        // 最好以上的程序封装成一个方法，思考：传什么参数？返回什么值？
        // 传什么：每一个参数是数组，第二个参数是被查找的元素
        // 返回值：返回被查找的这个元素的下标，如果找不到返回-1
        int index = arraySearch(arr, 2);
        System.out.println(index == -1 ? "该元素不存在": "该元素下标是: " + index);
    }
​
    /**
     * 从数组中检索某个元素的下标
     * @param arr 被检索的数组
     * @param ele 被检索的元素
     * @return 大于等于0的数表示元素的下标，-1表示该元素不存在
     */
    private static int arraySearch(int[] arr, int ele) {
        for(int i = 0; i < arr.length; i++){
            if(ele == arr[i]){
                return i;
            }
        }
        return -1;
    }
​
}
​

ArrayUtil.java

public class ArrayUtil {
    public static void main(String[] args) {
        int[] arr = {100, 200, 230, 235, 600, 1000, 2000, 9999};
​
        // 找出arr这个数组中200所在的下标。
        // 调用方法
        int index = binarySearch(arr, 999);
        System.out.println(index == -1 ? "该元素不存在" : "该元素的下标是: " + index);
    }
​
    /**
     * 从数组中查找目标元素的下标
     * @param arr  被查找的数据（这个必须是已经排序的)
     * @param dest 目标元素
     * @return -1表示该元素不存在，其它表示该元素的下标
     */
    private static int binarySearch(int[] arr, int dest) {
        // 开始下标
        int begin = 0;
        // 结束下标
        int end = arr.length - 1;
​
        // 开始元素的下标只要在结束元素下标的左边，就有机会继续循环
        while(begin <= end){
            // 中间元素下标
            int mid = (begin + end) / 2;
            if(arr[mid] == dest){
                return mid;
            }else if(arr[mid] < dest){
                // 目标在“中间的”右边
                // 开始元素的下标需要发生变化(开始元素的下标需要重新赋值)
                begin = mid + 1;
            }else{
                // arr[mid] > dest
                // 目标在“中间”的左边
                // 修改结束元素的下标
                end = mid - 1;
            }
        }
        return -1;
    }
}
​

 

5.6 介绍一下java.util.Arrays工具类

所有方法都是静态的，直接用类名调用
主要使用的是两个方法：
    二分法查找，排序
​
​
package com.bjpowernode.javase.array;
​
/*
好消息：
    SUN公司已经为我们程序员写好了一个数组工具类。
    java.util.Arrays;
 */
​
import java.util.Arrays;
​
public class ArraysTest02 {
    public static void main(String[] args) {
        // java.util.Arrays; 工具类中有哪些方法，我们开发的进修要参考API帮助文档
        // 不要死记硬背
        int[] arr = {3, 6, 5, 12, 1, 2, 32, 5, 5};
        // 排序
        Arrays.sort(arr);
        // 输出
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
        // 二分法查找（建立在排序的基础之上）
        int index = Arrays.binarySearch(arr, 32);
        System.out.println(index == -1 ? "该元素不存在" : "该元素下标是: " + index);
    }
}
​