大家好，我是讯享网，很高兴认识大家。



 <p>1.冯诺依曼计算机体系机构&#xff1a;输入、计算、存储、控制、输出。</p> 

讯享网

2.计算机存储的最小存储单元(计量单位)，用byte或者B表示。

二进制位：用byte表示

8个二进制位表示1个字节

GBK编码字符集下一个汉字是2个字节

UTF-8编码字符集下一个汉字是3个字节

但是Mysql中的varchar64单位是字符，会自动截断；不是字节。

3.ASCII码就记3个：0–48，A–65，a–97

4.常量：代码运行过程中，值不会改变的数据。

5.变量：分为基本数据类型【4类(整型、浮点型、字符型、布尔型)8种】和引用类型【类、接口、数组、枚举、注解】

6.标识符取名：可以包含英文字母、数字、$和_，但是不能数字开头，建议驼峰命名。

7.类型转换：等号两边类型不一致，不同类型的数据做运算。

8.类型转换分为自动类型转换(小转大)和强制类型转换(大转小，会有精度损失和数据溢出)，需要注意的是小数默认是double类型的双精度。

• 不要随意强转，很容易精度损失和数据溢出，float和double直接参与计算都会损失精度
• byte，short如果定义的值没有超过范围，jvm会自动转为int；如果再次赋值给byte，short需要我们手动强转
• char类型参与计算会自动转为int，提升为int会去对应的ASCII表中找对应的int值，没有的话就去unicode表(万国码)中找

  讯享网    public static void main(String[] args) {        short a = 10;        byte b = 20;        int c = a + b;        a=(short)c; // 不强转会提示Cast expression to ‘short’        b=(byte)c; // 不强转会提示Cast expression to ‘byte’        char d = ‘a’;        c= d + b; // ‘a’对应的是97 b是上面计算得到的30        System.out.println©; // 输出127   }

9.位运算符：

• 左移(<<)：左移几位就是乘以2的几次方 3 << 2 = 3* 2^2 = 12
• 右移(>>)：右移几位就是除以2的几次方，向下取整 9 >> 2 = 2,但是-9 >> 2 = -3。

10.数组：定长，存放相同类型的元素，在内存上连续。

• 动态初始化：数据类型[] 数组名 = new 数据类型[长度];
• 静态初始化：数据类型[] 数组名 = new 数据类型[]{元素，元素};
• 简化的静态初始化：数据类型[] 数组名= {};

11.操作数组常见的两个问题：

• 数组越界异常：ArrayIndexOutOfBoundsException
• 空指针异常：NullPointerException

12.标准的JavaBean：

• 类必须是具体的公共的。public class 类名
• 具有无参的构造方法和有参的构造方法
• 成员变量私有化，并提供用来操作的set和get方法

13.静态成员的特点：

• 静态成员属于类成员，不属于对象成员
• 静态成员随着类的加载而加载
• 静态成员优于非静态成员存在内存中
• 根据静态成员所在的类创建出来的对象，都可以共享这个静态成员

14.继承，关键字extends，需要注意：

• 子类可以继承父类中私有的和非私有成员，但是不能使用父类中私有成员
• 构造方法不能继承
• 继承不要从是否“拥有”方面学习，要从能否“使用”方面学习

15.继承前提下，成员变量的访问特点口诀：

看等号左边是谁，先调用谁中的成员；子类没有找父类

讯享网

注意：在 Java 中，类中的成员如果没有显式地添加访问修饰符，默认情况下会具有包内访问权限。这意味着这些成员只能在同一包内的类中访问。这种默认访问权限提供了一种介于 和 之间的访问控制机制。

成员方法的特点口诀：

看等号右边new的是谁，就先调用谁中的方法。

子类重写父类方法的注意事项：

• 子类重写父类方法之后，访问权限必须保证大于父类权限

public > protected > 默认 > private

• 子类重写父类方法，参数列表和方法名要一样
• 子类重写父类方法，返回值只能是父类返回类型的子类类型
• 私有方法不能重写，构造方法不能重写，静态方法不能重写

继承的使用场景：功能扩展（新增或者改造）

16.super和this：

• 关键字：
  • 引用当前对象的属性。
  • 调用当前对象的方法。
  • 调用当前对象的构造函数。
  • 作为方法的返回值。
• 关键字：
  • 引用父类的属性。
  • 调用父类的方法。
  • 调用父类的构造函数。

new子类对象时,会先初始化父类(先走父类无参构造方法).原因: 每个构造方法的第一行,默认都会有一个super(),不写jvm自动提供一个；super()代表的是父类无参构造

方法的继承：

• 子类不能继承构造方法，也不能重写
• 子类可以继承私有方法，不能重写
• 子类可以继承静态方法，不能重写

17.抽象类和抽象方法

• 抽象类中不一定非得有抽象方法
• 抽象方法所在的类一定是抽象类
• 抽象类不能new对象，只能new非抽象子类对象调用重写方法
• 抽象类理解为“标准”，子类必须重写所有抽象方法，不然编译报错
• 抽象类中可以有构造方法,是供子类创建对象时,初始化父类属性使用的
• 抽象类中的方法不是抽象方法，就必须包含方法体

18.接口是一个引用数据类型,是一种标准,规则

• 接口中的成员方法不加关键字默认是public abstract
• 可以加的关键字default（默认方法）、static（静态方法）
• 抽象方法不需要方法体；

• 默认方法和静态方法必须写方法体

          

接口的实现：

• 接口不能直接new，只能new实现类调用接口方法
• 抽象的方法实现类必须实现；默认的可以选择重写；静态的不能重写，因为属于接口，实现类只能调用

• 当一个类实现多个接口时,如果接口中的抽象方法有重名且参数一样的,只需要重写一次
• 当一个类实现多个接口时,如果多个接口中默认方法有重名的,且参数一样的,必须重写一次默认方法

19.抽象类和接口的区别

相同点: a.都位于继承体系的顶端,用于被其他类实现或者继承 b.都不能new c.都包含抽象方法,其子类或者实现类都必须重写这些抽象方法 不同点: a.抽象类:一般作为父类使用,可以有成员变量,构造,成员方法,抽象方法等 b.接口:成员单一,一般抽取接口,抽取的都是方法,视为功能的大集合 c.类不能多继承,但是接口可以

20.多态

a.前提: ​ 必须有子父类继承关系以及接口实现关系 ​ 必须有方法的重写 ​ 父类引用指向子类对象 ​ b.好处:扩展性强 -> 用父类类型接口,可以传递任意它的子类对象,接收哪个子类对象就指向哪个子类对象,就调用哪个子类对象重写后的方法 ​ 弊端:不能直接调用子类特有方法 ​ c.转型: ​ 向上转型:父类引用指向子类对象 ​ 向下转型:将父类类型转成子类类型,就可以调用子类特有功能 ​ d.成员的访问特点: ​ 成员变量:看等号左边是谁 ​ 成员方法:看new的是谁 ​ e.转型时容易出现的问题:类型转换异常ClassCastException ​ f.判断类型: instanceof

21.final

• 被final修饰的类不能被继承
• 被final修饰的方法不能被重写
• 被final修饰的变量不能重新赋值

final int a = 10; a = 20; // error: cannot assign a value to a final variable

• 被final修饰的对象地址值不会变，属性值可以改变

讯享网Person p = new Person(); p.setAge(10); system.Out.Println(p); // 打印的地址值

22.代码块：分为构造代码块和静态代码块

• 构造代码块:优先于构造方法执行，每次new对象都会调用。
• 静态代码块：优先于构造代码块，只执行一次。

23.匿名内部类

1.问题描述:我们如果想实现接口,简单使用一次抽象方法,我们就需要创建一个实现类,实现这个接口,重写抽象方法,还要new实现类对象,所以我们在想如果就单纯的想使用一次接口中的方法,我们能不能不这么麻烦呢?可以 a.创建实现类,实现接口 b.重写方法 c.创建实现类对象 d.调用方法 2.如果就想单纯的使用一下接口中的方法,我们就没必要经过以上四步了,我们可以四合一 3.匿名内部类怎么学:就按照一种格式来学,这一种格式就代表了实现类对象或者子类对象 4.格式: new 接口/抽象类(){ 重写方法 }.重写的方法();

=================================

类名 对象名 = new 接口/抽象类(){ 重写方法 } 对象名.重写的方法();

public interface USB {    void open();    void close(); }

讯享网public class Test01 {    public static void main(String[] args) {        new USB(){ ​            @Override            public void open() {                System.out.println(“usb打开了”);           } ​            @Override            public void close() {                System.out.println(“usb关闭了”);           }       }.open(); ​        System.out.println(“===================”); ​        USB usb = new USB() {            @Override            public void open() {                System.out.println(“USB打开了”);           } ​            @Override            public void close() {                System.out.println(“USB关闭了”);           }       };        usb.open();        usb.close();   } }

24.异常

• Throwable: 所有异常类的基类。
  • Error: 表示严重的错误，通常是无法恢复的，例如虚拟机错误、内存错误等。
  • Exception: 表示可以被程序捕获和处理的异常。

<ul><li> <p>RuntimeException: 运行时异常&#xff0c;通常是编程错误引起的&#xff0c;例如空指针异常、数组越界异常等。</p> </li><li> <p>非运行时异常&#xff08;Checked Exception&#xff09;: 必须被捕获或声明抛出的异常&#xff0c;例如 IOException、SQLException 等。</p> </li></ul></li></ul><p>常见的异常类</p> 

• RuntimeException 及其子类:
• NullPointerException: 当应用程序试图在要求为空的对象上调用实例方法时抛出
• ArrayIndexOutOfBoundsException: 当试图访问数组的无效索引时抛出。
• IllegalArgumentException: 当传递给方法的参数非法或不合适时抛出。
• ClassCastException: 当试图将对象强制转换为不是该对象的子类时抛出。

  

• ArithmeticException: 当发生异常的算术运算时抛出，例如除以零。
• UnsupportedOperationException: 当不支持请求的操作时抛出。

非运行时异常（Checked Exception）:

• IOException: 输入输出操作失败时抛出。
• FileNotFoundException: 当试图打开不存在的文件时抛出。
• SQLException: 数据库操作失败时抛出。

25.Object的toString()、equals()、clone()

• toString()的默认实现

讯享网public String toString() {    return getClass().getName() + “@” + Integer.toHexString(hashCode); }

但是可以自定义类的toString()实现

@Override public String toString() {

讯享网return "Person{name=''" + name + "', age='" + age + "}"; 

}

• equals()用于判断两个对象是否相等(默认实现是比较对象的引用，即是否同一个对象)

public boolean equals(Object obj) {    return (this == obj); }

也可以自定义实现，不过为了保持一致性，还需要重写hashCode()方法。

讯享网public class Person {    private String name;    private int age; ​    // 构造方法、getter 和 setter 略 ​    @Override    public boolean equals(Object obj) {        if (this == obj) {            return true;       }        if (obj == null || getClass() != obj.getClass()) {            return false;       }        Person other = (Person) obj;        return age == other.age && Objects.equals(name, other.name);   } ​    @Override    public int hashCode() {        return Objects.hash(name, age);   } }

• clone()方法默认实现是浅拷贝，只复制对象的基本类型属性和引用类型的引用。

protected Object clone() throws CloneNotSupportedException {    return super.clone(); }

浅拷贝的自定义实现：implements Cloneable 并重写clone()方法

浅拷贝：只复制对象的基本类型属性和引用类型的引用，新对象和原对象共享引用类型的属性。 深拷贝：递归地复制所有层次的对象，新对象和原对象完全独立。

26.Java.lang.Comparable

基本数据类型的大小比较可以使用比较运算符，引用类型的大小比较，java指定了一个标准接口：

讯享网package java.lang; ​ public interface Comparable{    int compareTo(Object obj); }

需要比较哪个类的对象大小，类就实现Comparable接口

 public Student(String name, int score) {        this.name = name;        this.score = score;   } ​    public String getName() {        return name;   } ​    public void setName(String name) {        this.name = name;   } ​    public int getScore() {        return score;   } ​    public void setScore(int score) {        this.score = score;   } ​    @Override    public String toString() {        return “Student{” +                “name=‘” + name + ’‘’ +                “, score=” + score +                ‘}’;   } ​    /*      this:代表students[i]      o:代表students[i+1] ​      如果students[i].getScore()-students[i+1].getScore()>0         证明数组中的前面一个对象比后面一个对象的分数高     /    @Override    public int compareTo(Object o) {        Student s = (Student) o;        return this.getScore()- s.getScore();   } }

出于扩展性考虑，使用第三方类的时候没有实现Comparable接口，或者不想用它本身的实现（比如人按身高排序，我想要按体重排序），这个时候Java给出了java.util.Comparator接口。

• 要比较的类实现Comparator接口

讯享网public class Student implements Comparator {}

• 重写compare方法定义比较规则

/

讯享网使用学生的身高为规则进行比较 传入对象o1，o2 如果s1的身高大于s2的身高，返回正数 如果s1的身高小于s2的身高，返回负数 如果s1的身高等于s2的身高，返回0 

/ ​ @Override public int compare(Object o1, Object o2) {    Student s1 = (Student) o1;    Student s2 = (Student) o2;    return s1.getHeight()-s2.getHeight(); }

27.基础API-String

实现原理：

• jdk8的时候:String底层是一个被final修饰的char数组-> private final char[] value;
• jdk9开始到之后:底层是一个被final修饰的byte数组-> private final byte[] value;

  一个char类型占2个字节 一个byte类型占1个字节 -> 省内存空间

字符串是常量，创建后不能更改

• 字面量创建：使用字面量创建的字符串会被存储在字符串池中。如果字符串池中已经存在相同的字符串，则不会创建新的对象，而是直接返回已存在的对象
• 使用new创建：不在字符串池中：使用 关键字创建的字符串对象不会被存储在字符串池中，每次调用 都会创建一个新的对象
• String构造函数创建：可以控制字符串长度
• 字符串连接创建：字符串连接会在运行时动态创建新的字符串对象。
  • 字符串拼接,如果等号右边是字符串字面值拼接,不会产生新对象(java出于性能考虑，编译时会将字面值字符串优化，直接拼接结果存放在字符串常量池中，不会创建新的对象)
  • 字符串拼接,如果等号右边有变量参数拼接,会产生新字符串对象(变量拼接字符串的实现是使用了StringBuilder的append方法追加了对象)

    String str1 = “hello”; String str2 = str1 + “world”; ​ // 编译器产生的类似字节码 String str2 = new StringBuilder().append(str1).append(“world”).toString(); ​ /

具体步骤 检查字符串常量池： 检查字符串常量池中是否存在 “world”。如果存在，直接使用；如果不存在，创建一个新的字符串对象并放入常量池中。 创建 StringBuilder 对象： 创建一个新的 StringBuilder 对象。 追加字符串： 使用 append 方法将 str1 和 “world” 追加到 StringBuilder 对象中。 转换为字符串： 调用 toString 方法将 StringBuilder 对象转换为一个新的字符串对象。 */

String.valueOf方法：将基本数据类型和对象转换为字符串。

StringBuilder或者StringBuffer： 和 对象是可变的，可以在不创建新对象的情况下修改字符串内容。

比较字符串的内容是否相等：

• 方法：比较字符串的内容是否相等。
• 运算符：比较字符串的引用是否相同。
• 方法：比较字符串的内容是否相等，不区分大小写。
• 方法：比较两个对象是否相等，可以处理 值。

常用的“获取”方法

• 获取长度：int length()
• 获取对应下标的字符：char charAt(int index)
• 获取指定字符在字符串中第一次出现的下标：int indexOf(String s)
• 获取拼接字符串：String concat(String s)
• 获取固定长度的字符串：String subString(int beginIndex) 前闭后开
• 截取字符串：String subString(int beginIndex, int endIndex) 前闭后开

常用的“转换”方法

• 转换成char数组：char[] toCharArray()
• 转换成byte数组： byte[] getBytes()
• 转换成指定编码的byte数组：byte[] getBytes(String charsetName)
• 替换字符：String replace(String s)

其他方法：

分割：String[] split((String regex)

判断包含：boolean contains(String s)

判断结尾：boolean endWith(String s)

判断开头：boolean startWith(String s)

转换小写：String toLowerCase()

转换大写：String toUpperCase()

去掉两端空格：String trim()

StringBuilder和StringBuffer简介：

• StringBuilder
  1. 非线程安全： 不是线程安全的，这意味着在多线程环境下使用 可能会导致数据不一致。
  2. 性能高：由于没有线程安全的开销， 在单线程环境下通常比 更快。
  3. 常用方法：

讯享网<ul><li> <p>&#xff1a;将指定的字符串追加到此序列的末尾。</p> </li><li> <p>&#xff1a;将指定的字符串插入此序列中。</p> </li><li> <p>&#xff1a;删除此序列中指定范围内的字符。</p> </li><li> <p>&#xff1a;将此序列中的字符顺序反转。</p> </li><li> <p>&#xff1a;返回此序列的字符串表示形式。</p> </li></ul></li></ol></li></ul> 

• StringBuffer
  1. 线程安全： 是线程安全的，所有公共方法都被同步（即使用 关键字），这使得多个线程可以安全地同时访问同一个 对象。
  2. 性能较低：由于线程安全的开销， 在单线程环境下通常比 慢。
  3. 常用方法

<ul><li> <p>&#xff1a;将指定的字符串追加到此序列的末尾。</p> </li><li> <p>&#xff1a;将指定的字符串插入此序列中。</p> </li><li> <p>&#xff1a;删除此序列中指定范围内的字符。</p> </li><li> <p>&#xff1a;将此序列中的字符顺序反转。</p> </li><li> <p>&#xff1a;返回此序列的字符串表示形式。</p> </li></ul></li></ol></li></ul> 

28.常用API-Math

math的基础用法：

• 求绝对值：static int abs(int a)
• 向上取整：static double ceil(double a)
• 向下取整：static double floor(double a)
• 四舍五入：static around(double a)
• 求较大值：static int max(int a, int b)
• 求较小值：static int min(int a, int b)

BigInteger：处理超大正数

1. 构造方法：
   • ：使用字符串创建 对象。
   • ：使用指定进制的字符串创建 对象。
2. 数学运算：
   • ：返回两个 对象的和。
   • ：返回两个 对象的差。
   • ：返回两个 对象的积。
   • ：返回两个 对象的商。
   • ：返回两个 对象的模。
   • ：返回 对象的幂。
3. 比较：
   • ：比较两个 对象，返回负数、零或正数。
   • ：判断两个 对象是否相等。
4. 转换：
   • ：将 转换为 。
   • ：将 转换为 。
   • ：返回 的字符串表示形式。
   • ：返回指定进制的字符串表示形式。

   讯享网import java.math.BigInteger; ​ public class BigIntegerExample {    public static void main(String[] args) {        // 使用字符串创建 BigInteger 对象        BigInteger bigInt1 = new BigInteger(“”);        BigInteger bigInt2 = new BigInteger(“”); ​        // 使用指定进制的字符串创建 BigInteger 对象        BigInteger bigInt3 = new BigInteger(“00”, 2); ​        System.out.println(“bigInt1: ” + bigInt1);        System.out.println(“bigInt2: ” + bigInt2);        System.out.println(“bigInt3: ” + bigInt3);   } }

BigDecimal：处理直接用float或者double做运算会出现精度损失的问题

1. 构造方法：
   • ：使用 值创建 对象。
   • ：使用字符串创建 对象。
   • ：使用 创建 对象。
   • ：使用无标度值和标度创建 对象。
2. 数学运算：
   • ：返回两个 对象的和。
   • ：返回两个 对象的差。
   • ：返回两个 对象的积。
   • ：返回两个 对象的商。注意：如果除不尽，会抛出 。
   • ：返回两个 对象的商，并指定结果的小数位数和舍入模式。
   • ：返回两个 对象的余数。
   • ：返回 对象的幂。
3. 比较：
   • ：比较两个 对象，返回负数、零或正数。
   • ：判断两个 对象是否相等。

     

4. 转换：
   • ：将 转换为 。
   • ：将 转换为 。
   • ：将 转换为 。
   • ：将 转换为 。
   • ：返回 的字符串表示形式。
5. 舍入模式：
   • ：四舍五入。
   • ：五舍六入。
   • ：银行家舍入（四舍六入，偶数时五舍六入）。
   • ：向上舍入。
   • ：向下舍入。
   • ：直接舍去多余部分。
   • ：直接进位。

import java.math.BigDecimal; import java.math.RoundingMode; ​ public class BigDecimalMathExample {    public static void main(String[] args) {        BigDecimal bigDecimal1 = new BigDecimal(“.”);        BigDecimal bigDecimal2 = new BigDecimal(“.”); ​        // 加法        BigDecimal sum = bigDecimal1.add(bigDecimal2);        System.out.println(“Sum: ” + sum); ​        // 减法        BigDecimal difference = bigDecimal1.subtract(bigDecimal2);        System.out.println(“Difference: ” + difference); ​        // 乘法        BigDecimal product = bigDecimal1.multiply(bigDecimal2);        System.out.println(“Product: ” + product); ​        // 除法        BigDecimal quotient = bigDecimal1.divide(bigDecimal2, 10, RoundingMode.HALF_UP);        System.out.println(“Quotient: ” + quotient); ​        // 模运算        BigDecimal remainder = bigDecimal1.remainder(bigDecimal2);        System.out.println(“Remainder: ” + remainder); ​        // 幂运算        BigDecimal power = bigDecimal1.pow(2);        System.out.println(“Power: ” + power);   } }

29.常用API-Date日期类

讯享网 1.概述:表示特定的瞬间,精确到毫秒 2.常识:   a.1000毫秒 = 1秒   b.时间原点:1970年1月1日 0时0分0秒(UNIX系统起始时间),叫做格林威治时间,在0时区上   c.时区:北京位于东八区,一个时区经度差15度,时间相差一个小时,所以北京时间比时间原点所在时区时间差8个小时   d.北京经纬度:东经116 北纬39.56 -> 温带大陆性季风气候   e.赤道   本初子午线(0度经线)     

在 Java 中，日期和时间的处理经历了多个阶段的发展，从最早的 类到后来的 包中的 和 类。

• Date类

  位于java.util包，表示特定瞬间，精确到毫秒。

  特点

  • 表示瞬间：表示从 1970 年 1 月 1 日 00:00:00 UTC 开始的毫秒数。
  • 不可变： 对象是不可变的。
  • 线程安全： 类本身是线程安全的，但相关的格式化工具（如 ）不是线程安全的。

  常用方法

  • ：创建一个表示当前时间的 对象。
  • ：创建一个表示指定毫秒数的 对象。
  • ：返回自 1970 年 1 月 1 日 00:00:00 UTC 以来的毫秒数。
  • ：设置此 对象的时间，以毫秒为单位。

    import java.util.Date; ​ public class DateExample {    public static void main(String[] args) {        // 创建一个表示当前时间的 Date 对象        Date now = new Date();        System.out.println(“Current Date and Time: ” + now); ​        // 获取自 1970 年 1 月 1 日 00:00:00 UTC 以来的毫秒数        long timeInMillis = now.getTime();        System.out.println(“Time in Milliseconds: ” + timeInMillis); ​        // 创建一个表示指定毫秒数的 Date 对象        Date specificDate = new Date(timeInMillis);        System.out.println(“Specific Date and Time: ” + specificDate);   } }

• DateTime类

  存在第三方库Joda-Time中

  特点

  • 丰富的 API：提供了大量的日期和时间处理方法。
  • 不可变： 对象是不可变的。
  • 线程安全： 类是线程安全的。

  常用方法

  • ：创建一个表示当前时间的 对象。
  • ：创建一个表示指定毫秒数的 对象。
  • ：获取年份。
  • ：获取月份。
  • ：获取月份中的天数。
• LocalDate类

  位于java.time包中，用于表示不带时区的日期。它只包含年、月、日。

  特点

  • 表示日期：只包含年、月、日信息。
  • 不可变： 对象是不可变的。
  • 线程安全： 类是线程安全的。

  常用方法

  • ：创建一个表示当前日期的 对象。
  • ：创建一个表示指定日期的 对象。
  • ：获取年份。
  • ：获取月份。
  • ：获取月份中的天数。
• LocalDateTime类

  位于 java.time 包中，用于表示不带时区的日期和时间。它包含年、月、日、小时、分钟和秒信息。

  特点

  • 表示日期和时间：包含年、月、日、小时、分钟和秒信息。
  • 不可变： 对象是不可变的。
  • 线程安全： 类是线程安全的。

  常用方法

  • ：创建一个表示当前日期和时间的 对象。
  • ：创建一个表示指定日期和时间的 对象。
  • ：获取年份。
  • ：获取月份。
  • ：获取月份中的天数。
  • ：获取小时。
  • ：获取分钟。
  • ：获取秒。

格式化选择：SimpleDateFormat 和DateTimeFormatter

• SimpleDateFormat是非线程安全的旧版本。

  讯享网import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; ​ public class SimpleDateFormatExample {    public static void main(String[] args) {        try {            // 创建 SimpleDateFormat 对象并指定格式            SimpleDateFormat formatter = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”); ​            // 当前时间            Date now = new Date();            String formattedDate = formatter.format(now);            System.out.println(“Formatted Date: ” + formattedDate); ​            // 解析字符串为 Date 对象            String dateString = “2023-10-01 12:30:45”;            Date parsedDate = formatter.parse(dateString);            System.out.println(“Parsed Date: ” + parsedDate);       } catch (ParseException e) {            e.printStackTrace();       }   } }

• DateTimeFormatter是线程安全的新版本。

  import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.time.format.DateTimeParseException; ​ public class DateTimeFormatterExample {    public static void main(String[] args) {        try {            // 创建 DateTimeFormatter 对象并指定格式            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”); ​            // 当前日期和时间            LocalDateTime now = LocalDateTime.now();            String formattedDateTime = formatter.format(now);            System.out.println(“Formatted Date and Time: ” + formattedDateTime); ​            // 解析字符串为 LocalDateTime 对象            String dateTimeString = “2023-10-01 12:30:45”;            LocalDateTime parsedDateTime = LocalDateTime.parse(dateTimeString, formatter);            System.out.println(“Parsed Date and Time: ” + parsedDateTime);       } catch (DateTimeParseException e) {            e.printStackTrace();       }   } }

时间的计算：Period和Duration、Plus和Minus

• Period类：用于表示日期间隔，常用于年月日；不可变对象

  常用方法：

  • ：创建一个表示指定年、月、日间隔的 对象。
  • ：创建一个表示指定年数的 对象。
  • ：创建一个表示指定月数的 对象。
  • ：创建一个表示指定天数的 对象。
  • ：返回一个新的 对象，表示加上另一个 后的结果。
  • ：返回一个新的 对象，表示减去另一个 后的结果。

  讯享网import java.time.LocalDate; import java.time.Period; ​ public class PeriodExample {    public static void main(String[] args) {        // 创建一个表示 2 年 3 个月 4 天的 Period 对象        Period period = Period.of(2, 3, 4);        System.out.println(“Period: ” + period); ​        // 创建一个表示当前日期的 LocalDate 对象        LocalDate today = LocalDate.now();        System.out.println(“Today‘s Date: ” + today); ​        // 添加 Period 到当前日期        LocalDate futureDate = today.plus(period);        System.out.println(“Future Date: ” + futureDate); ​        // 减去 Period 从当前日期        LocalDate pastDate = today.minus(period);        System.out.println(“Past Date: ” + pastDate);   } }

• Duration类：表示时间间隔，用于时分秒和纳秒；不可变对象

  常用方法：

  • ：创建一个表示指定天数的 对象。
  • ：创建一个表示指定小时数的 对象。
  • ：创建一个表示指定分钟数的 对象。
  • ：创建一个表示指定秒数的 对象。
  • ：创建一个表示指定纳秒数的 对象。
  • ：返回一个新的 对象，表示加上另一个 后的结果。
  • ：返回一个新的 对象，表示减去另一个 后的结果。

30.常用API-Calendar日历类

特点:

• 抽象类：Calendar是一个抽象类，不能实例化，通过Calendar.getInstance()获取实例对象
• 可变性：可以通过各种方法修改日期和时间
• 丰富的API：设置或者获取年月日时分秒
• 时区支持：可以设置和获取时区信息

常用方法：

1. 获取 实例：
   • ：获取一个默认时区和语言环境的 实例。
   • ：获取指定时区的 实例。
   • ：获取指定语言环境的 实例。
   • ：获取指定时区和语言环境的 实例。
2. 获取和设置日期和时间：
   • ：获取指定字段的值，如年、月、日等。
   • ：设置指定字段的值。
   • ：在指定字段上增加或减少指定的值。
3. 日期和时间的转换：
   • ：将 对象转换为 对象。
   • ：将 对象设置为 对象的日期和时间。
   • ：获取自 1970 年 1 月 1 日 00:00:00 UTC 以来的毫秒数。
   • ：设置自 1970 年 1 月 1 日 00:00:00 UTC 以来的毫秒数。
4. 时区操作：
   • ：获取当前 对象的时区。
   • ：设置当前 对象的时区。

31.常用API-Arrays数组工具类

32.常用API-基本类型和String之间的转换

• 基本类型转换为String
  • 使用
  • 使用 、、、 等
  • 使用+操作符：不推荐，效率低
• String转换为基本类型
  • 每个包装类中都有一个类似的方法: parseXXX