数组
数组
- 什么是数组？ (数组实际上是一种简单的数据结构。)
- Java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object
- 数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。）
- 数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。
- 数组是存储在堆内存当中的
- 数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象
- 数组一旦创建，在java中规定，长度不可变
- 数组的分类：一维数组、二维数组、多维数组...（一维数组较多，二维数组偶尔使用！）
- 所有的数组对象都有length属性(java自带的)，用来获取数组中元素的个数
- java中的数组要求数组中元素的类型统一，比如：int类型数组只能存储int类型，Person类型数组只能存储Person类型。
- 数组在内存方面存储的时候，内存地址连续，这是数组存储元素的特点。
- 所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。（数组中首元素的内存地址作为整个数组对象的内存地址。）
- 数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length - 1
- 数组这种数据结构的优点和缺点是什么？
- 优点：
- 第一：每一个元素的内存地址在空间存储上是连续的。
- 第二：每一个元素类型相同，所以占用空间大小一样。
- 第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的。
eg：数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的。（算出一个内存地址，直接定位的。）
- 缺点：
- 第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
- 第二：数组不能存储大数据量，为什么？
因为很难在内存空间上找到一块特别大的连续的内存空间。 - 注意：对于数组中最后一个元素的增删，是没有效率影响的。
- 数组在堆内存的内存图：
一维数组（一）
- 怎么声明/定义一个一维数组？
- 语法格式：
int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
- 怎么初始化一个一维数组呢？
- 包括两种方式：静态初始化一维数组，动态初始化一维数组。
- 静态初始化语法格式：
int[] array = {100, 2100, 300, 55}; - 通过下标对数组中的元素进行存和取， array[0] 就应该为 100 ；
- 动态初始化语法格式：
int[] array = new int[5];
这里的5表示数组的元素个数，初始化一个5个长度的int类型数组，每个元素默认值0
String[] names = new String[6];
初始化6个长度的String类型数组，每个元素默认值null。
- eg [ 看懂这个列子 并自己敲出来 ] [ 一维数组的遍历 ] :
public class ArrayTest01 {
public static void main(String[] args) {
// 声明一个int类型的数组，使用静态初始化的方式
int[] a = {1, 100, 10, 20, 55, 689};
// 这是C++风格，不建议java中使用。
//int a[] = {1, 100, 10, 20, 55, 689};
// 所有的数组对象都有length属性
System.out.println("数组中元素的个数" + a.length);
// 数组中每一个元素都有下标
// 通过下标对数组中的元素进行存和取。
// 取（读）
System.out.println("第一个元素 = " + a[0]);
System.out.println("最后一个元素 = " + a[5]);
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[5]);
// 一维数组怎么遍历呢？
for(int i = 0; i < a.length; i++){
System.out.println(a[i]); // i是从0到5，是下标
}
// 下标为6表示第7个元素，第7个元素没有，下标越界了。会出现什么异常呢？
//System.out.println(a[6]); //ArrayIndexOutOfBoundsException（比较著名的异常。）
// 从最后一个元素遍历到第1个元素
for (int i = a.length - 1; i >= 0; i--) {
System.out.println("颠倒顺序输出-->" + a[i]);
}
}
}
- 什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？
- 当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。
- 当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间。
- 案例如下：
public class ArrayTest02 {
public static void main(String[] args) {
// 声明/定义一个数组，采用动态初始化的方式创建
int[] a = new int[4]; // 创建长度为4的int数组，数组中每个元素的默认值是0
// 遍历数组
for (int i = 0; i < a.length; i++) {
System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
}
// 后期赋值
a[0] = 1;
a[1] = 100;
a[2] = 111;
a[3] = 222; // 注意下标别越界。
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]);
}
System.out.println("===============================");
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(strs2[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++) {
/*Object o = objects[i];
System.out.println(o);*/
System.out.println(objects[i]);
}
}
}
- 当一个方法上参数类型为数组时：
自己总结的步骤：
- 第一步：声明一个同类型的数组，并完成初始化。
- 第二步：调用方法的形式参数为数组时，将声明后的同类型数组的名称，作为该方法的形式参数，传入即可。
- 案例1：动态初始化后 再手动赋值
- 如下：
public class ArrayTest02 {
public static void main(String[] args) {
// 声明/定义一个数组，采用动态初始化的方式创建
int[] a = new int[4]; // 创建长度为4的int数组，数组中每个元素的默认值是0
// 遍历数组
for (int i = 0; i < a.length; i++) {
System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
}
// 后期赋值
a[0] = 1;
a[1] = 100;
a[2] = 111;
a[3] = 222; // 注意下标别越界。
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]);
}
System.out.println("===============================");
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(strs2[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++) {
/*Object o = objects[i];
System.out.println(o);*/
System.out.println(objects[i]);
}
}
}
- 当方法的参数为数组时，用以下语法赋值
- 案例二如下：
public class ArrayTest04 {
public static void main(String[] args) {
// 静态初始化一维数组
int[] a = {1,2,3};
printArray(a);
System.out.println("============================");
// 没有这种语法。
//printArray({1,2,3});
// 如果直接传递一个静态数组的话，语法必须这样写。
printArray(new int[]{1,2,3});
// 动态初始化一维数组
int[] a2 = new int[4];
printArray(a2);
System.out.println("=============================");
printArray(new int[3]);
}
// 为什么要使用静态方法？方便呀，不需要new对象啊。
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
String[] args
- main方法上面的“String[] args”有什么用？
- 分析如下：谁负责调用main方法（JVM）
JVM调用main方法的时候，会自动传一个String数组过来 - jVM默认传递过来的这个数组对象的长度？ 默认0
- 这个数组什么时候里面会有值呢？
其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为“String[] args”
例如这样运行程序：java ArrayTest05 abc def xyz
- 那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中。
- 把abc def xyz 转换成字符串数组：{"abc","def","xyz"}
- 所以main方法上面的String[] args数组主要是用来接收用户输入参数的。
- 以下代码表示的含义：数组对象创建了，但是数组中没有任何数据。
String[] strs = new String[0];
String[] strs = {}; // 静态初始化数组，里面没东西。
- 案例一如下：
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);
// 例如这样运行程序：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(args[i]);
}
}
public static void printLength(String[] args){
System.out.println(args.length); // 0
}
}
- string[ ] args有什么作用？
- 模拟一个系统，假设这个系统要使用，必须输入用户名和密码。
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];
// 假设用户名是admin，密码是123的时候表示登录成功。其它一律失败。
// 判断两个字符串是否相等，需要使用equals方法。
//if(username.equals("admin") && password.equals("123")){
// 这样编写是不是可以避免空指针异常。
// 采用以下编码风格，及时username和password都是null，也不会出现空指针异常。（这是老程序员给的一条编程经验。）
if("admin".equals(username) && "123".equals(password)){
System.out.println("登录成功，欢迎[" + username + "]回来");
System.out.println("您可以继续使用该系统....");
}else{
System.out.println("验证失败，用户名不存在或者密码错误！");
}
}
}
一维数组（二）
- 一维数组的深入：
- 一维数组的深入，数组中存储的类型为：引用数据类型
- 对于数组来说，实际上只能存储java对象的“内存地址”。数组中存储的每个元素是“引用”
- 数组中存储的是引用的的案例：
public class ArrayTest07 {
public static void main(String[] args) {
// a是一个数组
// a[0] 是数组中的一个元素。
// a[1] 是数组中的一个元素。
int[] a = {100, 200, 300};
System.out.println(a[1]);
//a[2] = 400;
int[] array = {1,2,3};
for (int i = 0; i < array.length; i++) {
/*int temp = array[i];
System.out.println(temp);*/
System.out.println(array[i]);
}
// 创建一个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(); // 这个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 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("鸟儿在歌唱！！！");
}
}
数组的扩容与拷贝
- 在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？
- 数组满了，需要扩容。
- java中对数组的扩容是?
- 先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。
- 结论：
- 数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意：尽可能少的进行数组的拷贝。
- 可以在创建数组对象的时候预估计以下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。
- 数组的拷贝
- java中的数组是怎么进行拷贝的呢？
System.arraycopy(5个参数);
调用JDK System类中的 arraycopy 方法，来完成数组的拷贝
- 五个参数的说明：
（拷贝源，拷贝源的起始位置下标，拷贝目标，拷贝目标的终止位置下表，拷贝起始位置到终止位置中间有几个元素）；
注意事项：
- 拷贝目标 用动态方式初始化
- 下标是从0开始的
- 拷贝目标的终止位置下表：就是从拷贝目标第几个元素开始拷贝
- 课堂源码如下：
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]);
}
}
}
二维数组
- 关于java中的二维数组
- 二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。
- 三维数组是什么？
三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。
实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。 - 二维数组静态初始化
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}}; - 书写格式：
eg1:
int array[][] ={
{1,1,1},
{2,2,2},
{3,3,3}
};
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}
};
}
}
- 关于二维数组中元素的：读 和 改
a[二维数组中的一维数组的下标】[一维数组中的元素下标]
a[0] [0]：表示第1个一维数组中的第1个元素。
a[3 】[ 100 ]：表示第4个一维数组中的第101个元素。
注意：对于a[3] [100】来说，其中 a[3] 是一个整体。[100]是前面a[3]执行结束的结果然后再下标100. - eg2：
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个元素);
// 以下代码的由来是因为以上代码的合并导致的。
System.out.println(a[0][0]);
// 取出第2个一维数组当中第3个元素
System.out.println("第二个一维数组中第三个元素：" + a[1][2]);
// 取出第3个一维数组当中第1个元素
System.out.println("第3个一维数组中第1个元素：" + a[2][0]);
// 改
a[2][0] = 11111;
System.out.println(a[2][0]);
// 注意别越界。
//java.lang.ArrayIndexOutOfBoundsException
//System.out.println(a[2][1]);
}
}
java.lang.ArrayIndexOutOfBoundsException
下标越界异常
- 二维数组的遍历
eg3:
public class ArrayTest11 {
public static void main(String[] args) {
// 二维数组
String[][] array = {
{"java", "oracle", "c++", "python", "c#"},
{"张三", "李四", "王五"},
{"lucy", "jack", "rose"}
};
// 遍历二维数组
for(int i = 0; i < array.length; i++){ // 外层循环3次。（负责纵向。）
String[] 一维数组 = array[i];
// 负责遍历一维数组
for(int j = 0; j < 一维数组.length; j++){
System.out.print(一维数组[j] + " ");
}
// 输出换行符
System.out.println();
}
// 合并代码
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();
}
}
}
- 动态初始化二维数组
int[][] array = new int[3][4];
// 3行4列。
// 3个一维数组，每一个一维数组当中4个元素。
- 当方法的参数为数组时
eg4 二维数组的遍历:
// 静态初始化
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();
}
}
}
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++) { // 循环3次。
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
day 23天作业
- 编写程序，使用一维数组，模拟栈数据结构。
要求：
1、这个栈可以存储java中的任何引用类型的数据。
2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息。）
3、在栈中提供pop方法模拟弹栈。（栈空了，也有有提示信息。）
4、编写测试程序，new栈对象，调用push pop方法来模拟压栈弹栈的动作。
5、假设栈的默认初始化容量是10.（请注意无参数构造方法的编写方式。）
答案如下：
public class MyStack {
// 向栈当中存储元素，我们这里使用一维数组模拟。存到栈中，就表示存储到数组中。
// 因为数组是我们学习java的第一个容器。
// 为什么选择Object类型数组？因为这个栈可以存储java中的任何引用类型的数据
// new Animal()对象可以放进去，new Person()对象也可以放进去。因为Animal和Person的超级父类就是Object。
// 包括String也可以存储进去。因为String父类也是Object。
private Object[] elements;
// 栈帧，永远指向栈顶部元素
// 那么这个默认初始值应该是多少。注意：最初的栈是空的，一个元素都没有。
//private int index = 0; // 如果index采用0，表示栈帧指向了顶部元素的上方。
//private int index = -1; // 如果index采用-1，表示栈帧指向了顶部元素。
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;
}
// 程序能够走到这里，说明栈没满
// 向栈中加1个元素，栈帧向上移动一个位置。
index++;
elements[index] = obj;
// 在声明一次：所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法。
System.out.println("压栈" + obj + "元素成功，栈帧指向" + index);
}
/**
* 弹栈的方法，从数组中往外取元素。每取出一个元素，栈帧向下移动一位。
* @return
*/
public void pop(){
if(index < 0){
System.out.println("弹栈失败，栈已空！");
return;
}
// 程序能够执行到此处说明栈没有空。
System.out.print("弹栈" + elements[index] + "元素成功，");
// 栈帧向下移动一位。
index--;
System.out.println("栈帧指向" + index);
}
// set和get也许用不上，但是你必须写上，这是规矩。你使用IDEA生成就行了。
// 封装：第一步：属性私有化，第二步：对外提供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;
}
}
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();
}
}
- 为某个酒店编写程序：酒店管理系统，模拟订房、退房、打印所有房间状态等功能。
1、该系统的用户是：酒店前台。
2、酒店使用一个二维数组来模拟。“Room[][] rooms;”
3、酒店中的每一个房间应该是一个java对象：Room
4、每一个房间Room应该有：房间编号、房间类型、房间是否空闲.
5、系统应该对外提供的功能：
可以预定房间：用户输入房间编号，订房。
可以退房：用户输入房间编号，退房。
可以查看所有房间的状态：用户输入某个指令应该可以查看所有房间状态。
答案如下：
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("输入功能编号有误，请重新输入！");
}
}
}
}
/*
酒店对象，酒店中有二维数组，二维数组模拟大厦。
*/
public class Hotel {
/**
* 二维数组，模拟大厦所有的房间
*/
private Room[][] rooms;
// 盖楼通过构造方法来盖楼。
public Hotel(){
// 一共有几层，每层的房间类型是什么，每个房间的编号是什么。
// 我们可以先写死。一共三层、一层单人间、二层标准间、三层总统套房，每层有10个房间。
/**
* 房间编号
* 1楼：101 102 103 104 105 106..
* 2楼：201 202 203 204 205 206..
* 3楼：301 302 303 304 305 306..
* ...
*/
// 动态初始化
rooms = new Room[3][10]; // 3行10列。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循环负责输出一层。
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。
// 假设房间编号207（下标是 rooms[1][6] ）
// 通过房间编号演算出下标。获取房间对象。
Room room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
// 修改为占用。
room.setStatus(false);
System.out.println(roomNo + "已订房！");
}
/**
* 退房
* @param roomNo
*/
public void exit(int roomNo){
Room room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
// 修改为空闲。
room.setStatus(true);
System.out.println(roomNo + "已退房！");
}
}
/**
* 酒店的房间
*/
public class Room extends Object{
/**
* 房间编号
* 1楼：101 102 103 104 105 106..
* 2楼：201 202 203 204 205 206..
* 3楼：301 302 303 304 305 306..
* ...
*/
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 isStatus() {
return status;
}*/
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.getNo() == room.getNo();
}
// toString方法重写
// toString方法的目的就是将java对象转换成字符串形式。
// 怎么转，转换成什么格式，程序员自己定。目的就是：简单、清晰明了。
// 我不要看对象内存地址。我要看具体的信息。
public String toString() {
//return "[101,单人间,占用]";
//return "[102,单人间,空闲]"; // 写死了。
//动态（把一个变量塞到一个字符串当中，口诀：加一个双引号，双引号中间加两个加号，两个加号中间加变量名。）
return "["+no+","+type+","+(status ? "空闲" : "占用")+"]";
}
// 编写一个临时程序测试以下
// 一会可以删除这个main方法
/*
public static void main(String[] args) {
//Room room = new Room(101, "单人间", true);
Room room = new Room(101, "单人间", false);
//System.out.println(room.toString());
// room是一个引用
// println(引用)，会自动调用引用的toString()方法。
System.out.println(room);
Room room1 = new Room(102, "单人间", false);
System.out.println(room.equals(room1));
}
*/
// 多行注释：ctrl + shift + /
// 查看一个类的属性和方法：ctrl + F12
}
+++
Day 24
不管equals、tostring（）方法用的上用不上，创建了一个类，你都得重写，这是编程素养
写一个方法要写文档注释 这也是基本素养
+++
- 处理day23天的作业
这一个s 是引用 指向了堆内存中的 String类型的对象
// 注意："abc" 这是一个字符串对象，字符串在java中有优待，不需要new也是一个对象。
// "abc" 字符串也是java对象，属于String类型。
Object[] arr = {new Husband(), new Wife(), "abc"};
- 赋值方法：
- 可以不在构造方法里面赋值，可以直接赋值，但是还是在调用构造方法的时候执行，完成初始化，并不是在这一行。
数组常见的算法
以下的算法在以后的java实际开发中我们不需要使用的
因为java已经封装好了，直接调用就行
只不过以后面试的时候，可能会有机会碰上
Arrays 工具类
- 算法实际上在java中不需要精通，因为java中已经封装好了，要排序就调用方法就行。
- 例如：java中提供了一个数组工具类：java.util.Arrays
Arrays是一个工具类。
其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。 - sort（）方法的使用
可以对整数型数组排序
/*
调用了Arrays工具类的sort（int【】 方法）
*/
Arrays.sort(nm);
//遍历输出排序后的数组
for (int i = 0 ;i < nm.length;i++){
System.out.println(nm[i]) ;
- 工具类：
- 所有方法都是静态的，直接用类名 调用
- 主要使用的是两个方法：
二分法查找 排序
排序分类
排序分为：
内部排序：将需要处理的所有数据加载到内部存储器中进行排序。
外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
冒泡排序算法
- 基本概念
冒泡排序算法
- 每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡。）
- 核心：
拿着左边的数字和右边的数字比对，当左边 > 右边的时候，交换位置。 - 例题如下：
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;
int count2 = 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;
count2++;
}
}
}
//System.out.println("比较次数：" + count);
System.out.println("交换位置的次数：" + count2); //13
// 输出结果
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
选择排序算法
- 每一次从这堆“参与比较的数据当中”找出最小值，拿着这个最小值和“参与比较的这堆最前面的元素”交换位置。
- 选择排序比冒泡排序好在：每一次的交换位置都是有意义的。
- 选择排序比冒泡排序的效率高。
选择排序的原理：
- 假设整数数组，里面 min 下标的元素值最小
- 将 min 下标的元素和其它元素进行比较，找出最小的那个元素放到数组左边，即将最小的元素下标赋值给min，其余的在进行比较。
- 比较完成后，如果假设的最小值下标和实际比较出来的最小值下标相同，则假设成立。
- 否则，假设不成立，需要交换两个元素位置，将最小数据放到元素左边。
- 例题如下：
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};
int count = 0;
int count2 = 0;
// 选择排序
// 5条数据循环4次。（外层循环4次。）
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] 最前面的数据
int temp;
temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
count2++;
}
}
// 冒泡排序和选择排序实际上比较的次数没变。
// 交换位置的次数减少了。
System.out.println("比较次数" + count); // 21
System.out.println("交换次数：" + count2); // 5
// 排序之后遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
//1 2 3 4 5
//假设1是最小的，结果1确实是最小的，就不需要交换位置。
数组的元素查找 [ P421 -P422]
单词积累：param 参数
- 数组元素查找有两种方式：
第一种方式：一个一个挨着找，直到找到为止。
第二种方式：二分法查找（算法），这个效率较高。 - 第一种方式例子：
public class ArraySearch {
public static void main(String[] args) {
// 这个例子演示一下第一种方式
int[] arr = {4,5,5,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, 5);
System.out.println(index == -1 ? "该元素不存在" : "该元素下标是：" + index);
}
/**
* 从数组中检索某个元素的下标（返回的是第一个元素的下标。）
* @param arr 被检索的数组
* @param ele 被检索的元素
* @return 大于等于0的数表示元素的下标，-1表示该元素不存在
*/
public static int arraySearch(int[] arr, int ele) {
for (int i = 0; i < arr.length; i++) {
if(ele == arr[i]){
return i;
}
}
return -1;
}
}
二分法查找
只适合从小到大排序的数组，没有排序的数据是无法查找的。
- 原理
- 先判断数组是否排序
- 求出中间元素下标，判断中间下标的元素是和要查找的元素的大小，如果相等直接返回元素下标
- 如果中间元素比要找元素小，修改起始元素下标
- 如果中间元素比要找元素大，修改结束元素下标
- eg：
- 第二种方法例子二分法（折半查找法）：
