关于java:1w-字总结-Java-常用类整理太全了建议收藏

起源：cnblogs.com/lwtyyds/p/15678152.html

罕用类概述

1. 外部类
2. Object 类
3. 包装类
4. 数学类
5. 工夫类
6. 字符串
7. String Builder 和 StringBuffer
8. DecimalFormat

外部类

「概念」：在一个类外部再定义一个残缺的类。

个别状况下类与类之间是互相独立的，外部类的意思就是突破这种独立思想，让一个类成为另一个类的外部信息，和成员变量、成员办法等同级别。

「外部类的益处：」

把一个类写在里面和写在外面最终达到的后果都一样，那咱们为什么还要应用外部类，岂不是多此一举吗？

「采纳外部类这种技术，能够暗藏细节和内部结构，封装性更好，让程序的构造更加正当！如果类很多且都裸露在里面，那么类与类之间的调用就会非常繁琐！」

外部类的分类：

1. 成员外部类（非动态外部类）

参考代码如下：

package NeiBuLei;
public class OuterClass {
    // 成员变量
    private String OuterName;
    // 成员办法
    public void display(){System.out.println("这是外部类办法！");
        System.out.println(OuterName);
    }
    // 外部类
    public class InnerClass{
        // 成员变量
        private String InnerNme;
        // 构造方法
        public InnerClass() {InnerNme = "Inner Class";}
        // 成员办法
        public void display(){System.out.println("这是外部类办法！");
            System.out.println(InnerNme);
        }
    }
    // 主办法
    public static void main(String[] args) {OuterClass outerClass = new OuterClass();
        outerClass.display();// 这是外部类办法！null

        // 这个类是外部类，曾经不是独立的类了，因而不能像外部类一样间接创立！//InnerClass innerClass = new InnerClass(); 行不通
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成员办法 / 变量 只是加了个前缀
        innerClass.display();// 这是外部类办法！}
}

输入后果：

这是外部类办法！null 这是外部类办法！Inner Class

「总结：成员外部类（非动态外部类）的应用就是将外部类作为外部类的的一个成员变量 / 成员办法来应用，所以必须依赖于外部类的对象能力调用，用法和成员变量 / 成员办法统一！」

2. 部分外部类

部分外部类：根本的外部类还能够在一个办法体中定义。

package NeiBuLei;
public class OuterClass {
    // 成员变量
    private String OuterName;
    // 成员办法
    public void display(){
        class InnerClass {public void print(){System.out.println("这是一个部分外部类办法！");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.print();}

    // 主办法
    public static void main(String[] args) {OuterClass outerClass = new OuterClass();
        outerClass.display();}
}

1. 动态外部类

动态外部类的结构不须要依赖于外部类对象，类中的动态组件都不须要依赖于任何对象，能够间接通过「类自身」 进行结构。

package NeiBuLei;
public class OuterClass {
    // 成员变量
    private String OuterName;
    // 成员办法
    public void display(){System.out.println("这是外部类办法！");
        System.out.println(OuterName);
    }
    // 动态外部类
    public static class InnerClass{
        private String InnerName;
        public InnerClass() {InnerName = "Inner Class";}

        // 成员办法
        public void display(){System.out.println("这是动态外部类办法！");
            System.out.println(InnerName);
        }
    }

    // 主办法
    public static void main(String[] args) {OuterClass outerClass = new OuterClass();
        outerClass.display();
        // 动态外部类的结构不依赖与外部类，能够间接通过类自身进行结构！InnerClass innerClass = new InnerClass();
        innerClass.display();}
}

输入后果：

这是外部类办法！null 这是动态外部类办法！Inner Class

4. 匿名外部类

匿名外部类：没有名字的外部类。

匿名外部类「次要利用与接口的实现！」

接口：

package NeiBuLei;
public interface MyInterface {public void test();
}

实现类：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {System.out.println("test");
    }
}

匿名外部类的应用：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {System.out.println("test");
    }
}

「匿名外部类的益处：」

咱们定义接口之后，「它的实现类不须要去独自创立一个文件去写它的实现」，咱们能够把这个实现类的操作写到咱们调用的中央就能够了！写起来更加简洁、不便。

「匿名外部类的毛病：」

耦合度太高了！

Object 类

匿名外部类的毛病

Object 类罕用办法：

1.equals 办法

「==与 equals 的比照【面试题】+ jdk 查看原码」

== 是一个比拟运算符

1. ==：既能够判断根本类型，又能够判断援用类型
2. ==：如果判断的是「根本类型」，「判断的是值是否相等」。

//==：如果判断的是根本类型，判断的是 值 是否相等
int x1 = 10;
int x2 = 10;
double x3 = 10.0;
System.out.println(x1 == x2);//true
System.out.println(x1 == x3);//true

1. ==：如果判断的是「援用类型」，「判断的是地址是否相等，即判断是不是同一个对象」

package Equals;
public class Test01 {public static void main(String[] args) {
        //==：如果判断的是援用类型，判断的是地址是否相等，即判断是不是同一个对象
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a==c);// ? true
        System.out.println(b==c);// true
        B obj = a;
        System.out.println(obj==c);// true
    }
}

class B{}
class A extends B{}

1. equals 办法是 Object 类中的办法，「只能判断援用类型」。

❝

idea 查看 Jdk 原码：鼠标光标放在要查看的办法上，间接输出 ctrl + b

查看某个类所有办法：ctrl + F12

❞

1. 默认判断的是地址是否相等，「子类 (Object 类是所有类的父类) 往往重写该办法，用于判断内容是否相等」。

/*
Object 类 equals()办法原码

// 默认判断地址是否一样
    public boolean equals(Object obj) {return (this == obj);
    }

子类往往重写该办法，用于判断内容是否相等  String 类中的 equals()办法原码（重写了父类 equals()办法）public boolean equals(Object anObject) {if (this == anObject) {// 如果是同一个对象(地址雷同)
            return true; // 返回 true
        }
        if (anObject instanceof String) { // 判断类型
            String anotherString = (String)anObject; // 向下转型
            int n = value.length;
            if (n == anotherString.value.length) { // 如果长度雷同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) { // 比拟每一个字符
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true; // 如果两个字符串每一个字符都雷同，则返回 true
            }
        }
        return false;
    }
 */

在看个例子

【小练习】

写出输入后果：

package Equals;
public class EqualsTest01 {public static void main(String[] args) {Person p1 = new Person();
        p1.name = "tom";
        Person p2 = new Person();
        p2.name = "tom";
        System.out.println(p1 == p2);// 援用类型——判断是否为同一个对象（地址）System.out.println(p1.name.equals(p2.name));// p.name 是 String 类型，重写了 equals()办法——判断内容是否一样
        System.out.println(p1.equals(p2));//p1,p2 属于 Person 类，该类并没有重写 equals()办法（继承父类 equals()办法，即判断地址）String s1 = new String("abc");
        String s2 = new String("abc");

        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);
    }
}

class Person{public String name;}

输入后果：

false true false true false

2.hashCode 办法

小结：（能够当作地址来看但它实质上不是地址）

1. 进步具备哈希构造的容器的效率
2. 两个援用，如果指向的是同一个对象，则哈希值必定一样
3. 两个援用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值次要依据地址号来！不能将哈希值齐全等价于地址
5. 在前面的汇合中 hashCode 如果需要的话，也会重写

package hashCode;
public class HashCode {public static void main(String[] args) {AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hashCode()="+ aa.hashCode());
        System.out.println("aa2.hashCode()="+ aa2.hashCode());
        System.out.println("aa3.hashCode()="+ aa3.hashCode());
    }
}

class AA{}

输入后果：

❝

aa.hashCode()=460141958 aa2.hashCode()=1163157884 aa3.hashCode()=460141958

❞

3.toString 办法

toString 办法

根本介绍：

默认返回：全类名 + @ + 哈希值的十六进制

/*
    Object toString()原码
    //(1)getClass().getName() 类的全类名（包名 + 类名）//(2)Integer.toHexString(hashCode()) 将 hashCode 的值转成 16 进制字符串
    public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 */

「子类往往重写 toString 办法，用于返回对象的属性信息（快捷键：alt + insert），当然咱们也能够本人定制。」

当咱们输入一个对象时，toString()办法会被默认调用

4.finzlize 办法

finzlize 办法：当垃圾收集确定不再有对该对象的援用时，垃圾收集器在对象上调用该对象。

1. 当对象被回收时，零碎主动调用该对象的 finzlize 办法。子类能够重写该办法，做一些开释资源的操作
2. 什么时候被回收：当某个对象没有任何援用时，则 jvm 就认为这个对象是一个垃圾对象，就会时候垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finzlize 办法。

1. 垃圾回收机制的调用，是由零碎来决定（即有本人的 GC 算法），也能够通过 System.gc()被动触发垃圾回收机制。

❝

注：在理论开发中，简直不会用 finzlize 办法，更多的是为了应酬面试

❞

包装类

「1. 根本数据类型以及对应的包装类：」

byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean

这些类都在 java.lang 包

「2. 包装类的意义：」

1. 让根本数据类型有面向对象的特色
2. 「封装了字符串转化成根本数据类型的办法（重点）」

3. 包装类罕用办法：

1. Integer.parseInt()
2. Long.paseLong()
3. Double.parseDouble()

【参考代码】

public class Test {public static void main(String[] args) {//        Integer i = new Integer(10);// 创立包装类对象
//        Integer ii = 10; // 主动打包
//        System.out.println(i+10); // 在应用上，int 和 Integer 其实没有区别，能够相互应用
//        System.out.println(ii+10);
//        int j = ii;// 主动解包
//        System.out.println(j+100);

        String a = "12";
        String b = "34";
        System.out.println(a+b); // 1234
    // 转型:
        // 字符串转成 int 的惟一计划
        int c = Integer.parseInt(a);
        int d = Integer.parseInt(b);
        System.out.println(c+d); // 46

        // 字符串转成 double 类型
        String e = "1.25";
        double f = Double.parseDouble(e);
        System.out.println(f*6); // 7.5

        // 转成 long 类型
        long l = Long.parseLong("1234567");
        System.out.println(l);
    }
}

数学类

❝

数学类的办法都是静态方法，能够间接援用——Math. 办法();

❞

「罕用数学类办法：」

1. abs()：获取绝对值
2. max()：求最大值
3. min()：求最小值
4. pow()：求次幂
5. round()：四舍五入
6. sqrt()：求平方根

工夫类

Java 罕用工夫类：

1. Date 日期类
2. Calendar 日历类
3. SimpleDateFormat 格式化工夫类

❝

Date 和 Calendar 类 在 java.util 包中，SimpleDateFormat 类 在 java.text 包

❞

1.Date 日期

【1】new Date() 能够获取到零碎工夫

【2】getTime() 能获取到工夫的 long 模式，能够用来计算时间差

❝

getTime()——获取计算机底层存储的数字，返回一个数字用来示意工夫，这个数字的类型 long，单位为毫秒。

❞

【参考代码】

import java.util.Date;
public class Test {public static void main(String[] args) {Date d = new Date();
        System.out.println(d); // 零碎工夫
        //get...()——获取年月日.....
        System.out.println(d.getYear()+1900); // 从 1900 年开始算的
        System.out.println(d.getMonth()+1); // 月份从 0 开始计算
        System.out.println(d.getDate()); // 天数
        System.out.println(d.getHours());// 小时

        //getTime()——获取到工夫的毫秒模式 返回的是 long
        System.out.println(d.getTime());
    }
}

2.Calendar 日历

【1】get() 获取到工夫的某一部分

【2】set() 设置工夫 – -> 计算工夫：零碎曾经帮咱们设置好了，不必放心二月有多少天等问题，计算工夫非常不便

❝

注：Calendar 日历类是抽象类，因而不能够去 new 对象。尽管抽象类不能创建对象，然而 jdk 官网提供了一个实例对象的操作：

Calendar rightNow = Calendar.getInstance();

咱们通过这条代码就是间接造了一个 Calender 的对象

❞

【参考代码】：get() 获取到工夫的某一部分：

package date;
import java.util.Calendar;
public class TestCalendar {public static void main(String[] args) {Calendar cal = Calendar.getInstance();
//        System.out.println(cal);

        /*
 假如当天：2021
        8
        10
         */
  cal.set(Calendar.DATE,cal.get(Calendar.DATE)+31); // 计算工夫(这里用天数计算的)

        // 获取 Calendar 创立的对象里的所有内容
        System.out.println(cal.get(Calendar.YEAR)); // 2021 年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：从 0 开始的  后果：为 10 月
        System.out.println(cal.get(Calendar.DATE)); // 日
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));// 小时
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));
    }
}

【参考代码】：set() 设置工夫 – -> 计算工夫：

❝

注：cal.setTime(d); 把 Date 转化成 Calendar

❞

package date;
import java.util.Calendar;
import java.util.Date;
public class TestCalendar {public static void main(String[] args) {Date d = new Date();
        Calendar cal = Calendar.getInstance();
        cal.setTime(d);// 把 Date 转化成 Calendar
        System.out.println(cal);
        System.out.println(cal.get(Calendar.YEAR)); //  年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：从 0 开始的
        System.out.println(cal.get(Calendar.DATE)); // 日
    }
}

3.SimpleDateFormat 格式化工夫

Date，Calendar 通过援用也能够进行工夫的格式化，但比拟繁琐，而 SimpleDateFormat 类是专门帮咱们格式化工夫的工具类，它在 java.text 包中。

【工夫格局】：yyyy-MM-dd HH:mm:ss

SimpleDateFormat 类有两大罕用办法：

【1】format(Date)：

❝

format(Date) 帮咱们把工夫转成字符串，字符串的格局为 SimpleDateFormat 类定义对象时设置的工夫格局

❞

【参考代码】

package Simple;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
public class Test {public static void main(String[] args) {Date d = new Date();
        System.out.println(d); //Thu Aug 12 08:40:08 CST 2021  不美观

  //                  设置格式化工夫的模式，咱们罕用 yyyy-MM-dd HH:mm:ss 这个模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 工夫格局
        String s = sdf.format(d); // 格式化工夫
        System.out.println(s); // 2021-08-12 08:45:09
    }
}

【2】parse(String)：

❝

parse(String) 帮咱们把字符串转化成工夫

❞

【参考代码】

package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Test2 {public static void main(String[] args) throws ParseException {Scanner sc = new Scanner(System.in);
        System.out.println("请输出一个工夫(yyyy-MM-dd HH:mm:ss)：");
        String s = sc.nextLine();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       Date d =  sdf.parse(s); // 把字符串转成工夫
        System.out.println(d);
        /*
        请输出一个工夫(yyyy-MM-dd HH:mm:ss)：2021-08-12 12:25:21
        Thu Aug 12 12:25:21 CST 2021
         */
    }
}

❝

注：因为用户输出的字符串不肯定是咱们要求的格局，可能是任何货色，想把它们转成工夫是不可能的，你不可能把一个人转成工夫 对吧，因而存在着很大的危险未解决(异样: java.text.ParseException)，为此咱们须要解决异样。

❞

4. 计算时间差

计算思路：

1. 格式化工夫
2. 先将字符串转化成 long 类型工夫
3. 计算毫秒级别时间差，取绝对值
4. 毫秒级别时间差转成秒级别
5. 秒级别时间差转成分钟级别
6. 分钟级别时间差转化显示成 xx 小时 xx 分钟

【参考代码】

package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDiff {public static void main(String[] args) throws ParseException {
        String s1 = "2021-08-12 12:00:00"; // 开始工夫
        String s2 = "2021-08-12 14:35:00"; // 完结工夫
        // 格式化工夫
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        // 将字符串转成工夫模式
        Date d1 = sdf.parse(s1);
        Date d2 = sdf.parse(s2);

        // 计算时间差: 先要获取工夫毫秒模式（long 类型）再做差
        long long1 = d1.getTime();
        long long2 = d2.getTime();
        long diffTime = Math.abs(long1 - long2);

        // 秒级别时间差
        long diffSec = diffTime / 1000;

        // 分级别时间差
        long diffMin = diffSec / 60;

        // 显示 xx 小时 xx 分钟
        long displayHours = diffMin / 60; // 小时
        long displayMin = diffMin % 60; // 分钟
        System.out.println("您学习的时长为："+displayHours+"小时"+displayMin+"分钟");
    }
}

String 类

字符串类罕用办法

「办法汇总：」

❝

「注：字符串是一个不可变的类型（final 类），简直所有的字符串操作都会返回一个新字符串而不是在原有根底上进行批改。」

❞

【示例代码】

public class Test {public static void main(String[] args) {
        String s = "我的名字叫李华";
        s.concat("hhh"); // 在字符串 s 上拼接，拼接 hhh
        System.out.println(s);// 我的名字叫李华
        // 字符串是不可变的数据类型
        // 简直所有的字符串操作都会返回一个新字符串
        String s1 = s.concat("hhh"); // 在字符串 s 上拼接，拼接 hhh
        System.out.println(s1);// 我的名字叫李华 hhh

        String str1 = "李华喜爱看罗老师的视频";
        str1.replace("李华","张三");
        System.out.println(str3); // 李华喜爱看罗老师的视频  并没有替换 字符串是不变的 str1 还是 str1

        String str2 = str1.replace("李华","张三");// 简直所有的字符串操作都会返回一个新字符串 新串要用新变量接
        System.out.println(str2);// 张三喜爱看罗老师的视频
   }
}
package String;
import java.util.Scanner;
public class Test {public static void main(String[] args) {
        String s = "我的名字叫李华";
        System.out.println(s.charAt(0)); // 获取第 0 个地位的字符
        s.concat("hhh");
        System.out.println(s);// 我的名字叫李华
        // 字符串是不可变的数据类型
        // 简直所有的字符串操作都会返回一个新字符串
        String s1 = s.concat("hhh"); // 在字符串 s 上拼接，拼接 hhh
        System.out.println(s1);// 我的名字叫李华 hhh
        System.out.println(s.contains("李华")); //true
        System.out.println(s.contains("牛津")); //false
        System.out.println("邀请李华来加入英语沙龙流动".endsWith("流动"));//true 判断是否以 xxx 为结尾
        System.out.println("邀请李华来加入英语沙龙流动".startsWith("李华"));//false 判断是否以 xxx 结尾

        // equals 字符串内容是否雷同

        // 承受邀请加入流动的李华到现场后要输出验证码
//        String yanZhengMa = "AAkm";
//
//        Scanner sc = new Scanner(System.in);
//
//        System.out.println("请输出验证码("+yanZhengMa+")");
//
//        String userInput = sc.nextLine();
//
//        if(yanZhengMa.equalsIgnoreCase("aakm")){  // 疏忽大小写判断两边的内容是否一样
//            System.out.println("欢送加入英语沙龙流动！");
//        }else{//            System.out.println("您未受到邀请，请现场报名！");
//        }

//        String str = "李华玩得很开心！";
//        System.out.println(str.indexOf("开心"));// 5 计算给出字符串第一个呈现的地位

        String str2 = "李华问题很好";
        System.out.println(str2.length()); // 6 计算字符串的长度

        String str3 = "李华喜爱看罗老师的视频";
        str3.replace("李华","张三");
        System.out.println(str3); // 李华喜爱看罗老师的视频  并没有替换 字符串是不变的 str3 还是 str3

        String str4 = str3.replace("李华","张三");// 简直所有的字符串操作都会返回一个新字符串 新串要用新变量接
        System.out.println(str4);// 张三喜爱看罗老师的视频
        String str5 = "哈哈_呵呵_嘻嘻_噢 no";
        String[] ss = str5.split("_");// 切割
        System.out.println(ss[0]);// 哈哈
        System.out.println(ss[1]);// 哈哈
        System.out.println(ss[2]);// 嘻嘻
        System.out.println(ss[3]);// 噢 no

        String str6 = "今天天气不错";
        System.out.println(str6.substring(2,4));// 天气 字符串截取 [ ) 左闭右开，左边取不到

        String str7 ="哈    哈";
        System.out.println(str7.trim());// 去掉左右两边的空格
        int i = 10;
        System.out.println(String.valueOf(i)); // 根本数据类型转为字符串
        System.out.println(i+""); // 野路子
    }
}

String Builder 和 StringBuffer

「String 类的毛病：」

String 是一个不可变的数据类型，每每拼接都会产生一个新的字符串，那么内存迟早会被这些拼接的字符串塞满。

「String 类和 StringBuilder 和 StringBuffer 类的区别：」

StringBuilder 和 StringBuffer：「可变的字符串，不产生新对象，比拟省内存」，当进行大量的字符串拼接时倡议应用 StringBuffer 和 StringBuilder，但它们两个一些办法的实现简直跟 String 一样。

「StringBuffer 和 StringBuilder 类：」

【类似点】

两者用法截然不同，能够认为是一个类

【区别】

1. StringBuffer 线程平安，StringBuilder 非线程平安。
2. StringBuilder 相比于 StringBuffer 有速度劣势，「少数状况下倡议应用 StringBuilder 类，但当被要求线程平安时必须应用 StringBuilder 类」

❝

字符串拼接办法：append()办法

StringBuffer 和 StringBuilder 转成 String 类：

StringBuilder sb = new StringBuilder(“ 猫喜爱吃鱼 ”); String s = sb.toString();

❞

【参考代码】

package String;
public class TestStringBuilder {public static void main(String[] args) {StringBuilder sb = new StringBuilder();// 一个空的字符串 ""StringBuilder sb2 = new StringBuilder(" 猫喜爱吃鱼 ");
        System.out.println(sb2);// 猫喜爱吃鱼

        sb2.append("，狗也喜爱吃鱼");
        System.out.println(sb2);// 追加  猫喜爱吃鱼，狗也喜爱吃鱼

        sb2.insert(1,"哈哈哈");
        System.out.println(sb2); // 猫哈哈哈喜爱吃鱼，狗也喜爱吃鱼

        // 上述的操作 huan'c
        // 把 StringBuilder 转化成 String
        String s = sb2.toString();
        System.out.println(s); // 猫哈哈哈喜爱吃鱼，狗也喜爱吃鱼
        // 上述操作都能够将 StringBuilder 换成 StringBuffer，后果一样
    }
}

DecimalFormat

DecimalFormat：对小数进行格式化，保留几位小数。与格式化工夫联想记。

❝

. 示意小数点

0 和# 示意数位，保留几位就几个 0 或者 #

❞

【参考代码】

import java.text.DecimalFormat;
import java.util.Scanner;
public class Test {public static void main(String[] args) {
        double d= 10/3.0;
        System.out.println(d);//3.3333333333333335

        // . 示意小数点
        // 0 和 #示意数字

        // 保留两位小数                        格局
        DecimalFormat df = new DecimalFormat(".00"); // 或者.##
        String s = df.format(d); // 把 d 转成下面设置的格局
        System.out.println(s);//3.33
   }
}

总结

万变不离其宗，Java 的其余类和性能，都离不开这些根底。牢记根底，成长的更稳！

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！