Java入门级教学（超详细&上）

已于 2024-05-13 17:50:41 修改
阅读量5.2k 收藏 344
点赞数 51
分类专栏： Java技术栈学习系列 文章标签： java
于 2023-02-01 14:20:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51634403/article/details/128833276
版权
探索Java语言的跨平台原理，涵盖基本语法如数据类型、运算符及内存管理，深入讲解StringBuilder与String互转技巧。通过实例分析Collection与List等集合类的使用，包括ArrayList、Map等，强调遍历与操作方法，解析集合框架特性与应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

项目和markdown文件资料：
https://github.com/cocochimp/Java-H5-Study-Resources

文章目录

1. Java基本语法

Java语言跨平台原理

Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。

  • JVM（Java Virtual Machine），Java虚拟机
  • JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）
  • JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。

Java中的内存分配

  • 目前我们只需要记住两个内存，分别是：栈内存和堆内存
区域名称作用
寄存器给CPU使用，和我们开发无关。
本地方法栈JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区存储可以运行的class文件。
堆内存存储对象或者数组，new来创建的，都存储在堆内存。
方法栈方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

1.1 Java中的数据类型

Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。

  • Java中的基本数据类型
数据类型关键字内存占用取值范围（2的次方）
整数类型byte17次
short215次
int（默认）431次
long863次
浮点类型float4128次
double（默认）81024次
字符类型char20 ~ 2的16次
布尔类型boolean1true，false
  • 类型转换

image-20230127234508672

注：boolean类型不能与其他基本数据类型相互转换。

1.2 字符(串)的“+”操作

char类型参与算术运算，使用的是计算机底层对应的十进制数值。

需要我们记住三个字符对应的数值：

  • ‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
  • ‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
  • ‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加
System.out.println(1+99+"cc"+1+1); //100cc11
System.out.println(1+99+"cc"+(1+1)); //100cc2

1.3 常见运算符

1、赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

2、自增自减运算符

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10
int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少？
/*
解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增...
所以整个式子应该是：int y = 10 + 11 + 12;
输出结果为33。
*/
注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！

3、三元运算符(案例)

  • 1、需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
public class OperatorTest01 {
	public static void main(String[] args) {
        //1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
        int weight1 = 180;
        int weight2 = 200;
        //2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
        boolean b = weight1 == weight2 ? true : false;
        //3：输出结果
        System.out.println("b:" + b);
    }
}
  • 2、需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。
public class OperatorTest02 {
    public static void main(String[] args) {
        //1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
        int height1 = 150;
        int height2 = 210;
        int height3 = 165;
        //2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int tempHeight = height1 > height2 ? height1 : height2;
        //3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int maxHeight = tempHeight > height3 ? tempHeight : height3;
        //4：输出结果
        System.out.println("maxHeight:" + maxHeight);
    }
}

1.4 Scanner数据输入

步骤：

  1. 导包
import java.util.Scanner
  1. 创建Scanner对象
Scanner sc=new Scanner(System.in);
  1. 接收数据
int i=sc.nextInt();
  • 示例：
import java.util.Scanner;
public class ScannerDemo {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        int x = sc.nextInt();
        //输出数据
        System.out.println("x:" + x);
    }
}
  • 三个和尚
import java.util.Scanner;
public class ScannerTest {
    public static void main(String[] args) {
        //身高未知，采用键盘录入实现。首先导包，然后创建对象。
        Scanner sc = new Scanner(System.in);
        //键盘录入三个身高分别赋值给三个变量。
        System.out.println("请输入第一个和尚的身高：");
        int height1 = sc.nextInt();
        System.out.println("请输入第二个和尚的身高：");
        int height2 = sc.nextInt();
        System.out.println("请输入第三个和尚的身高：");
        int height3 = sc.nextInt();
        //用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int tempHeight = height1 > height2 ? height1 : height2;
        //用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int maxHeight = tempHeight > height3 ? tempHeight : height3;
        //输出结果。
        System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");
    }
}

1.5 switch语句

  • switch语句练习-春夏秋冬（应用）

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。 运行结果：

春：3、4、5
夏：6、7、8
秋：9、10、11
冬：1、2、12
  • 示例代码：
public class Demo1 {
    public static void main(String[] args) {
    //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
        //case穿透
        switch(month) {
        case 1:
        case 2:
        case 12:
        	System.out.println("冬季");
        	break;
        case 3:
        case 4:
        case 5:
        	System.out.println("春季");
        	break;
        case 6:
        case 7:
        case 8:
        	System.out.println("夏季");
        	break;
        case 9:
        case 10:
        case 11:
        	System.out.println("秋季");
        	break;
        default:
        	System.out.println("你输入的月份有误");
        }
    }
}
  • 注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。

1.6 for循环语句

  • for循环练习-水仙花

解释：什么是水仙花数？

水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数

例如 153 333 + 555 + 111 = 153

  • 示例代码
public class ForTest04 {
    public static void main(String[] args) {
        //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
        for(int i=100; i<1000; i++) {
            //在计算之前获取三位数中每个位上的值
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;
            //判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
            if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                //输出满足条件的数字就是水仙花数
                System.out.println(i);
            }
        }
    }
}

1.7 while循环语句

  • while循环练习-珠穆朗玛峰

需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

  • 示例代码：
public class WhileTest {
    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;
        //定义纸张厚度
        double paper = 0.1;
        //定义珠穆朗玛峰的高度
        int zf = 8844430;
        //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
        while(paper <= zf) {
        	//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
            paper *= 2;
            //在循环中执行累加，对应折叠了多少次
            count++;
        }
        //打印计数器的值
        System.out.println("需要折叠：" + count + "次");
    }
}

1.8 Random随机数

步骤：

  1. 导包
import java.util.Random
  1. 创建Scanner对象
Random r = new Random();
  1. 接收数据
int i=r.nextInt(10);

注：10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0- 19

  • 示例：

需求： 程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？

当猜错的时候根据不同情况给出相应的提示

A. 如果猜的数字比真实数字大，提示你猜的数据大了

B. 如果猜的数字比真实数字小，提示你猜的数据小了

C. 如果猜的数字与真实数字相等，提示恭喜你猜中了

import java.util.Random;
import java.util.Scanner;
public class RandomTest {
    public static void main(String[] args) {
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        while(true) {
               //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入你要猜的数字：");
                int guessNumber = sc.nextInt();
                //比较输入的数字和系统产生的数据，需要使用分支语句。
                //这里使用if..else..if..格式，根据不同情况进行猜测结果显示
                if(guessNumber > number) {
                	System.out.println("你猜的数字" + guessNumber + "大了");
                } else if(guessNumber < number) {
                	System.out.println("你猜的数字" + guessNumber + "小了");
                } else {
                	System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}

1.9 数组

  • 数组定义
int arr[]; //int[] arr;
double arr[]; //double[] arr;
char arr[]; //char[] arr;
  • 动态数组初始化
int[] arr = new int[3];
  • 静态数组初始化
int[] arr = {1, 2, 3};
  • 示例：最大值获取：从数组的所有元素中找出最大值。
public class ArrayTest02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};
        //定义一个变量，用于保存最大值
        //取数组中第一个数据作为变量的初始值
        int max = arr[0];
        //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
            	max = arr[x];
            }
        }
        //循环结束后打印变量的值
        System.out.println("max:"+max);
    }
}

1.10 方法

  • 方法定义
public static void method (int[] arr) {
// 方法体;
}

//解释：
方法权限 static 返回值类型 方法名 (参数) {
// 方法体;
}
  • 方法重载

定义：在同一个类中多个相同名称的方法（只与参数有关）。

public class MethodDemo {
    public static float fn(int a) {
    	//方法体
    }
    public static int fn(int a , int b) {
    	//方法体
    }
}

错误示范：

public class MethodDemo {
    public static void fn(int a) {
    	//方法体
    }
    public static int fn(int a) { /*错误原因：重载与返回值无关*/
    	//方法体
    }
}
public class MethodDemo01 {
    public static void fn(int a) {
    	//方法体
    }
}
public class MethodDemo02 {
    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
    	//方法体
    }
}

image-20230128140823402

1.11 递归

  • 递归的介绍
    • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
    • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
    • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
public class DiGuiDemo {
    public static void main(String[] args) {
        //回顾不死神兔问题，求第20个月兔子的对数
        //每个月的兔子对数：1,1,2,3,5,8，...
        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }
    /*
    递归解决问题，首先就是要定义一个方法：
    定义一个方法f(n)：表示第n个月的兔子对数
    那么，第n-1个月的兔子对数该如何表示呢？f(n-1)
    同理，第n-2个月的兔子对数该如何表示呢？f(n-2)
    StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
    */
    public static int f(int n) {
        if(n==1 || n==2) {
            return 1;
        } else {
            return f(n - 1) + f(n - 2);
        }
    }
}
  • 递归的注意事项
    • 递归一定要有出口。否则内存溢出
    • 递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出

递归求阶乘

  • 案例需求

    用递归求5的阶乘，并把结果在控制台输出

public class DiGuiDemo01 {
    public static void main(String[] args) {
        //调用方法
        int result = jc(5);
        //输出结果
        System.out.println("5的阶乘是：" + result);
    }
    
    //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
    public static int jc(int n) {
        //在方法内部判断该变量的值是否是1
        if(n == 1) {
            //是：返回1
            return 1;
        } else {
            //不是：返回n*(n-1)!
            return n*jc(n-1);
        }
    }
}

2. 面向对象三大特性

解释：

面向对象的三大特性是：封装、继承、多态。

2.1 封装

概念

  1. 封装概述是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的 ；
  2. 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法 ；
  3. 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性；

标准类制作

需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。

示例代码：

class Student {
    //成员变量
    private String name;
    private int age;
    
    //构造方法
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    //成员方法
    public void setName(String name) {
    	this.name = name;
    }
    public String getName() {
    	return name;
    }
    public void setAge(int age) {
    	this.age = age;
    }
    public int getAge() {
    	return age;
    }
    public void show() {
    	System.out.println(name + "," + age);
    }
}
/*
    创建对象并为其成员变量赋值的两种方式
    1:无参构造方法创建对象后使用setXxx()赋值
    2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();
        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

2.2 继承

1、概念&特点

继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

  • 实现继承的格式

    • 继承通过extends实现
    • class Dog extends Animal { }

  • 继承的好处

    • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
    • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

  • 继承的坏处

    • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

  • 继承的应用场景

    • is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

2、继承中变量的访问特点

在子类方法中访问一个变量，采用的是就近原则。

  1. 子类局部范围找
  2. 子类成员范围找
  3. 父类成员范围找
  4. 如果都没有就报错(不考虑父亲的父亲…)

3、super关键字

  • this和super的使用分别

    • 成员变量：
      • this.成员变量 - 访问本类成员变量
      • super.成员变量 - 访问父类成员变量
    • 成员方法：
      • this.成员方法 - 访问本类成员方法
      • super.成员方法 - 访问父类成员方法
    • 构造方法：
      • this(…) - 访问本类构造方法
      • super(…) - 访问父类构造方法

  • super内存图

image-20230128232119239

4、方法重写

概念：子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了 父类的功能，又定义了子类特有的内容

Override注解：用来检测当前的方法，是否是重写的方法，起到【校验】的作用

5、继承案例

  • 需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试

  • 分析：

    ①猫：

    成员变量：姓名，年龄

    构造方法：无参，带参

    成员方法：get/set方法，抓老鼠()

    ②狗：

    成员变量：姓名，年龄

    构造方法：无参，带参

    成员方法：get/set方法，看门()

    ③共性：

    成员变量：姓名，年龄；

    构造方法：无参，带参；

    成员方法：get/set方法

  • 步骤：

    1、定义动物类(Animal)

    【成员变量：姓名，年龄】【 构造方法：无参，带参】【成员方法：get/set方法】

    2、定义猫类(Cat)，继承动物类

    【构造方法：无参，带参】【成员方法：抓老鼠() 】

    3、定义狗类(Dog)，继承动物类

    【构造方法：无参，带参】【成员方法：看门() 】

    4、定义测试类(AnimalDemo)，写代码测试

class Animal {
    private String name;
        private int age;
        public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
            this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class Cat extends Animal {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}
class Dog extends Animal {
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    public void lookDoor() {
        System.out.println("狗看门");
    }

    /*
    测试类
    */
    public class AnimalDemo {
        public static void main(String[] args) {
            //创建猫类对象并进行测试
            Cat c1 = new Cat();
                c1.setName("加菲猫");
                c1.setAge(5);
                System.out.println(c1.getName() + "," + c1.getAge());
                c1.catchMouse();
                Cat c2 = new Cat("加菲猫", 5);
                System.out.println(c2.getName() + "," + c2.getAge());
                c2.catchMouse();
        }
    }

2.3 多态

概念：同一个对象，在不同时刻表现出来的不同形态

  • 多态的前提

    • 要有继承或实现关系
    • 要有方法的重写
    • 要有父类引用指向子类对象

  • 多态中的成员访问特点

    • 成员变量

      编译看父类，运行看父类

    • 成员方法

      编译看父类，运行看子类

代码演示

  • 动物类
public class Animal {
    public int age = 40;
        public void eat() {
        System.out.println("动物吃东西");
    }
}
  • 猫类
public class Cat extends Animal {
    public int age = 20;
        public int weight = 10;
        @Override
        public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
  • 测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
            System.out.println(a.age);
            // System.out.println(a.weight);
            a.eat();
            // a.playGame();
    }
}

多态的好处与弊端

  • 好处

    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

  • 弊端

    不能使用子类的特有成员

    （基于弊端，因此我们不需要在子类中定义成员方法）

//向上转型
Animal a = new Cat();
a.eat();
// a.playGame();//子类的特定方法

//向下转型
Cat c = (Cat)a;
c.eat();
c.playGame();

3. 常见API

概念

  • 什么是API？

API (Application Programming Interface) ：应用程序编程接口

  • java中的API

指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

3.1 String类

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序 中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

  • 常用构造方法（理解）
方法名说明
public String()创建一个空白字符串对象，不含有任何内容
public String(char[] chs)根据字符数组的内容，来创建字符串对象
public String(byte[] bys)根据字节数组的内容，来创建字符串对象
String s = “abc”;直接赋值的方式创建字符串对象，内容就是abc
  • 常用方法
方法名说明
public boolean equals(Object anObject)比较字符串的内容，严格区分大小写(用户名和密码)
public char charAt(int index)返回指定索引处的 char 值
public int length()返回此字符串的长度

字符串的比较

  • ==号的作用

比较基本数据类型：比较的是具体的值

比较引用数据类型：比较的是对象地址值

String案例

  1. 用户登录案例

已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示。

/*
    思路：
    1:已知用户名和密码，定义两个字符串表示即可
    2:键盘录入要登录的用户名和密码，用 Scanner 实现
    3:拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用
    equals() 方法实现
    4:用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
*/
public class StringTest01 {
    public static void main(String[] args) {
        //已知用户名和密码，定义两个字符串表示即可
        String username = "itheima";
        String password = "czbk";
        //用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
        for(int i=0; i<3; i++) {
            //键盘录入要登录的用户名和密码，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String name = sc.nextLine();
            System.out.println("请输入密码：");
            String pwd = sc.nextLine();
            //拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals() 方法实现
            if (name.equals(username) && pwd.equals(password)) {
            	System.out.println("登录成功");
            break;
        } else {
            if(2-i == 0) {
            	System.out.println("你的账户被锁定，请与管理员联系");
            } else {
                //2,1,0
                //i,0,1,2
                System.out.println("登录失败，你还有" + (2 - i) + "次机会");
            	}
            }
        }
    }
}
  1. 遍历字符串案例

键盘录入一个字符串，使用程序实现在控制台遍历该字符串

/*
    思路：
    1:键盘录入一个字符串，用 Scanner 实现
    2:遍历字符串，首先要能够获取到字符串中的每一个字符
    public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
    3:遍历字符串，其次要能够获取到字符串的长度
    public int length()：返回此字符串的长度
    数组的长度：数组名.length
    字符串的长度：字符串对象.length()
    4:遍历字符串的通用格式
*/
public class StringTest02 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        for(int i=0; i<line.length(); i++) {
        	System.out.println(line.charAt(i));
        }
    }
}
  1. 统计字符次数案例

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

/*
    思路：
    1:键盘录入一个字符串，用 Scanner 实现
    2:要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
    3:遍历字符串，得到每一个字符
    4:判断该字符属于哪种类型，然后对应类型的统计变量+1
    假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范
    围即可
    大写字母：ch>='A' && ch<='Z'
    小写字母： ch>='a' && ch<='z'
    数字： ch>='0' && ch<='9'
    5:输出三种类型的字符个数
*/
public class StringTest03 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        //遍历字符串，得到每一个字符
        for(int i=0; i<line.length(); i++) {
            char ch = line.charAt(i);
            //判断该字符属于哪种类型，然后对应类型的统计变量+1
            if(ch>='A' && ch<='Z') {
            	bigCount++;
            } else if(ch>='a' && ch<='z') {
            	smallCount++;
            } else if(ch>='0' && ch<='9') {
            	numberCount++;
            }
        }
        //输出三种类型的字符个数
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字：" + numberCount + "个");
    }
}
  1. 字符串拼接案例

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法， 并在控制台输出结果。

例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

/*
    思路：
    1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
    2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
    返回值类型 String，参数列表 int[] arr
    3:在方法中遍历数组，按照要求进行拼接
    4:调用方法，用一个变量接收结果
    5:输出结果
*/
public class StringTest04 {
    public static void main(String[] args) {
        //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};
        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        //输出结果
        System.out.println("s:" + s);
    }
    //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
    两个明确：
    返回值类型：String
    参数：int[] arr
    */
    public static String arrayToString(int[] arr) {
        //在方法中遍历数组，按照要求进行拼接
        String s = "";
        s += "[";
        for(int i=0; i<arr.length; i++) {
            if(i==arr.length-1) {
            	s += arr[i];
            } else {
            	s += arr[i];
            	s += ", ";
            }
        }
        s += "]";
        return s;
    }
}

5.字符串反转案例

定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果 例如，键盘录入 abc，输出结果 cba

/*
    思路：
    1:键盘录入一个字符串，用 Scanner 实现
    2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    3:在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
    4:调用方法，用一个变量接收结果
    5:输出结果
*/
public class StringTest05 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //调用方法，用一个变量接收结果
        String s = reverse(line);
        //输出结果
        System.out.println("s:" + s);
     }
    //定义一个方法，实现字符串反转
    /*
        两个明确：
        返回值类型：String
        参数：String s
    */
    public static String reverse(String s) {
        //在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        String ss = "";
        for(int i=s.length()-1; i>=0; i--) {
            ss += s.charAt(i);
        }
        return ss;
    }
}

3.2 StringBuilder类

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的 内容是可变的

  • StringBuilder类和String类的区别

    • String类：内容是不可变的
    • StringBuilder类：内容是可变的

  • 常用的构造方法

方法名说明
public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
  • 常用的方法
方法名说明
public StringBuilder append (任意类型)添加数据，并返回对象本身
public StringBuilder reverse()返回相反的字符序列
public int length()返回长度，实际存储值
public String toString()通过toString()就可以实现把StringBuilder转换为String

StringBuilder和String相互转换

  • StringBuilder转换为String

public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String

StringBuilder sb = new StringBuilder();
String s = sb.toString();
  • String转换为StringBuilder

public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder

String s = "hello";
StringBuilder sb = new StringBuilder(s);

StringBuilder案例

  1. 字符串拼接升级版案例

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法， 并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

/*
    思路：
    1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
    2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
    返回值类型 String，参数列表 int[] arr
    3:在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
    4:调用方法，用一个变量接收结果
    5:输出结果
*/
public class StringBuilderTest01 {
    public static void main(String[] args) {
        //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};
        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        //输出结果
        System.out.println("s:" + s);
    }
    
    //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
        两个明确：
        返回值类型：String
        参数：int[] arr
	*/
    public static String arrayToString(int[] arr) {
        //在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i=0; i<arr.length; i++) {
            if(i == arr.length-1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}
  1. 字符串反转升级版案例

定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果 例如，键盘录入abc，输出结果 cba

/*
    思路：
    1:键盘录入一个字符串，用 Scanner 实现
    2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    3:在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
    4:调用方法，用一个变量接收结果
    5:输出结果
*/
public class StringBuilderTest02 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //调用方法，用一个变量接收结果
        String s = myReverse(line);
        //输出结果
        System.out.println("s:" + s);
    }
    //定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    /*
        两个明确：
        返回值类型：String
        参数：String s
    */
    public static String myReverse(String s) {
        //在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
        //String --- StringBuilder --- reverse() --- String
        // StringBuilder sb = new StringBuilder(s);
        // sb.reverse();
        // String ss = sb.toString();
        // return ss;
        return new StringBuilder(s).reverse().toString();
    }
}

3.3 Math类

概述：Math 包含执行基本数字运算的方法

  • Math中方法的调用方式

    • Math类中无构造方法，但内部的方法都是静态的，则可以通过类名进行调用。

  • Math类常用方法

方法名说明
public static int abs(int a)返回参数的绝对值
public static double ceil(double a)返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)按照四舍五入返回最接近参数的int
public static int max(int a,int b)返回两个int值中的较大值
public static int min(int a,int b)返回两个int值中的较小值
public static double pow (double a,double b)返回a的b次幂的值
public static double random()返回值为double的正值，[0.0,1.0)

3.4 System类

  • System类的常用方法
方法名说明
public static void exit(int status)终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()返回当前时间(以毫秒为单位)
  • 示例代码

需求：在控制台输出1-10000，计算这段代码执行了多少毫秒

public class SystemDemo {
    public static void main(String[] args) {
        // 获取开始的时间节点
        long start = System.currentTimeMillis();
            for (int i = 1; i <= 10000; i++) {
                System.out.println(i);
            }
        // 获取代码运行结束后的时间节点
        long end = System.currentTimeMillis();
            System.out.println("共耗时：" + (end ­ start) + "毫秒");
    }
}

3.5 Object类

  • Object类概述
    • Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类， 换句话说，该类所具备的方法，所有类都会有一份。
  • 查看方法源码的方式
    • 选中方法，按下Ctrl + B
  • 重写toString方法的方式
    • Alt + Insert 选择toString
    • 在类的空白区域，右键 -> Generate -> 选择toString
  • toString方法的作用：
    • 以良好的格式，更方便的展示对象中的属性值
@Override
public String toString() {
    return "Student{" +
        "name='" + name + '\'' +
        ", age=" + age +
        '}';
}

//运行结果
Student{name='xxx', age=xx}
Student{name='xxx', age=xx}
  • equals方法的作用
    • 用于对象之间的比较，返回true和false的结果
    • 举例：s1.equals(s2); s1和s2是两个对象
  • 重写equals方法的场景
    • 不希望比较对象的地址值，想要结合对象属性进行比较的时候。
  • 重写equals方法的方式
    • alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
    • 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。
@Override
public boolean equals(Object o) {
    //this -- s1
    //o -- s2
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o; //student -- s2
    if (age != student.age) return false;
    return name != null ? name.equals(student.name) : student.name == null;
}

//需求：比较两个对象的内容是否相同
System.out.println(s1.equals(s2));

3.6 Arrays类

  • Arrays的常用方法
方法名说明
public static String toString(int[] a)返回指定数组的内容的字符串表达形式
public static void sort(int[] a)按照数字顺序排列指定的数组
  • 工具类设计思想
    • 构造方法用private修饰
    • 成员用public static修饰

3.7 包装类

1、基本类型包装类

  • 作用

    将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

    常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

2、Integer类

Integer类概述 包装一个对象中的原始类型 int 的值

方法名说明
public static Integer valueOf(int i)返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)返回一个保存指定值的 Integer 对象 String
//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);
//public static Integer valueOf(String s)：返回一个保存指定值的Integer对象String
Integer i4 = Integer.valueOf("100");
System.out.println(i4);

int和String类型的相互转换

  • int转换成String
    • 方法一：直接在数字后加一个空字符串
    • 方法二：通过String类静态方法valueOf()
public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");
    }
}
  • String转换成int
    • 方法一：先将字符串数字转成Integer，再调用valueOf()方法
    • 方式二：通过Integer静态方法**parseInt()**进行转换
public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

3、字符串排序案例

  • 案例需求

    有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：“27 38 46 50 91”

public class IntegerTest {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";
        //把字符串中的数字数据存储到一个int类型的数组中
        String[] strArray = s.split(" ");
        // for(int i=0; i<strArray.length; i++) {
        // System.out.println(strArray[i]);
        // }
        //定义一个int数组，把 String[] 数组中的每一个元素存储到 int 数组中
        int[] arr = new int[strArray.length];
        for(int i=0; i<arr.length; i++) {
            arr[i] = Integer.parseInt(strArray[i]);
        }
        //对 int 数组进行排序
        Arrays.sort(arr);
        
        //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
        StringBuilder sb = new StringBuilder();
        for(int i=0; i<arr.length; i++) {
            if(i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();
        //输出结果
        System.out.println(result);
    }
}

4、自动拆箱和自动装箱

  • 自动装箱

    把基本数据类型转换为对应的包装类类型

  • 自动拆箱

    把包装类类型转换为对应的基本数据类型

Integer i = 100; // 自动装箱
i += 200; // i = i + 200; i + 200 自动拆箱；i = i + 200; 是自动装箱

3.8 Date类

1、Date类

  • Date类概述

    Date 代表了一个特定的时间，精确到毫秒

  • Date类构造方法

方法名说明
public Date()分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

基准时间：Thu Jan 01 08:00:00 CST 1970

//public Date()：分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
Date d1 = new Date();
System.out.println(d1);//Sun Jan 29 16:23:30 CST 2023

//public Date(long date)：分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
long date = 1000*60*60;
Date d2 = new Date(date);
System.out.println(d2);//Thu Jan 01 09:00:00 CST 1970
  • 常用方法
方法名说明
public long getTime()获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)设置时间，给的是毫秒值
public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();
        //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
        // System.out.println(d.getTime());
        // System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 +
        "年");
        //public void setTime(long time):设置时间，给的是毫秒值
        // long time = 1000*60*60;
        long time = System.currentTimeMillis();
        d.setTime(time);
        System.out.println(d);
    }
}

2、SimpleDateFormat类

概述：SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。

我们重点学习日期格式化和解析

方法名说明
public final String format(Date date)将日期格式化成日期/时间字符串**（Date—>String）**
public Date parse(String source)从给定字符串的开始解析文本以生成日期**（String—>Date）**
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //格式化：从 Date 到 String
        Date d = new Date();
        // SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);//2023年01月29日 16:36:27
        System.out.println("--------");
        
        //从 String 到 Date
        String ss = "2048-08-09 11:11:11";
        //ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);//Sun Aug 09 11:11:11 CST 2048
    }
}

3、日期工具类案例

定义一个日期工具类(DateUtils)，包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式 的日期，然后定义一个测试类(DateDemo)，测试日期工具类的方法

  • 工具类
public class DateUtils {
    private DateUtils() {}
    /*
    把日期转为指定格式的字符串
    返回值类型：String
    参数：Date date, String format
    */
    public static String dateToString(Date date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }
    /*
    把字符串解析为指定格式的日期
    返回值类型：Date
    参数：String s, String format
    */
    public static Date stringToDate(String s, String format) throws
        ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;
    }
}
  • 测试类
public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();
        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);
        String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
        System.out.println(s2);
        String s3 = DateUtils.dateToString(d, "HH:mm:ss");
        System.out.println(s3);
        System.out.println("--------");
        String s = "2048-08-09 12:12:12";
        Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}

3.9 Calender类

概述：Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法 。

Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。

该方法返回一个Calendar 对象。

其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();

方法名说明
public int get(int field)返回给定日历字段的值
public abstract void add(int field, int amount)根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date)设置当前日历的年月日
public class CalendarDemo {
    public static void main(String[] args) {
        //获取日历类对象
        Calendar c = Calendar.getInstance();
        //public int get(int field):返回给定日历字段的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
        //public abstract void add(int field, int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
            //需求1:3年前的今天
            // c.add(Calendar.YEAR,-3);
            // year = c.get(Calendar.YEAR);
            // month = c.get(Calendar.MONTH) + 1;
            // date = c.get(Calendar.DATE);
            // System.out.println(year + "年" + month + "月" + date + "日");
            //需求2:10年后的10天前
            // c.add(Calendar.YEAR,10);
            // c.add(Calendar.DATE,-10);
            // year = c.get(Calendar.YEAR);
            // month = c.get(Calendar.MONTH) + 1;
            // date = c.get(Calendar.DATE);
            // System.out.println(year + "年" + month + "月" + date + "日");
            //public final void set(int year,int month,int date):设置当前日历的年月日
            c.set(2050,10,10);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}

二月天案例

获取任意一年的二月有多少天

public class CalendarTest {
    public static void main(String[] args) {
        //键盘录入任意的年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年：");
        int year = sc.nextInt();
        //设置日历对象的年、月、日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);
        //3月1日往前推一天，就是2月的最后一天
        c.add(Calendar.DATE, -1);
        //获取这一天输出即可
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的2月份有" + date + "天");
    }
}

4. Java特性

4.1 对象内存图

  • 成员变量使用过程

image-20230128145801533

  • 成员方法调用过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LOkxYucX-1675231935171)(https://cocochimp-markdown-img.oss-cn-beijing.aliyuncs.com/save/image-20230128145826634.png)]

注：多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份。

4.2 权限修饰符

image-20230128232744698

4.3 final修饰符

作用：final代表最终的意思，可以修饰成员方法，成员变量，类

  • 效果

    • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
    • final修饰方法：该方法不能被重写
    • final修饰变量：表明该变量是一个常量，不能再次赋值

  • fianl修饰基本数据类型变量

    • final 修饰指的是基本类型的数据值不能发生改变

  • final修饰引用数据类型变量

    • final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

4.4 static关键字

  • static的概念
    • static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
  • static修饰的特点
    1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
    2. 可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】
class Student {
    public String name; //姓名
    public int age; //年龄
    public static String university; //学校 共享数据！所以设计为静态！
    public void show() {
        System.out.println(name + "," + age + "," + university);
    }
}
public class StaticDemo {
    public static void main(String[] args) {
        // 为对象的共享数据赋值
        Student.university = "传智大学";
            Student s1 = new Student();
            s1.name = "林青霞";
            s1.age = 30;
            s1.show();
            Student s2 = new Student();
            s2.name = "风清扬";
            s2.age = 33;
            s2.show();
    }
}
  • static的访问特点
    • 非静态的成员方法
      • 能访问静态的成员变量
      • 能访问非静态的成员变量
      • 能访问静态的成员方法
      • 能访问非静态的成员方法
    • 静态的成员方法
      • 能访问静态的成员变量
      • 能访问静态的成员方法

总结成一句话就是：静态成员方法只能访问静态成员（非静态可以为所欲为）

4.5 抽象类

当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！ 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

//抽象类的定义
public abstract class 类名 {}
//抽象方法的定义
public abstract void eat();

  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

  • 抽象类不能实例化

    抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

  • 抽象类的子类

    要么重写抽象类中的所有抽象方法

    要么是抽象类

案例

请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试

  • 动物类
public abstract class Animal {
    private String name;
        private int age;
        public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
            this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}
  • 猫类
public class Cat extends Animal {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
  • 狗类
public class Dog extends Animal {
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
  • 测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，按照多态的方式
        Animal a = new Cat();
            a.setName("加菲");
            a.setAge(5);
            System.out.println(a.getName()+","+a.getAge());
            a.eat();
            System.out.println("­­­­­­­­");
            a = new Cat("加菲",5);
            System.out.println(a.getName()+","+a.getAge());
            a.eat();
    }
}

4.6 接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

Java中的接口更多的体现在对行为的抽象！

//接口用关键字interface修饰
public interface 接口名 {}

//类实现接口用implements表示
public class 类名 implements 接口名 {}

  • 接口不能实例化

    接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。

    多态的形式：具体类多态，抽象类多态，接口多态。

  • 接口的子类

    要么重写接口中的所有抽象方法

    要么子类也是抽象类

接口的成员特点

  • 成员特点

    • 成员变量

      只能是常量

      默认修饰符：public static final

    • 构造方法

      没有，因为接口主要是扩展功能的，而没有具体存在

    • 成员方法

      只能是抽象方法

      默认修饰符：public abstract

      关于接口中的方法，JDK8和JDK9中有一些新特性（暂不讲解）

案例

  • 案例需求

    对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能。

    请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。

  • 动物类

public abstract class Animal {
    private String name;
        private int age;
        public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
            this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}
  • 跳高接口
public interface Jumpping {
    public abstract void jump();
}
  • 猫类
public class Cat extends Animal implements Jumpping {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
  • 测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Jumpping j = new Cat();
            j.jump();
            System.out.println("­­­­­­­­");

            Animal a = new Cat();
            a.setName("加菲");
            a.setAge(5);
            System.out.println(a.getName()+","+a.getAge());
            a.eat();
            // a.jump();

            a = new Cat("加菲",5);
            System.out.println(a.getName()+","+a.getAge());
            a.eat();
            System.out.println("­­­­­­­­");

            Cat c = new Cat();
            c.setName("加菲");
            c.setAge(5);
            System.out.println(c.getName()+","+c.getAge());
            c.eat();
            c.jump();
    }
}

类和接口的关系

  • 类与类的关系

    继承关系，只能单继承，但是可以多层继承

  • 类与接口的关系

    实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

  • 接口与接口的关系

    继承关系，可以单继承，也可以多继承

抽象类和接口的区别

  • 成员区别

    • 抽象类

      变量,常量；有构造方法；

      有抽象方法,也有非抽象方法

    • 接口

      常量；抽象方法

  • 设计理念区别

    • 抽象类

      对类抽象，包括属性、行为

    • 接口

      对象为抽象，主要是行为

4.7 泛型

  • 泛型概述

    是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型 它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方 法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具 体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称 为泛型类、泛型方法、泛型接口

  • 泛型定义格式

    • <类型>：指定一种类型的格式。这里的类型可以看成是形参
    • <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
    • 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

  • 泛型的好处

    • 把运行时期的问题提前到了编译期间
    • 避免了强制类型转换

1、泛型类

  • 定义格式
修饰符 class 类名<类型> { }
  • 泛型类
public class Generic<T> {
    private T t;
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}
  • 测试类
public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<String>();
        g1.setT("林青霞");
        System.out.println(g1.getT());
        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(30);
        System.out.println(g2.getT());
        Generic<Boolean> g3 = new Generic<Boolean>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}

2、泛型方法

  • 定义格式
修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
  • 带有泛型方法的类
public class Generic {
    public <T> void show(T t) {
        System.out.println(t);
    }
}
  • 测试类
public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("林青霞");
        g.show(30);
        g.show(true);
        g.show(12.34);
    }
}

3、泛型接口

  • 定义格式
修饰符 interface 接口名<类型> { }
  • 泛型接口
public interface Generic<T> {
void show(T t);
}
  • 泛型接口实现类
public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
  • 测试类
public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl<String>();
        g1.show("林青霞");
        Generic<Integer> g2 = new GenericImpl<Integer>();
        g2.show(30);
    }
}

4、类型通配符

  • 类型通配符的作用

    为了表示各种泛型List的父类，可以使用类型通配符

  • 类型通配符的分类

    • 类型通配符：<?>
      • List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
      • 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
    • 类型通配符上限： <? extends 类型>
      • List<? extends Number>：它表示的类型是Number或者其子类型
    • 类型通配符下限： <? super 类型>
      • List<? super Number> ：它表示的类型是Number或者其父类型

  • 类型通配符的基本使用

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符：<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("--------");
        
        //类型通配符上限：<? extends 类型>
        // List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("--------");
        
        //类型通配符下限：<? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        // List<? super Number> list9 = new ArrayList<Integer>();
    }
}

4.8 可变参数

  • 可变参数介绍

    可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

  • 可变参数定义格式

修饰符 返回值类型 方法名(数据类型… 变量名) { }

  • 可变参数的注意事项

    • 这里的变量其实是一个数组
    • 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

  • 可变参数的基本使用

public class ArgsDemo01 {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30, 40));
        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));
        System.out.println(sum(10,20,30,40,50,60,70,80,90,100));
    }
    
    // public static int sum(int b,int... a) {
    // return 0;
    // }
    public static int sum(int... a) {
        int sum = 0;
        for(int i : a) {
            sum += i;
        }
        return sum;
    }
}

可变参数的使用

  • Arrays工具类中有一个静态方法：
    • public static List asList(T… a)：返回由指定数组支持的固定大小的列表
    • 返回的集合不能做增删操作，可以做修改操作
  • List接口中有一个静态方法：
    • public static List of(E… elements)：返回包含任意数量元素的不可变列表
    • 返回的集合不能做增删改操作
  • Set接口中有一个静态方法：
    • public static Set of(E… elements) ：返回一个包含任意数量元素的不可变集合
    • 在给元素的时候，不能给重复的元素
    • 返回的集合不能做增删操作，没有修改的方法
public class ArgsDemo02 {
    public static void main(String[] args) {
        public static <T> List<T> asList(T... a)：//返回由指定数组支持的固定大小的列表
        List<String> list = Arrays.asList("hello", "world", "java");
        list.add("javaee"); //UnsupportedOperationException
        list.remove("world"); //UnsupportedOperationException
        list.set(1,"javaee");
        System.out.println(list);
        
        public static <E> List<E> of(E... elements)：//返回包含任意数量元素的不可变列表
        List<String> list = List.of("hello", "world", "java", "world");
        list.add("javaee");//UnsupportedOperationException
        list.remove("java");//UnsupportedOperationException
        list.set(1,"javaee");//UnsupportedOperationException
        System.out.println(list);

        public static <E> Set<E> of(E... elements) ：//返回一个包含任意数量元素的不可变集合
        Set<String> set = Set.of("hello", "world", "java","world");
        IllegalArgumentException
        Set<String> set = Set.of("hello", "world", "java");
        set.add("javaee");//UnsupportedOperationException
        set.remove("world");//UnsupportedOperationException
        System.out.println(set);
    }
}

5. 异常

1、概念

异常就是程序出现了不正常的情况

image-20230129164715505

2、JVM默认处理异常的方式

如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：

  • 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
  • 程序停止执行

5.1 try-catch方式处理异常

  • 程序从 try 里面的代码开始执行
  • 出现异常，就会跳转到对应的 catch 里面去执行
  • 执行完毕之后，程序还可以继续往下执行
try {
    可能出现异常的代码;
} catch(异常类名 变量名) {
    异常的处理代码;
}
  • 示例代码
public class ExceptionDemo01 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
            System.out.println("这里能够访问到吗");
        } catch (ArrayIndexOutOfBoundsException e) {
            // System.out.println("你访问的数组索引不存在，请回去修改为正确的索引");
            e.printStackTrace();
        }
    }
}

5.2 Throwable成员方法

  • 常用方法
方法名说明
public String getMessage()返回此 throwable 的详细消息字符串
public String toString()返回此可抛出的简短描述
public void printStackTrace()把异常的错误信息输出在控制台
public class ExceptionDemo02 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); //new ArrayIndexOutOfBoundsException();
            System.out.println("这里能够访问到吗");
        } catch (ArrayIndexOutOfBoundsException e) { //new
            ArrayIndexOutOfBoundsException();
            // e.printStackTrace();
            //public String getMessage():返回此 throwable 的详细消息字符串
            // System.out.println(e.getMessage());
            //Index 3 out of bounds for length 3
            //public String toString():返回此可抛出的简短描述
            // System.out.println(e.toString());
            //java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
                //public void printStackTrace():把异常的错误信息输出在控制台
                e.printStackTrace();
            // java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
                // at com.itheima_02.ExceptionDemo02.method(ExceptionDemo02.java:18)
                // at com.itheima_02.ExceptionDemo02.main(ExceptionDemo02.java:11)
        }
    }
}

编译时异常和运行时异常的区别

  • 编译时异常
    • 都是Exception类及其子类
    • 必须显示处理，否则程序就会发生错误，无法通过编译
  • 运行时异常
    • 都是RuntimeException类及其子类
    • 无需显示处理，也可以和编译时异常一样处理

5.3 throws方式处理异常

  • 定义格式
public void 方法() throws 异常类名 {
}
  • 示例代码
public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        // method();
        try {
            method2();
        }catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("结束");
    }
    //编译时异常
    public static void method2() throws ParseException {
        String s = "2048-08-09";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d = sdf.parse(s);
        System.out.println(d);
    }
    //运行时异常
    public static void method() throws ArrayIndexOutOfBoundsException {
        int[] arr = {1, 2, 3};
        System.out.println(arr[3]);
    }
}
  • 注意
    • 这个throws格式是跟在方法的括号后面的
    • 编译时异常必须要进行处理，两种处理方案：try…catch …或者 throws，如果采用 throws 这种方案， 将来谁调用谁处理
    • 运行时异常可以不处理，出现问题后，需要我们回来修改代码

throws和throw的区别

image-20230129165721691

5.4 自定义异常

  • 自定义异常类
public class ScoreException extends Exception {
    public ScoreException() {}
    public ScoreException(String message) {
        super(message);
    }
}
  • 老师类
public class Teacher {
    public void checkScore(int score) throws ScoreException {
        if(score<0 || score>100) {
            // throw new ScoreException();
            throw new ScoreException("你给的分数有误，分数应该在0-100之间");
        } else {
            System.out.println("成绩正常");
        }
    }
}
  • 测试类
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入分数：");
        int score = sc.nextInt();
        Teacher t = new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}

6. 集合

集合体系结构

  • 集合类的特点

    提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

  • 集合类的体系图

image-20230129190528576

6.1 Collection集合

概述

  • Collection集合概述

    • 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
    • JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

  • Collection集合基本使用

public class CollectionDemo01 {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();
        //添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");
        //输出集合对象
        System.out.println(c);
    }
}
  • Collection集合的常用方法
方法名说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数

1、Collection集合的遍历

  • 迭代器的介绍

    • 迭代器，集合的专用遍历方式
    • Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
    • 迭代器是通过**集合的iterator()**方法得到的，所以我们说它是依赖于集合而存在的

  • Collection集合的遍历

public class IteratorDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");
        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();
        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

2、集合的案例-Collection集合存储学生对象并遍历

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

  • 学生类
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
  • 测试类
public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Student> c = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        //把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        //遍历集合(迭代器方式)
        Iterator<Student> it = c.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

6.2 List集合

  • List集合概述

    • 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
    • 与Set集合不同，列表通常允许重复的元素

  • List集合特点

    • 有索引
    • 可以存储重复元素
    • 元素存取有序

  • List集合的特有方法

方法名描述
void add(int index,E element)在此集合中的指定位置插入指定的元素
E remove(int index)删除指定索引处的元素，返回被删除的元素
E set(int index,E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索引处的元素

1、集合的案例-List集合存储学生对象并遍历

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

  • 学生类
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
  • 测试类
public class ListDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        
        //迭代器方式
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");
        
        //for循环方式
        for(int i=0; i<list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

2、并发修改异常

  • 出现的原因

    迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException

  • 解决的方案

    用for循环遍历，然后用集合对象做对应的操作即可

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现
            // Iterator<String> it = list.iterator();
            // while (it.hasNext()) {
            // String s = it.next();
            // if(s.equals("world")) {
            // list.add("javaee");
            // }
            // }
            for(int i=0; i<list.size(); i++) {
                String s = list.get(i);
                if(s.equals("world")) {
                    list.add("javaee");
                }
            }
        //输出集合对象
        System.out.println(list);
    }
}

3、列表迭代器

  • ListIterator介绍
    • 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
    • 用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
public class ListIteratorDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if(s.equals("world")) {
                lit.add("javaee");
            }
        }
        System.out.println(list);
    }
}

4、增强for循环

//定义格式
for(元素数据类型 变量名 : 数组/集合对象名) {
    循环体;
}
  • 示例代码
public class ForDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i : arr) {
            System.out.println(i);
        }
        System.out.println("--------");
        
        String[] strArray = {"hello","world","java"};
        for(String s : strArray) {
            System.out.println(s);
        }
        System.out.println("--------");
        
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        for(String s : list) {
            System.out.println(s);
        }
        System.out.println("--------");
        //内部原理是一个Iterator迭代器
        /*
        for(String s : list) {
            if(s.equals("world")) {
            	list.add("javaee"); //ConcurrentModificationException
            }
        }
        */
    }
}

5、集合的案例-List集合存储学生对象三种方式遍历

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

  • 学生类
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
  • 测试类
public class ListDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        
        //迭代器：集合特有的遍历方式
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");
        
        //普通for：带有索引的遍历方式
        for(int i=0; i<list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");
        
        //增强for：最方便的遍历方式
        for(Student s : list) {
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

6.3 ArrayList集合

  • ArrayList集合

    底层是数组结构实现，查询快、增删慢

  • 泛型的使用

    用于约束集合中存储元素的数据类型

  • 构造方法

方法名说明
public ArrayList()创建一个空的集合对象
  • 成员方法
方法名说明
public boolean remove(Object o)删除指定的元素，返回删除是否成功
public E remove(int index)删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)修改指定索引处的元素，返回被修改的元素
public E get(int index)返回指定索引处的元素
public int size()返回集合中的元素的个数
public boolean add(E e)将指定的元素追加到此集合的末尾
public void add(int index,E element)在此集合中的指定位置插入指定的元素

1、存储字符串并遍历

创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合

/*
    思路：
    1:创建集合对象
    2:往集合中添加字符串对象
    3:遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(int index)方法实现
    4:遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
    5:遍历集合的通用格式
*/
public class ArrayListTest01 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();
        //往集合中添加字符串对象
        array.add("刘正风");
        array.add("左冷禅");
        array.add("风清扬");
        //遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
        // System.out.println(array.size());
        //遍历集合的通用格式
        for(int i=0; i<array.size(); i++) {
            String s = array.get(i);
            System.out.println(s);
        }
    }
}

2、存储学生对象并遍历

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

/*
    思路：
    1:定义学生类
    2:创建集合对象
    3:创建学生对象
    4:添加学生对象到集合中
    5:遍历集合，采用通用遍历格式实现
*/
public class ArrayListTest02 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("风清扬", 33);
        Student s3 = new Student("张曼玉", 18);
        //添加学生对象到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);
        //遍历集合，采用通用遍历格式实现
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

3、存储学生对象并遍历升级版

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合，学生的姓名和年龄来自于键盘录入

/*
    思路：
    1:定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
    2:创建集合对象
    3:键盘录入学生对象所需要的数据
    4:创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
    5:往集合中添加学生对象
    6:遍历集合，采用通用遍历格式实现
*/
public class ArrayListTest {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<Student>();
        //为了提高代码的复用性，我们用方法来改进程序
        addStudent(array);
        addStudent(array);
        addStudent(array);
        //遍历集合，采用通用遍历格式实现
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
    /*
    两个明确：
    返回值类型：void
    参数：ArrayList<Student> array
    */
    public static void addStudent(ArrayList<Student> array) {
        //键盘录入学生对象所需要的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名:");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄:");
        String age = sc.nextLine();
        //创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
        //往集合中添加学生对象
        array.add(s);
    }
}

4、ArrayList集合存储学生对象三种方式遍历

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

  • 学生类
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
  • 测试类
public class ArrayListDemo {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        //把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);
        
        //迭代器：集合特有的遍历方式
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");
        
        //普通for：带有索引的遍历方式
        for(int i=0; i<array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");
        
        //增强for：最方便的遍历方式
        for(Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

6.4 LinkedList集合

  • LinkedList集合

    底层是链表结构实现，查询慢，增删快

  • 成员方法

方法名说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中的最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素

6.5 Set集合

概述和特点

  • Set集合的特点
    • 元素存取无序
    • 没有索引、只能通过迭代器或增强for循环遍历
    • 不能存储重复元素
public class SetDemo {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<String>();
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");
        //遍历
        for(String s : set) {
            System.out.println(s);
        }
    }
}

哈希值

  • 哈希值简介

    是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

  • 如何获取哈希值

    Object类中的public int hashCode()：返回对象的哈希码值

  • 哈希值的特点

    • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
    • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

  • 学生类

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int hashCode() {
        return 0;
    }
}
  • 测试类
public class HashDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("林青霞",30);
        //同一个对象多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode()); //1060830840
        System.out.println(s1.hashCode()); //1060830840
        System.out.println("--------");
        Student s2 = new Student("林青霞",30);
        //默认情况下，不同对象的哈希值是不相同的
        //通过方法重写，可以实现不同对象的哈希值是相同的
        System.out.println(s2.hashCode()); //2137211482
        System.out.println("--------");
        System.out.println("hello".hashCode()); //99162322
        System.out.println("world".hashCode()); //113318802
        System.out.println("java".hashCode()); //3254818
        System.out.println("world".hashCode()); //113318802
        System.out.println("--------");
        System.out.println("重地".hashCode()); //1179395
        System.out.println("通话".hashCode()); //1179395
    }
}

6.6 HashSet集合

  • HashSet集合的特点
    • 底层数据结构是哈希表
    • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
    • 没有带索引的方法，所以不能使用普通for循环遍历
    • 由于是Set集合，所以是不包含重复元素的集合
public class HashSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<String>();
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");
        //遍历
        for(String s : hs) {
            System.out.println(s);
        }
    }
}
  • 哈希表

image-20230130114750179

1、集合存储学生对象并遍历

  • 案例需求

    • 创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
    • 要求：学生对象的成员变量值相同，我们就认为是同一个对象

  • 学生类

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name ==
            null;
    }
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}
  • 测试类
public class HashSetDemo02 {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<Student> hs = new HashSet<Student>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        Student s4 = new Student("王祖贤", 33);
        //把学生添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);
        
        //遍历集合(增强for)
        for (Student s : hs) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

2、LinkedHashSet集合概述和特点

  • LinkedHashSet集合特点
    • 哈希表和链表实现的Set接口，具有可预测的迭代次序
    • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
    • 由哈希表保证元素唯一，也就是说没有重复的元素
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");
        linkedHashSet.add("world");
        //遍历集合
        for(String s : linkedHashSet) {
            System.out.println(s);
        }
    }
}

6.7 TreeSet集合

  • TreeSet集合概述
    • 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
      • TreeSet()：根据其元素的自然排序进行排序
      • TreeSet(Comparator comparator) ：根据指定的比较器进行排序
    • 没有带索引的方法，所以不能使用普通for循环遍历
    • 由于是Set集合，所以不包含重复元素的集合
public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();
        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);
        ts.add(30);
        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }//10 20 30 40 50
    }
}

1、自然排序Comparable的使用

  • 案例需求

    • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
    • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

  • 实现步骤

    • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
    • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
    • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

  • 学校类

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Student s) {
        // return 0;
        // return 1;
        // return -1;
        //按照年龄从小到大排序
        int num = this.age - s.age;
        // int num = s.age - this.age;
        //年龄相同时，按照姓名的字母顺序排序
        int num2 = num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}
  • 测试类
public class TreeSetDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>();
        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);
        Student s5 = new Student("linqingxia",33);
        Student s6 = new Student("linqingxia",33);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

2、比较器排序Comparator的使用

  • 案例需求

    • 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
    • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

  • 实现步骤

    • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
    • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
    • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

  • 学生类

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
  • 测试类
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
            //this.age - s.age
            //s1,s2
            int num = s1.getAge() - s2.getAge();
            int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
            : num;
            return num2;
          	}
        });
        
        //创建学生对象
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("wangzhaojun", 28);
        Student s3 = new Student("diaochan", 30);
        Student s4 = new Student("yangyuhuan", 33);
        Student s5 = new Student("linqingxia",33);
        Student s6 = new Student("linqingxia",33);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

3、成绩排序案例

  • 案例需求
    • 用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合
    • 要求：按照总分从高到低出现
  • 学生类
public class Student {
    private String name;
    private int chinese;
    private int math;
    public Student() {
    }
    public Student(String name, int chinese, int math) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getChinese() {
        return chinese;
    }
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }
    public int getMath() {
        return math;
    }
    public void setMath(int math) {
        this.math = math;
    }
    public int getSum() {
        return this.chinese + this.math;
    }
}
  • 测试类
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建TreeSet集合对象，通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
            // int num = (s2.getChinese()+s2.getMath())-
            (s1.getChinese()+s1.getMath());
            //主要条件
            int num = s2.getSum() - s1.getSum();
            //次要条件
            int num2 = num == 0 ? s1.getChinese() - s2.getChinese() :
            num;
            int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName())
            : num2;
            return num3;
            }
        });
        
        //创建学生对象
        Student s1 = new Student("林青霞", 98, 100);
        Student s2 = new Student("张曼玉", 95, 95);
        Student s3 = new Student("王祖贤", 100, 93);
        Student s4 = new Student("柳岩", 100, 97);
        Student s5 = new Student("风清扬", 98, 98);
        Student s6 = new Student("左冷禅", 97, 99);
        // Student s7 = new Student("左冷禅", 97, 99);
        Student s7 = new Student("赵云", 97, 99);
        //把学生对象添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        //遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getChinese() + "," +
                               s.getMath() + "," + s.getSum());
        }
    }
}

4、不重复的随机数案例

  • 案例需求
    • 编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出
public class SetDemo {
    public static void main(String[] args) {
        //创建Set集合对象
        // Set<Integer> set = new HashSet<Integer>();
        Set<Integer> set = new TreeSet<Integer>();
        //创建随机数对象
        Random r = new Random();
        //判断集合的长度是不是小于10
        while (set.size()<10) {
            //产生一个随机数，添加到集合
            int number = r.nextInt(20) + 1;
            set.add(number);
        }
        //遍历集合
        for(Integer i : set) {
            System.out.println(i);
        }
    }
}

6.8 Map集合

  • Map集合概述
interface Map<K,V> //K：键的类型；V：值的类型

  • Map集合的特点

    • 键值对映射关系
    • 一个键对应一个值
    • 键不能重复，值可以重复
    • 元素存取无序

  • Map集合的基本使用

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();
        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        map.put("itheima003","柳岩");
        //输出集合对象
        System.out.println(map);
    }
}

1、基本方法介绍

方法名说明
V put(K key,V value)添加元素
V remove(Object key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue(Object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数
  • 示例代码
public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();
        //V put(K key,V value)：添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        
        //V remove(Object key)：根据键删除键值对元素
        // System.out.println(map.remove("郭靖"));
        // System.out.println(map.remove("郭襄"));
        
        //void clear()：移除所有的键值对元素
        // map.clear();
        
        //boolean containsKey(Object key)：判断集合是否包含指定的键
        // System.out.println(map.containsKey("郭靖"));
        // System.out.println(map.containsKey("郭襄"));
        
        //boolean isEmpty()：判断集合是否为空
        // System.out.println(map.isEmpty());
        
        //int size()：集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());
        
        //输出集合对象
        System.out.println(map);
    }
}

2、集合的获取功能

方法名说明
V get(Object key)根据键获取值
Set keySet()获取所有键的集合
Collection values()获取所有值的集合
Set> entrySet()获取所有键值对对象的集合
  • 示例代码
public class MapDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");
        
        //V get(Object key):根据键获取值
        // System.out.println(map.get("张无忌"));
        // System.out.println(map.get("张三丰"));
        
        //Set<K> keySet():获取所有键的集合
        // Set<String> keySet = map.keySet();
        // for(String key : keySet) {
        // System.out.println(key);
        // }
        
        //Collection<V> values():获取所有值的集合
        Collection<String> values = map.values();
        for(String value : values) {
            System.out.println(value);
        }
    }
}

3、Map集合的遍历(方式1)

  • 遍历思路

    • 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
      • 把所有的丈夫给集中起来
      • 遍历丈夫的集合，获取到每一个丈夫
      • 根据丈夫去找对应的妻子

  • 步骤分析

    • 获取所有键的集合。用keySet()方法实现
    • 遍历键的集合，获取到每一个键。用增强for实现
    • 根据键去找值，用get(Object key)方法实现
public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");
        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

4、Map集合的遍历(方式2)

  • 遍历思路
    • 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
      • 获取所有结婚证的集合
      • 遍历结婚证的集合，得到每一个结婚证
      • 根据结婚证获取丈夫和妻子
  • 步骤分析
    • 获取所有键值对对象的集合
      • Set<Map,Entry<K,V>> entrySet()：获取所有键值对对象的集合
    • 遍历键值对对象的集合，得到每一个键值对对象
      • 用增强for实现，得到每一个Map.Entry
    • 根据键值对对象获取键和值
      • 用getKey()得到键
      • 用getValue()得到值
public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");
        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }                                                                 
    }
}

6.9 HashMap集合

1、HashMap集合练习之键是String值是Student

创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。存储三个键值对元素，并遍历

  • 学生类
public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
  • 测试类
/*
    需求：
    创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。存储三个键值对
    元素，并遍历
    思路：
    1:定义学生类
    2:创建HashMap集合对象
    3:创建学生对象
    4:把学生添加到集合
    5:遍历集合
    方式1：键找值
    方式2：键值对对象找键和值
*/
public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<String, Student> hm = new HashMap<String, Student>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        //把学生添加到集合
        hm.put("itheima001", s1);
        hm.put("itheima002", s2);
        hm.put("itheima003", s3);
        
        //方式1：键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            Student value = hm.get(key);
            System.out.println(key + "," + value.getName() + "," +
                               value.getAge());
        }
        System.out.println("--------");
        
        //方式2：键值对对象找键和值
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for (Map.Entry<String, Student> me : entrySet) {
            String key = me.getKey();
            Student value = me.getValue();
            System.out.println(key + "," + value.getName() + "," +
                               value.getAge());
        }
    }
}

2、HashMap集合练习之键是Student值是String

  • 案例需求

    • 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
    • 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

  • 学生类

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name ==
            null;
    }
    
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}
  • 测试类
public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student, String> hm = new HashMap<Student, String>();
        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        Student s4 = new Student("王祖贤", 33);
        //把学生添加到集合
        hm.put(s1, "西安");
        hm.put(s2, "武汉");
        hm.put(s3, "郑州");
        hm.put(s4, "北京");
        //遍历集合
        Set<Student> keySet = hm.keySet();
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," +
                               value);
        }
    }
}

3、集合嵌套之ArrayList嵌套HashMap

  • 案例需求
    • 创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap
    • 每一个HashMap的键和值都是String，并遍历。
public class ArrayListIncludeHashMapDemo {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<HashMap<String, String>> array = new
            ArrayList<HashMap<String, String>>();
        //创建HashMap集合，并添加键值对元素
        HashMap<String, String> hm1 = new HashMap<String, String>();
        hm1.put("孙策", "大乔");
        hm1.put("周瑜", "小乔");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm1);
        HashMap<String, String> hm2 = new HashMap<String, String>();
        hm2.put("郭靖", "黄蓉");
        hm2.put("杨过", "小龙女");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm2);
        HashMap<String, String> hm3 = new HashMap<String, String>();
        hm3.put("令狐冲", "任盈盈");
        hm3.put("林平之", "岳灵珊");
        //把HashMap作为元素添加到ArrayList集合
        array.add(hm3);
        //遍历ArrayList集合
        for (HashMap<String, String> hm : array) {
            Set<String> keySet = hm.keySet();
            for (String key : keySet) {
                String value = hm.get(key);
                System.out.println(key + "," + value);
            }
        }
    }
}

4、集合嵌套之HashMap嵌套ArrayList

  • 案例需求
    • 创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList
    • 每一个ArrayList的元素是String，并遍历。
public class HashMapIncludeArrayListDemo {
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap<String, ArrayList<String>> hm = new HashMap<String,
        ArrayList<String>>();
        //创建ArrayList集合，并添加元素
        ArrayList<String> sgyy = new ArrayList<String>();
        sgyy.add("诸葛亮");
        sgyy.add("赵云");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("三国演义",sgyy);
        ArrayList<String> xyj = new ArrayList<String>();
        xyj.add("唐僧");
        xyj.add("孙悟空");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("西游记",xyj);
        ArrayList<String> shz = new ArrayList<String>();
        shz.add("武松");
        shz.add("鲁智深");
        //把ArrayList作为元素添加到HashMap集合
        hm.put("水浒传",shz);
        //遍历HashMap集合
        Set<String> keySet = hm.keySet();
        for(String key : keySet) {
            System.out.println(key);
            ArrayList<String> value = hm.get(key);
            for(String s : value) {
                System.out.println("\t" + s);
            }
        }
    }
}

5、统计字符串中每个字符出现的次数

  • 案例需求
    • 键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
    • 举例：键盘录入“aababcabcdabcde” 在控制台输出：“a(5)b(4)c(3)d(2)e(1)”
public class HashMapDemo {
    public static void main(String[] args) {
        //键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //创建HashMap集合，键是Character，值是Integer
        // HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
        TreeMap<Character, Integer> hm = new TreeMap<Character, Integer>();
        //遍历字符串，得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);
            //拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
            Integer value = hm.get(key);
            if (value == null) {
                //如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
                hm.put(key,1);
            } else {
                //如果返回值不是null：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key,value);
            }
        }
        //遍历HashMap集合，得到键和值，按照要求进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for(Character key : keySet) {
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result = sb.toString();
        //输出结果
        System.out.println(result);
    }
}

6.10 Collections集合工具类

1、Collections概述和使用

  • Collections类的作用

    是针对集合操作的工具类

  • Collections类常用方法

方法名说明
public static void sort(List list)将指定的列表按升序排序
public static void reverse(List list)反转指定列表中元素的顺序
public static void shuffle(List list)使用默认的随机源随机排列指定的列表
public class CollectionsDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<Integer>();
        //添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
        //public static <T extends Comparable<? super T>> void sort•(List<T> list)：将指定的列表按升序排序
        Collections.sort(list);
        
        //public static void reverse•(List<?> list)：反转指定列表中元素的顺序
        Collections.reverse(list);
        
        //public static void shuffle•(List<?> list)：使用默认的随机源随机排列指定的列表
        Collections.shuffle(list);
        System.out.println(list);
    }
}

2、ArrayList集合存储学生并排序

  • 案例需求

    • ArrayList存储学生对象，使用Collections对ArrayList进行排序
    • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

  • 学生类

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
  • 测试类
public class CollectionsDemo02 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("linqingxia", 30);
        Student s2 = new Student("zhangmanyu", 35);
        Student s3 = new Student("wangzuxian", 33);
        Student s4 = new Student("liuyan", 33);
        //把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        //使用Collections对ArrayList集合排序
        //sort•(List<T> list, Comparator<? super T> c)
        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
                    : num;
                return num2;
            }
        });
        //遍历集合
        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}
黑马程序员Java教程学习笔记（一）
末初 · mochu7
01-17 2万+
文章目录黑马程序员Java学习笔记Java版本Java语言的跨平台原理JRE和JDKJDK的下载和安装HelloWorld案例注释关键字常量数据类型标识符类型转换运算符字符"+"操作字符串"+"操作复制运算符自增自减运算符关系运算符逻辑运算符三元运算符两只老虎三个和尚 黑马程序员Java学习笔记 Java版本 Java(5.0)：是更新力度很大的一个版本，直接让Java的发展进入了快车道 Java(8.0)：是公司中生产/开发环境使用的最多的版本 Java(11.0)：是Java学习者使用的最
Springboot入门到精通（超详细文档）
热门推荐
cuiqwei的博客
06-24 37万+
1. Spring Boot是什么 我们知道，从 2002 年开始，Spring 一直在飞速的发展，如今已经成为了在Java EE（Java Enterprise Edition）开发中真正意义上的标准，但是随着技术的发展，Java EE使用 Spring 逐渐变得笨重起来，大量的 XML 文件存在于项目之中。繁琐的配置，整合第三方框架的配置问题，导致了开发和部署效率的降低。 2012 年 10 月，Mike Youngstrom 在 Spring jira 中创建了一个功能请求，要求在 Spring
史上最强 Java 学习路线图！
沉默王二
04-24 32万+
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的。 第一部分：Java 基础篇 这个阶段就是编程入门，掌握 Java 这门编程语言的基本语法，为后面的修行之路打好基础。 包括的知识点有： 环境搭建——Intellij IDEA 一站式搞定 Java 基础语法 面向对象——封装、继承、多态 数组 字符串 集合框架 IO 反射 注解 网络编程 并发编程 这方面的资源我给大家梳理下： 1）针对 Intellij IDEA，GitHub 上有一份简体中文版教
Java 循环结构，超详细整理，适合新手入门
久绊A的博客
02-16 2370
Java 循环结构，超详细整理，适合新手入门、一、什么是循环？、无限循环、什么是无限循环？、无限循环案例、while 循环、什么是while循环？、while 循环基本用法：、案例：计算从1到100的和：（1 + 2 + 3 + 4 + … + 100 = ?）、do…while 循环、什么是do-while循环？、do…while 循环基本用法、实例：计算从1到100的和：（1 + 2 + 3 + 4 + … + 100 = ?）
超全Java入门学习路线指南
Javaaaaaaaaaaa13的博客
11-28 1429
swing的入门实例讲解控件、事件处理和布局介绍弹出框和多个窗口之间的切换。
Linux入门-部署 超详细教学
一名热爱编程的热血青年
05-12 1617
Linux 网络配置 本地部署 mysql tomcat redis nginx
java如何从入门进阶到高级
2401_86900375的博客
01-05 1148
针对java的学习，不同阶段采用的方式是不一样的。本文把java的学习分为入门、实战、进阶三个阶段。下面分开来说
卷土重来之Java入门基础
free_girl_fang的博客
10-24 827
Java入门课程旨在为初学者提供Java编程语言的基础知识和核心概念。课程内容涵盖Java的历史和特点、基本数据类型、变量和常量、运算符、控制流程（包括条件语句和循环）、数组和字符串处理。通过实践练习和小型项目，学员将学习如何编写、调试和运行Java程序，为进一步学习高级Java特性和框架打下坚实的基础。本课程适合对编程感兴趣的新手，无需任何先前的编程经验。
2024年Java学习路线【超详细超实用】
m0_47946173的博客
01-29 5642
JavaSE> 贪吃蛇游戏-->多线程下载器-->图书管理系统-->在线聊天项目-->MySQL-->JDBC -->前端必修课-->Vue--> JavaWeb -->Ajax -->Maven入门篇-->Maven进阶篇-->MyBatis-->Spring-->SpringMVC-> Linux--> - > Git-->SpringBoot3 -->Redis7 -->Spring Security--> MyBatis Plus-->动力云客-->动力恒合仓储项目 --> RabbitMQ--
【CSS】入门级教学（超级细致版本）
懒羊羊的博客
03-20 3044
html+css CSS是用来修饰HTML内容的打个比方 HTML相当于你买了一间房子而CSS就相当于装修这间房子。HTML定义网页的结构,主要让页面的内容结构化、块状化 CSS控制 HTML的标签,定义所需要的样式，美化网页。 p{}是用来修改段落间距参数的，针对于换行的元素之间 CLASS .****意思是名为****的类这样的标签
编程课件+Java系列课程+PPT课件+Java教学
04-23
一、Java入门 - Java概述：介绍Java的历史、特点和应用领域。 - 开发环境搭建：指导安装JDK和配置开发环境，推荐使用IDE如IntelliJ IDEA。 二、基础语法 - 数据类型与变量：讲解基本数据类型和变量声明。 - ...
Flink保姆级教程,超详细,教学集成多个第三方工具(从入门到精通)
Oz_Mood的博客
04-02 1万+
Flink 允许你通过实现接口来创建自定义数据源。// 定义一个自定义数据源Thread.sleep(1000) // 模拟数据生成延迟// 创建执行环境// 添加自定义数据源// 打印数据流// 启动 Flink 作业以上示例展示了如何在 Scala 中使用 Flink DataStream API 来从不同的数据源获取数据。每个示例都包含了创建数据流的代码和对数据流进行操作的注释。这些示例可以作为构建更复杂 Flink 流处理作业的起点。
2023年Java学习路线【超详细超实用】
m0_47946173的博客
11-02 845
Java学习路线速看版：JavaSE--> MySQL--> JavaSE项目【图书管理系统】-->JDBC -->前端必修课-->Vue--> JavaWeb -->Ajax -->Linux-->Maven--> MyBatis--> Spring-> SpringMVC- > Git-->CRM项目--> Redis7 --> Maven进阶--> SpringBoot3 --> MyBatis Plus --> Dubbo -->盈利宝项目--> 动力恒合仓储项目 --> SpringC
Infron超级Java入门教程核心知识点详解
资源摘要信息:&quot;《Infron Real Electric超级Java Ingang》是针对Java初学者的基础教学资源，其主要目的是让学习者掌握Java编程语言的基础知识和核心概念。本资源中将详细阐述Java语言的基础知识，包括但不限于Java的...
Java循环编程常见错误与优化实践
最新发布
静水深流
06-10 181
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
11《Java 类加载机制：从动态加载到热修复的底层秘密》
qq_62682600的博客
06-08 907
Java 类加载机制在运行期完成类的加载、连接与初始化，牺牲部分性能换灵活性，支持热修复、插件化等。其生命周期含 7 阶段，初始化有 5 种强制触发场景，动态性是热修复等技术的底层基础。
什么是闭包，JavaScript闭包详解
qq_44136882的博客
06-09 897
JavaScript闭包详解：闭包是函数与可访问的外部变量的组合，具有记忆词法作用域的特性。核心特征在于函数能访问定义时的作用域变量，即使在其他位置执行。常见用途包括封装私有变量、创建函数工厂和处理回调。但需注意内存泄漏风险及循环中的变量共享问题。React Hooks也依赖闭包机制保存状态。理解闭包有助于编写高效灵活的代码，但需正确处理变量引用和生命周期。
Java 语言特性(面试系列1)
myy2012的专栏
06-10 1096
JVM 为节省内存，相同字面量的字符串共享同一个实例。：线程安全，分段锁实现（JDK8 采用 CAS+之间的对象，超出范围时创建新对象。
springCloud2025+springBoot3.5.0+Nacos集成redis从nacos拉配置起服务
zwrlj527的专栏
06-07 642
本文探讨了在搭建最新SpringCloud+SpringBoot3+Nacos微服务框架时，网关(Gateway)选择WebFlux响应式编程模型的原因及Redis集成的方案。作者对比了WebFlux与传统Servlet栈的性能优势，包括非阻塞I/O、高并发处理能力等技术特点。针对Redis集成问题，提出了两种解决方案：一种是自定义配置类RedisAfterNacosAutoConfiguration，确保在Nacos配置加载后初始化Redis连接；另一种是直接使用SpringBoot自动配置。文章还提供了
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值