自学java （day26）：数组

/**
 * 数组元素查找
 *      两种方法：
 *          一个一个找
 *          二分法查找
 */
//一个一个找
public class ArraySearch {
    public static void main(String[] args) {
        int[] arr={4,5,6,7,87,3};

        /*
        //找出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 = arraySearsh(arr,87);
        System.out.println(index == -1?"该元素不存在":"该元素的下标是："+index);
        
    }

    public static int arraySearsh(int[] arr, int ex) {
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ex){
                return i;

            }
        }
        return -1;
    }

}

import java.util.Arrays;

/**
 * 使用Sun公司的数组工具类：java.util.Arrays；
 *      所有方法都是静态的，直接用类名调用
 *      主要使用两个方法：
 *          二分法查找，排序
 *      以后要看API帮助文档，不要死记硬背（帮助文档打开方式：两次shift，搜索Array）
 */
public class ArraysTest01 {
    public static void main(String[] args) {
        /*
        int[] arr={3,64,75,8,96,575};

        //工具类中的大部分方法都是静态的
        Arrays.sort(arr);//可以排序

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
*/
        //java.util.Arrays；工具类中有那些方法，我们开发的时候需要参考API帮助文档
        //不要死记硬背。
        int[] arr = {3,4,5,6,7,84,68,37,8,2};
        //排序
        Arrays.sort(arr);
        //输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

        //二分法查找（建立在排序基础之上）
        int index = Arrays.binarySearch(arr,68);
        System.out.println(index == -1?"该元素不存在":"该元素下标是："+index);
    }
}

/**
* Array
*       1、java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object。
*       2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）
*           数组字面意思是“一组数据”
*       3、数组当中可以存储“基本数据类型的数据”，也可以存储“引用数据类型的数据”。
*       4、数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆内存中）
*       5、数组在内存方面是怎么样的一个图形？
 *      6、数组当中如果存储的是java对象的话，实际上存储的是对象的引用或者叫内存地址。
 *      7、数组一旦创建，在java中规定，长度不可变。（数组长度不可变）
 *      8、数组的分类：一维数组、二维数组、三维数组、多维数组....（一维数组使用最多）
 *      9、所以的数组对象都有length属性（java自带的），用来获取数组中元素的个数。
 *      10、java中的数组要求数组元素的类型统一（int类型的数组只能存储int类型数据）
 *      11、数组在内存方面存储的时候，数组中的元素内存地址是连续的。（数组存储元素的特点）
 *      12、所以的数组都是拿首元素的内存地址作为整个数组对象的内存地址。（数组最后一个元素的下标是：length-1）
 *      13、数组的这种数据结构的优缺点：
 *          优点：查询/查找/检索某个下标的元素时，效率极高
 *                  为啥检索效率高
 *                      第一：每一个元素的内存地址的空间是连续的
 *                      第二：每个元素的类型相同，所占空间是一样的
 *                      第三：知道首元素的地址，知道每个元素占用空间的大小，就可以算出每个元素的内存地址，所以效率高。
 *          缺点：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率低，因为随机删除元素，会涉及到后边的元素统一
 *              向前或者向后位移的操作
 *               数组不能存储大数据量，因为很难在内存空间上找到一块特别大的连续的内存空间。
 *
 *          注意：对于数组中最后一个元素的增删是没有影响的。
 *       14、怎么声明或者定义一个一维数组：
 *              语法格式：
 *                      int[] array1；
 *                      double[] array2；
 *                      boolean[] array3；
 *
 *       15、怎么初始化一维数组：
 *          包括两种形式：静态初始化一维数组，动态初始化一维数组。
 *          静态初始化语法格式：
 *              int[]  array={122,45,68,5};
 *          动态初始化语法格式：
 *              int[] array=new int[5];     //5表示数组的元素个数，长度为5，每个元素的默认值为0
 *              String[] names=new String[6];    //初始化六个长度的一维数组，每个元素默认值为null
 *
* */

public class ArrayTest01 {
    public static void main(String[] args) {
        //使用静态初始化int类型的一维数组
        int[] array1={1,2,3,5,4,6};

        //所有的数组对象都有length属性
        System.out.println("元素的个数="+array1.length);

        //通过下标对数组元素进行存和取
        System.out.println("第一个元素="+array1[0]);
        System.out.println("最后一个元素="+array1[array1.length-1]);

        //修改第一个元素
        array1[0]=21;
        System.out.println("第一个元素="+array1[0]);

        //一维数组怎么遍历？
        for(int i=0;i<=array1.length-1;i++){
            System.out.print(array1[i]);
        }
        System.out.println("\n");

        //数组越界会出现：ArrayIndexOutOfBoundsException这个异常
        //System.out.println(array1[6]);

        //从最后一个元素遍历到第一个元素
        for(int i=array1.length-1;i>=0;i--){
            System.out.print(array1[i]);
        }

        //使用动态初始化一维数组
    }
}

/**
 *      关于每个类型的默认值
 *          数据类型        默认值
 *          ------------------------
 *          byte            0
 *          short           0
 *          int             0
 *          long            0
 *          float           0.0f
 *          double          0.0
 *          char            \u0000
 *          boolean         false
 *          引用数据类型      null
 *
 *      什么时候使用静态初始化方式，什么时候使用动态初始化方式？
 *          当你创建数组的时候，确定数组中存储那些具体元素的时候，使用静态初始化方式。
 *          当你创建数组的时候，不确定数组中存储那些元素的时候，使用动态初始化方式，预先分配内存空间。
 */
public class ArrayTest02 {
    public static void main(String[] args) {
        //使用动态初始化一维数组
        int[] array1=new int[4];//创建int型数组，默认值为0
        //遍历数组
        for(int i=0;i<array1.length;i++){
            System.out.println("下标为"+i+"的元素是"+array1[i]);
        }

        //初始化Object类型的动态数组
        Object[] objs=new Object[3];//3个长度，动态初始化，所以每个元素默认值是null
        for(int i=0;i< objs.length;i++){
            System.out.println(objs[i]);
        }
    }
}

public class ArrayTest03 {

    //main方法的编写方式可以采用C++的语法格式：String args[]
    public static void main(String[] args) {

        //调用方法时传一个数组printArray
        int[] x={1,2,3,4};
        printArray(x);

        printArray(new int[3]);
    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

//当一个方法的参数是一个数组的时候，可以采用这种方法传。
public class ArrayTest04 {
    public static void main(String[] args) {
        //静态初始化一维数组
        int[] a={1,2,3};
        printArray(a);

        //直接传一个静态数组的话，语法必须是这样的
        printArray(new int[]{1,2,3});

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

        printArray(new int[4]);
    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
        }
        System.out.println("\n");
    }
}

/**
 *      main方法上面的”String[] args“有什么用？？？
 *          分析：谁去调用main方法（答案：JVM）
 *          JVM调用main方法的时候，会自动传一个String数组过来。
 */
public class ArrayTest05 {
    //这个方法程序员写出来，JVM负责调用，调用的时候一定会传一个String数组过来。
    public static void main(String[] args) {
        //默认长度是0
        System.out.println("JVM给传递过来的String数组参数，这个数组的长度是："+args.length);

        //这个数组里面什么时候会有值呢？？
        //这个数组是留给用户的，用户可以在控制台输入参数，这个参数会自动转换成” String[] args “
        //例如这个运行程序：java ArrayTest05 abc def xyz
        //那么JVM会自动将“abc def xyz”通过空格的方式分离，分离完成之后，自动放到” String[] args “数组下
        //所以main方法上面的” String[] args “是用来接收用户输入的
        //输入之后把“abc def xyz”转化成字符串数组：{”abc“，”def“，”xyz“}
        //遍历数组
        for (int i = 0; i < args.length; i++) {
            System.out.println(i);
        }
    }
}

/**
 *  模拟一个系统，假设这个系统需要输入用户名和密码，才能使用。
 */
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 passworld=args[1];//数组的第二个元素就是密码

        //假设用户名是admin，密码是123的时候表示登陆成功，其他都是失败。
        //判断两个字符串是否相等，使用equals方法。
        if(username.equals("admin")&&passworld.equals("123")){
            System.out.println("登录成功，欢迎["+username+"]回来");
            System.out.println("请您继续使用改系统！！");
        }else {
            System.out.println("验证失败，用户名不正确或者密码错误");
        }
    }
}

/**
 *      一维数组的深入，数组中存储的数据类型为：引用数据类型
 *      对于数组来说，实际上只能存储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
            Animal a=animals[i];
            //a去调用move
            a.move();
             */
            //代码合并
            animals[i].move();
        }

        //动态初始化一个长度为二的Animal类型的数组
        Animal[] ans=new Animal[2];
        //创建一个Animal对象，放到数组的第一个位置上
        ans[0]=new Animal();

        //Animal数组中只能存放Animal类型的
      //  ans[1]=new Product();//报错

        //Animal数组中可以存放Cat类型的数据，因为Cat是Animal的子类。孩子可以往数组里放
        ans[1]=new Cat();

        //创建Animal类型的数组，数组当中存放Cat和Bird
        Animal[] anis={new Cat(),new Bird()};//数组存放了另个对象的内存地址
        for (int i = 0; i < anis.length; i++) {

            //Cat c=anis[i];//报错，不能这样
            //如果调用的这个方法是父类中的方法不需要向下转型，直接使用父类型引用调用即可。
            Animal c=anis[i];
            c.move();


            //子类中有特有的方法，这样调用，需要强制转换
            if(anis[i] instanceof Cat){
                Cat c1=(Cat)anis[i];
                c1.catMouse();
            } else if (anis[i] instanceof Bird) {
                Bird b=(Bird)anis[i];
                b.sing();
            }
        }
    }
}

class Animal{
    public void move(){
        System.out.println("Animal move.....");
    }

}

//商品类
class Product{

}

class Cat extends Animal {
    public void move() {
        System.out.println("猫仔粥.....");
    }

    //特有方法
    public void catMouse(){
        System.out.println("猫捉老鼠");
    }
}

class Bird extends Animal {
    public void move() {
        System.out.println("鸟在飞.....");
    }
    //特有方法
    public void sing(){
        System.out.println("鸟在唱歌");
    }
}

/**
 * 关于一维数组的扩容。
 *      在java开发中，数组长度一旦确定，不可变，数组满了怎么办？
 *          数组满了，需要扩容
 *          java中对数组的扩容是：
 *              先新建一个大容量的数组，然后将小容量的数组中的数据一个一个的拷贝到大数组当中。
 */
public class ArrayTest08 {
    public static void main(String[] args) {
        //java中的数组怎么拷贝？
        //System.arraycopy();//就用这个拷贝

        //拷贝源：从这个数组拷贝
        int[] src={1,11,22,3,4};

        //拷贝目标（拷贝到这个数组上）
        int[] dest=new int[20];//动态初始化长度为20的数组

        //调用JDK System类中的arraycopy方法，来完成数组拷贝
        System.arraycopy(src,1,dest,5,3);//(拷贝源，拷贝源的起始位置，拷贝目标，拷贝目标的起始位置，拷贝的长度)
        
        //遍历目标数组
        for (int i = 0; i < dest.length; i++) {
            System.out.print(dest[i]+" ");//000001122300000000000
        }
        System.out.println("\n");

        //数组中如果存储的元素是引用，怎么拷贝
        String[] strs={"hello","world","study","java"};
        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]);
        }
    }
}

/**
 * 关于java中的二维数组
 *      1、二维数组其实是特殊的一维数组，特殊在一维数组中的每个元素是一个一维数组。
 *      2、三维数组是什么:三维数组是一个特殊的二维数组，特殊在这个二维数组中的每个元素是一个一维数组。
 *          使用最多的是一维数组，二维数组也少，三维数组基本不用。
 *      3、二维数组静态初始化：int[][] a={{10,20,30},{100,120,150},{1,2,6,4,9,8,2,0}};
 *
 */
public class ArrayTest09 {
    public static void main(String[] args) {
        //一维数组
        int[] array={10,20,30};

        //二维数组
        int[][] a={{10,20,30},{100,120,150},{1,2,6,4,9,8,2,0}};

        //三维数组
        int[][][] a1={{{15,26},{45,63}},{{55,16},{55,66}}};


    }
}

/**
 *      关于二维数组中元素的，读和改
 */
public class ArrayTest10 {
    public static void main(String[] args) {
        int[][] a={
                {15,23,16},
                {78,16,89,52},
                {56,26,51,23,0}
        };

        //请取出第一个一维数组
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[0][i]);
        }

        //改
        a[0][1]=123;
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[0][i]);
    }
}
}

/**
 *  二维数组的遍历
 */
public class ArrayTest11 {
    public static void main(String[] args) {
        //二维数组
        String[][] array={
                {"java","oracle","c++","python","c#"},
                {"张三","李四","王五"},
                {"luck","jack","rose"}
        };
        //遍历二维数组
        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();
        }
    }
}

/**
 *  动态初始化二维数组
 */
public class ArrayTest12 {
    public static void main(String[] args) {
        //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,7},
                {1,2,3,63}
        };

        printArray(a);
    }



    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();//换行
        }
    }
}

/**
 * 数组工具类（自己写的）
 * 1、关于查找算法中的：二分查找：（是基于排序的基础之上，要是一个有序的序列）
 * 10 11 12 13 14 15 16 17 18 19 20
 * 通过二分查找找到18这个元素的下标:
 *          1.（第一个下标+最后元素的下标）/2--->找到中间元素的下标
 *          2、拿中间这个元素和目标要查找的元素对比：
 *              目标元素<中间元素：（第一个元素下标+中间元素下标）/2--->设置新的中间元素的下标
 *              目标元素>中间元素：（最后一个元素下标+中间元素下标+1）/2--->设置新的中间元素的下标
 *              目标元素=中间元素：（找到了）
 */
public class ArrayUtil {
    public static void main(String[] args) {
        int[] arr={100,200,230,235,1000,2000,9999};
        //找出arr数组中的200所在的下标
        //调用方法
        int index = binarySearch(arr,2000);
        System.out.println(index==-1?"该元素不存在":"该元素下标是："+index);

    }

    /**
     *从数组中查找目标元素的下标
     * @param arr 备查找的数组（必须是已经排序的）
     * @param dest 要查找的元素（目标元素）
     * @return -1表示该元素不存在，其他表示返回该元素的下标
     */
    public 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;
                mid = (mid + end) / 2;
            } else if (arr[mid] > dest) {
                //结束元素下标重写赋值
                end = mid - 1;
                mid = (mid + begin) / 2;
            }
        }
        return -1;
    }
}

/**
 * 冒泡排序算法
 * 3,2,7,6,8
 *
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr={9,8,10,7,6,0,11};

        //冒泡排序的外层循环
        //确定要比较的次数
        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]){
                    //交换
                    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.print(arr[i]+" ");
        }
        System.out.println();
    }
}

/**
 * 选择排序
 *      关键是怎么找出最小的
 */
public class SelectSotr {
    public static void main(String[] args) {
        int[]  arr={3,1,6,2,5};
        //输出原数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        System.out.println();

        //选择排序五个数据，外层循环四次；；需要四个数据依次比较
        for (int i = 0; i < arr.length-1; i++) {//数组下标为0123的依次和后边元素做比较
            //i=0 1 2 3
            //i正好是“参与比较的这对数据中”最左边元素的下标
            //测试i的程序
            //System.out.println(i);
            for(int j=i+1;j< arr.length;j++){//被外循环作为比较对象的元素的数组下标
                //System.out.println("==>"+j);
                int min=arr[i];
                if(arr[i]>arr[j]){
                    int temp;
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }

        //输出结果
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        System.out.println();
    }
}

/**
 *  java软件工程师人生路上的第一个小型项目，锻炼一下面向对象
 *      为某个酒店编写程序，酒店管理系统，模拟订房、退房、打印所以房间状态等功能。
 *      1、该系统的用户是：酒店前台。
 *      2、酒店使用一个二维数组来完成
 *      3、酒店中的每个房间应该是一个java对象。
 *      4、每个房间应该有：房间号，房间类型，房间是否空闲。
 *      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]表示退出系统!!!");
       while (true){
           System.out.println("请输入功能编号：");
           Scanner s=new Scanner(System.in);
           int i=s.nextInt();
           if (i == 1) {
               //房间信息
               hotel.print();
           } else if (i == 2) {
               //订房
               System.out.println("请输入订房编号：");
               int roomNo=s.nextInt();//前台输入订房编号
               hotel.order(roomNo);
           }else if(i == 3){
               //退房
               System.out.println("请输入退房编号：");
               int roomNo=s.nextInt();
               hotel.exit(roomNo);
           }else if(i == 0){
               //退出系统
               System.out.println("欢迎下次再来");
               return;
           }else {
               //出错了
               System.out.println("输入的编号有误，请重新输入!!");
           }
       }
    }
}

/**
 * 酒店对象，酒店中有二维数组，二维数组模拟大厦
 */
public class Hotel {
    /**
     * 二维数组模拟大厦，所有的房间
     */
    private Room[][] rooms;

    //通过构造方法来盖楼，盖房间
    public Hotel(){
        //一共几层，每层的什么类型，每个房间的编号是什么
        /**
         * 房间编号
         * 1楼：101,102,103
         * 2楼：201,202,203
         * 3楼：..........
         * ..........
         */
        //三层楼，每层十个房间
        //到这里就只有房间的架子，什么都没有
        rooms = new Room[3][10];

        //创建30个Room对象，放到数组中
        //二维数组遍历
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms[i].length; j++) {
                if(i==0){//1层
                    rooms[i][j]=new Room(((i+1)*100+j+1),"单人间",true);
                } else if (i==1) {//2层
                    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++) {
                Room room=rooms[i][j];
                System.out.print(room);
            }
            System.out.println();
        }
    }

    //订房

    /**
     * 订房方法
     * 调用这个方法需要传一个房间编号，这个房间编号是前台输入的
     * @param roomNo
     */
    public void order(int roomNo){
        //订房主要是将房间状态status改为false
        //Room对象的status修改为false
        //通过房间编号，算出下标，获取房间对象
        Room room=rooms[roomNo/100-1][roomNo%100-1];
        room.setStatus(false);
        System.out.println(roomNo+"已订房");
    }

    /**
     * 退房
     */
    public void exit(int roomNo){
        //订房主要是将房间状态status改为true
        //Room对象的status修改为true
        //通过房间编号，算出下标，获取房间对象
        Room room=rooms[roomNo/100-1][roomNo%100-1];
        room.setStatus(true);
        System.out.println(roomNo+"已退房");
    }
}

/**
 * 酒店的房间
 */
public class Room {
    /**
     * 房间编号
     * 1楼：101,102,103
     * 2楼：201,202,203
     * 3楼：..........
     * ..........
     */
    private int no;//房间编号
    /**
     * 房间类型：标准间，单人间，双人间
     */
    private String type;//房间类型
    /**
     * 房间状态
     * ture表示空闲，可以被预定
     * false表示占用，不可以被预定
     */
    private boolean status;//房间状态

    //构造方法
    public Room() {
    }

    public Room(int no, String type, boolean status) {
        this.no = no;
        this.type = type;
        this.status = status;
    }

    //setter和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;
    }

    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    //equals方法重写
    @Override
    public boolean equals(Object obj) {
        if(obj==null||!(obj instanceof Room)) return false;
        if(this==obj)  return true;
        Room room=(Room) obj;
        if(this.no==room.getNo()) return true;
        return false;
    }

    //toString方法重写
    @Override
    public String toString() {
        return "["+no+","+type+","+(status?"空闲":"占用")+"]";
    }

    /*
    //编写临时程序测试一下(toString()方法)，一会删掉
    public static void main(String[] args) {
        Room room=new Room(101,"单人间",true);
        System.out.println(room.toString());
        //room是一个引用
        //println（），会自动调用引用的toString（）方法
        System.out.println(room);

    }
    */
}

/**
 * 编写程序，使用一维数组，模拟栈数据结构。
 * 要求：
 *     1、这个栈可以存储java中的任何引用数据类型的数据。
 *     2、在栈中提供push方法模拟压栈、（栈满了，要有提示信息）
 *     3、在栈中提供pop方法模拟压栈。 （栈空了，要有提示信息）
 *     4、编写测试程序，new栈对象，调用push pop方法来模拟压栈出栈动作。
 *     5、假设栈的初始化容量是10，（注意构造方法的编写方式）
 */

public class MyStack {
    //向栈中存储元素，我们这里使用一维数组模拟，存到栈中，就表示存到数组中。
    //因为数组是我们学习java的第一个容器。
    //为什么选择Object类型数组：因为这个栈可以存储java中的任何引用数据类型的数据。
    //Object类型任何类型的数据的数组就相当于哆啦A梦的口袋，可以存储。
    private Object[] elements;

    //栈帧，永远指向栈顶元素的位置
    private int index;

    /**
     * 无参构造方法，默认栈初始化是10
     */
    public MyStack() {
        //一维数组动态初始化
        //默认初始化容量是10
        this.elements=new Object[10];

        //给index初始化
        this.index=-1;
    }

    /**
     * 压栈的方法
     * @param obj  被压的元素
     */
    public void push(Object obj){
        //判断栈满不满
        if(index>=elements.length-1){
            System.out.println("栈已满！！！");
            return;
        }
        //程序到这里就说明栈没满，index加一
        this.index++;
        this.elements[index]=obj;
        System.out.println("压栈"+obj+"元素成功，栈帧指向"+index);
    }

    /**
     * 出栈的方法,从数组往外取元素
     */
    public void pop(){
        if(index<0){
            System.out.println("栈已空！！！");
            return ;
        }
        //程序到这里就说明栈没空，index减一
        System.out.print("出栈"+elements[index]+"元素成功，");
        index--;
        System.out.println("栈帧指向"+index);
    }

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

public class MyStackTest {
    public static void main(String[] args) {
        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();
    }

}