java学习笔记3 -- 异常、多线程、字符串、常用类-CSDN博客

本文链接：https://blog.csdn.net/weixin_45027619/article/details/122721999

1.异常

完整笔记

1.1 概述

1.1.1 定义

程序在运行过程中出现不正常的情况，导致运行终止。

1.1.2 异常分类

在这里插入图片描述

1.2 常见的运行时异常

1.2.1 NullPointerException

引用数据类型变量的值为null，使用变量调用属性或者方法时，出现NullPointerException。

    @Test
    public void testNullPointerException(){
//        空指针异常
        String s = null;
        System.out.println(s.toString());
    }

1.2.2 ArrayIndexOutOfBoundsException

    @Test
    public void testNullPointerException(){
//        数组角标越界异常
        int[] arr = {1,2,3};
        System.out.println(arr[3]);
    }

1.2.3 ClassCastException

一般发生在向下转型时。

    @Test
    public void testClassCaseException(){
        Object o = new Date();
        String s = (String)o;
    }

1.2.4 NumberFormatException

一般发生在将字符串转为包装类时。

    @Test
    public void testNumberFormatException(){
        String s = "abc";
        int i = Integer.parseInt(s);
    }

1.2.5 InputMismatchException

使用Scanner从键盘输入不匹配的类型时。

    @Test
    public void testInputMismatchException(){
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
    }

1.2.6 ArithmeticException

算术异常：除0

1.3 常见的编译时异常

编译时异常：编写代码后，在IDE中会自动标出来，不解决无法运行。

1.4 异常处理机制

1.4.1 抓抛模型

抛：程序在运行过程中出现异常，就会在异常代码处生成异常类的对象，并将此对象抛出，一旦发生异常，其后的代码就不再执行；
异常产生的方式：① 系统自动生成 ② 手动生成异常对象，并throw
抓：可以理解为异常的处理方式。① try-catch-finally ② throws

1.4.2 异常处理机制1：try-catch-finally

try代码块中是可能出现异常的代码，catch中是捕获异常后的处理方法，finally中是必须要执行的代码；
try中出现异常后的代码不再执行，如果有必须要执行的，放到finally中；
catch的形参是异常对象，有String getMessage()和void printStackTrace()方法，表示异常描述信息，开发中常使用printStackTrace()方法；
可以有多个catch语句，一个异常只能被一个catch捕获；
并列catch结构中，父类异常对象不能声明在子类异常对象前面；
在try结构中声明的变量，再出了try结构以后，就不能再被调用；
try-catch-finally可以进行嵌套；
try-catch-finally后面的代码会被执行，因为异常已经被处理了，程序会继续执行。

    @Test
    public void testInputMismatchException(){
        try {
            Scanner sc = new Scanner(System.in);
            int i = sc.nextInt();
        }catch (NumberFormatException e){
            System.out.println(e.getMessage());
        }catch (InputMismatchException e){
            e.printStackTrace();
        }catch(Exception e){
            System.out.println(e.getMessage());
        }finally {
            // 一定会执行的代码
        }
    }

1.4.3 finally的使用

finally是可选的；
finally中的代码一定会被执行，即使catch中又出现异常了，try中有return语句，catch中有return语句等情况；
如果finlly、try、catch中都有return语句，那么只会执行finally中的return语句；
像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。
在try中return执行之前始终会执行finally里面的代码，如果finally里面有return，则数据跟随finally改变并返回，不会再执行try中的return。如果没有return，则原数据不跟随finally里改变的数据改变！
finallly在一些特定情况下是不会执行的。参考文章

	@Test
	public void test2() {
		FileInputStream fis = null;
		try {
			File file = new File("hello1.txt");//文件可能不存在，而出现异常
			fis = new FileInputStream(file);

			int data = fis.read();
			while (data != -1) {
				System.out.print((char) data);
				data = fis.read();
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (fis != null)
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

1.4.4 编译时异常和运行时异常的不同处理

编译时异常使用try-catch-finally处理，使得其编译过程中不会报错，但是运行过程中仍可能会报错，相当于将编译时可能出现的异常延迟到运行时；有些语句本身就存在异常，是因为源码中的方法使用了throws声明了异常，我们必须要处理才能编译成功(例如FileInputStream的创建)
开发中，运行时异常通常不需要try-catch-finally处理，因为有默认的处理方式；但是编译时异常一定要处理，不处理就无法运行。(可见1.6)

1.4.5 异常处理机制2：throws + 异常类型

格式：访问修饰符返回值类型方法名(形参) throws 异常类1，异常类2，…{ }

throws将当前方法中的异常抛给调用者，如果调用者不处理，仍然会有异常；
throws并没有真正解决异常，try-catch-finally才是真正把异常解决了；
对于编译时异常如果不使用try-catch-finally处理，那么必须throws给调用者；
异常后的代码不再执行；
子类重写方法抛出的异常不能大于父类被重写方法抛出的异常，因为在多态情况下，我们对异常进行try-catch-finally处理，是以父类为准；

1.5 开发中如何选择异常处理方式

1.如果父类中被重写的方法没有使用throws抛异常，而子类重写的方法有异常，那么只能在子类中使用try-catch-finally处理异常；
2.如果方法a在运行的过程中需要调用方法b，而方法b需要调用方法c，那么方法b、c要使用throws抛出异常，在方法a中使用try-catch-finally处理；

1.6 throw手动抛出异常

一些情况下，我们需要手动抛出异常，比如用户输入不符合规定的范围等等；
throw在方法内部使用，用来抛出一个异常对象，并结束当前方法的执行；
只有异常类的对象才可以throw；

1.6.1 抛出运行时异常

运行时异常，可以不用处理。

    public void test1(int i) {
        if (i < 0) {
            throw new RuntimeException("输入不合规");
        }
    }

Exception in thread "main" java.lang.RuntimeException: 输入不合规
	at Exception.ThrowsTest.test1(ThrowsTest.java:30)
	at Exception.ThrowsTest.main(ThrowsTest.java:21)

1.6.2 抛出编译时异常

编译时异常，要么throws让调用者处理，要么使用try-catch-finally处理；

    public void test1(int i) throws Exception {
        if (i < 0) {
            throw new Exception("输入不合规");
        }
    }

1.7 自定义异常类

要求：
1.继承于现有的异常结构：RuntimeException（运行时）、Exception（运行时+编译时）；
2.提供全局常量：serialVersionUID；
3.提供重载的构造器；
4.自定义的异常通过throw抛出；

public class MyException extends RuntimeException{
    static final long serialVersionUID = 123123213;
    public MyException() {
    }
    public MyException(String msg){
        super(msg);
    }
}

1.8 throw和throws的区别

1.throws是声明异常，throw是抛出异常；
2.throws是处理异常的一种方式，而throw是手动抛出异常；
3.位置不同：throws在方法声明处，后面时异常类名，throw在方法体中，后面是异常对象；
4.throws表示可能会出现异常，而throw一定会抛出一个异常对象；

1.9 总结

在这里插入图片描述

2.项目三

2.1 NameListService

有常量用常量，不用使用具体数据，不然修改很麻烦；
与前端交互的写在view层中，抛出异常的处理逻辑放在service层中；

2.2 TeamService

如果可以不用else，尽量只用if来写，这样代码结构更清晰；
下面第二种写法不对，如果是一名架构师但是人数够了，那么还会去执行下面的else if语句，因为架构师是设计师的子类，所以可能会进入第1个或者第2个else if中，导致程序出错；
instanceOf的使用；

正确的：

        if(p instanceof Architect){
            if(t.getArchitectCount()==1)
                throw new AddException("团队中至多只能有一名架构师");

        }else if (p instanceof Designer){
            if(t.getDesignerCount()==2)
                throw new AddException("团队中至多只能有两名设计师");

        }else if (p instanceof Programmer){
            if(t.getProgrammerCount()==3)
                throw new AddException("团队中至多只能有三名程序员");
        }

错误的:

    if (p instanceof Architect && t.getArchitectCount() == 1) {
            throw new AddException("团队中至多只能有一名架构师");
        } else if (p instanceof Designer && t.getDesignerCount() == 2) {
            throw new AddException("团队中至多只能有两名设计师");
        } else if (p instanceof Programmer && t.getProgrammerCount() == 3) {
            throw new AddException("团队中至多只能有三名程序员");
        }

2.3 继承和多态

在前端页面输出实体类的信息，可以利用继承和多态的特性，重写toString方法，如果其中有不同的信息，可以在父类中提取出一个公共的方法，让所有子类的toString方法调用这个方法，而不用调用父类中的toString方法，也能实现代码复用。输出时，所有父子类对象都只要调用toString即可输出对应的信息，大大降低了代码的冗余。

3.多线程

3.1 概述

3.1.1 程序

为了完成特定任务，使用某种语言编写的一组指令。

3.1.2 进程

正在运行中的程序，是资源分配的最小单位。
生命周期：产生-运行-消亡

3.1.3 线程

进程内部的执行单元，一个进程至少要有一个线程，线程是调度的基本单位。
线程共享进程的堆空间，有自己独立的栈空间。
java程序中至少有三个线程，main方法主线程、垃圾回收线程和异常处理线程。

3.1.4 并行和并发

并行：多个CPU同时执行多个任务。
并发：一个CPU(采用时间片)同时执行多个任务。

3.1.5 使用多线程的优点

提高应用程序的响应，增强用户的体验感。例如：用户可以边听音乐边聊天。
提高计算机系统cpu的利用率。
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。
多线程在单核cpu上反而会降低程序执行的速度，因为线程切换也需要时间开销，但是对多核cpu来说，可以提升程序运行的速度。

3.1.6 什么时候使用多线程

需要多个任务同时执行的时候；
程序需要一些等待的任务，如用户输入、文件读写操作、网络操作等；
需要一些后台运行的程序；

3.2 创建线程方式1

3.2.1 步骤

创建Thread的子类；
重写run()方法；
实例化子类对象；
调用子类对象的start()方法启动线程；

3.2.2 start方法的作用

启动当前线程；
调用当前线程重写的run()方法，并不会立即执行，只是进入了就绪态，具体什么时候执行取决于cpu；

3.2.3 细节

如果直接调用run()方法，那么不会开启新线程，还是在当前线程中执行；
一个线程对象只能调用一次start()方法，启动一个新线程，如果多次调用，会出现java.lang.IllegalThreadStateException异常；

3.2.4 实例

public class ThreadTest extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(i);
        }
    }
}

class Test {
    public static void main(String[] args) {
        ThreadTest t1 = new ThreadTest();
        t1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("-------------------------");
        }
    }
}

3.2.5 Thread匿名子类

new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0)
                        System.out.println(Thread.currentThread().getName() + "," + i);
                }
            }
        }.start();

3.2 创建线程方式2

3.2.1 步骤

创建类来实现Runnable接口；
重写run()方法；
创建Thread对象，将实现类作为构造器的形参放进去；
使用Thread对象调用start()方法开启线程；

3.2.2 实例

class RunnableTest implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

class Test {
    public static void main(String[] args) {
        RunnableTest r = new RunnableTest();
        Thread t = new Thread(r, "线程1");
        t.start();
        }
  }

3.2.3 Runnable匿名内部类

   new Thread(new Runnable(){
       @Override
       public void run() {
           System.out.println(1);
       }
   },"线程1").start();

3.2.4 细节

因为不是继承的Thread类，所以调用Thread中的方法时，需要使用类名或者对象。

3.3 线程相关的方法

3.3.1 start() —见上面

3.3.2 run()

线程在被调度时执行的操作

3.3.3 static Thread currentThread()

表示当前正在执行中的线程

3.3.4 getName()

获取当前线程的名称

3.3.5 setName(String name)

设置当前线程的名称

3.3.6 static void yield() --线程让步

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
让步不一定会成功，因为并不会阻塞当前线程，当前线程回到就绪态，仍然有可能被cpu执行

3.3.7 join() – 线程的插队

在线程a中调用线程b的join方法，会阻塞线程a，直到线程b执行完毕为止(在另一个线程执行完毕前都不会执行本线程)

3.3.8 static void sleep(long time)

使当前线程进入休眠状态，time以毫秒为单位

3.3.9 boolean isAlive()

判断当前线程是否还存活

3.4 线程的优先级

3.4.1 全局常量

MAX_PRIORITY：最高优先级（10）
MIN_PRIORITY：最低优先级（1）
NORM_PRIORITY：普通优先级（5）
线程的优先级默认为5。

3.4.2 方法

	线程对象.setPriority(Thread.MAX_PRIORITY);设置线程的优先级
	线程对象.setPriority(8); 设置线程的优先级
	线程对象.getPriority(); 获取线程的优先级

3.4.3 细节

优先级高的线程只是被cpu执行的概率更高，而并非一定在低优先级的线程之前执行；

3.5 两种线程创建方式的区别

一般优先使用实现Runnable接口的方式

继承Thread类有单继承的局限，而实现Runnable接口更加灵活；
实现Runnable接口可以更好地满足数据共享的需求；

3.6 线程的生命周期

3.7 线程安全问题

多个线程共享一个数据时，一个线程操作共享数据时被另一个线程抢占了CPU，从而造成了数据不同步的问题。
共享数据：多个线程共同操作的属性。

3.7.1 如何解决

同步代码块
同步方法
Lock锁

3.7.2 上面三种方法的优缺点

优点：解决了线程安全的问题。
缺点：执行同步代码时，相当于是单线程，降低了程序运行的速度。

3.7.3 同步和异步

同步：某个时间段内只能执行一件事，加锁实现同步。
异步：某个时间段内多件事同时执行。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

3.8 同步代码块

3.8.1 格式

同步监视器：可以是任意对象，但使用同一资源的所有线程必须使用同一对象。
操作共享数据的代码不能包含的太多，也不能包含的太少。

synchronized(同步监视器){
	操作共享数据的代码
}

3.8.2 同步代码块处理实现Runnable接口的线程安全问题

对于同步监视器，可以使用当前对象this，因为所有线程都是使用的同一个对象。

class PocketTest1 implements Runnable {
    private int count = 100;
    @Override
    public void run() {
        while (true) {
            synchronized(this){
                if (count > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出1张，还有" + count + "张");
                    count--;
                }else
                    break;
            }
        }
    }
}

3.8.3 同步代码块处理继承Thread类的线程安全问题

对于同步监视器，不能使用this，可以使用静态对象，也可以使用当前类(类名.class)。

class PocketTest extends Thread {
    private static int count = 100;
    public static Object o = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized(o){
            synchronized(PocketTest.class){
                if (count > 0) {
                    System.out.println(getName() + "卖出1张，还有" + --count + "张");
                } else
                    break;
            }
        }
    }

    public PocketTest(String name) {
        super(name);
    }
}

3.9 同步方法

3.9.1 格式

同步方法中也有同步监视器，只是不用显示声明。
非静态方法的同步监视器是this，静态方法的同步监视器是类(类名.class)

    public synchronized static SingleTon getSingleTon() {
        if (singleTon == null) {
            singleTon = new SingleTon();
        }
        return singleTon;
    }

3.9.2 同步方法处理实现Runnable接口的线程安全问题

非静态方法的同步监视器是this，静态方法的同步监视器是类

class PocketTest1 implements Runnable {
    private int count = 1000;
    @Override
    public void run() {
        while (true) {
            test();
        }
    }
    public synchronized void test(){
        if (count > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出1张，还有" + count + "张");
                count--;
            }
    }
}

3.9.3 同步方法处理继承Thread类的线程安全问题

必须将同步方法声明为static，本类对象才能共用一个同步监视器

class PocketTest extends Thread {
    private static int count = 1000;

    @Override
    public void run() {
        while (true) {
            test();
        }
    }
    public synchronized static void test(){
        if (count > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出1张，还有" + count + "张");
            count--;
        }
    }
    public PocketTest(String name) {
        super(name);
    }
}

3.10 线程安全的懒汉式单例模式

方式1：同步方法

public class SingleTon {
    private SingleTon() {

    }

    private static SingleTon singleTon;

    public synchronized static SingleTon getSingleTon() {
        if (singleTon == null) {
            singleTon = new SingleTon();
        }
        return singleTon;
    }

}

方式2：同步代码块

public class SingleTon {
    private SingleTon() {

    }

    private static SingleTon singleTon;
        public static SingleTon getSingleTon(){
            synchronized (SingleTon.class){
                if (singleTon == null) {
                singleTon = new SingleTon();
                }
                return singleTon;
            }
        }
}

方式3：效率更高的同步代码块

public class SingleTon {
    private SingleTon() {

    }

    private static SingleTon singleTon;
        public static SingleTon getSingleTon(){
            if (singleTon == null) {
                synchronized (SingleTon.class){
                    if (singleTon == null) {
                        singleTon = new SingleTon();
                    }
                }
            }
            return singleTon;
        }
}

3.11 释放锁的操作

同步代码块和同步方法执行完毕；
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致线程结束；
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁；
当前线程在同步代码块、同步方法中出现了return或break语句终止了该代码块或方法的执行；

3.12 不会释放锁的操作

当前线程在同步代码块、同步方法中调用yield()、sleep()方法，不会释放锁；
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）；

3.13 线程的死锁

3.13.1 定义

不同线程占用对方所需的资源而不放弃，都在等待对方放弃自己所需的资源，从而形成了死锁。

3.13.2 解决方法

专门的算法
避免使用同步资源
避免嵌套同步

3.14 Lock锁

如果同步代码有异常，一定要将unlock()方法放在finally代码块中；

class PocketTest1 implements Runnable {
    private int count = 100;
//    1.创建ReentrantLock对象
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
//                2.上锁
                lock.lock();
                if (count > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出1张，还有" + --count + "张");
                }else{
                    break;
                }
            } finally {
//                3.解锁
                lock.unlock();
            }
        }
    }
}

3.15 synchronized和Lock的异同

相同点：都可以解决线程安全问题
不同点：synchronized执行完相应的同步代码后，自动释放同步监视器；Lock需要手动上锁和解锁。

3.16 线程通信

3.16.1 三个方法

wait():阻塞当前线程并且释放同步监视器；
notify():唤醒一个被wait()的线程，如果有多个线程，具体唤醒顺序由jvm决定详解；
notifyAll():唤醒所有被wait()的线程；

3.16.2 细节

wait(),notify(),notifyAll() 只能在同步代码块或同步方法中使用，不能用在Lock中；
三个方法都要使用同步监视器调用；
三个方法都是java.lang.Object中的方法；

3.16.3 sleep()和wait()的异同

相同点：都可以使线程进入阻塞状态；
不同点：1.在同步代码块或者同步方法中调用sleep()不会释放同步监视器，而调用wait()会释放同步监视器；
2.声明位置不同：sleep是Thread中的静态方法，wait是Object中的方法；
3.调用位置不同：sleep可以在多线程的任意场景中调用，wait只能在同步代码块或同步方法中调用；

3.17 生产者消费者问题

/**
 * @Description: 生产者消费者问题
 * @author:zhou
 * @create: 2022-02-04 15:54
 */
class ProduceTest{
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        new Thread(new Producer(clerk),"生产者1").start();
        new Thread(new Customer(clerk),"消费者1").start();
        new Thread(new Customer(clerk),"消费者2").start();
    }
}

public class Producer implements Runnable {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.product();
        }
    }
}

class Customer implements Runnable {
    private Clerk clerk;

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.custome();
        }
    }
}

class Clerk {
    private int count = 0;

    public void product() {
            synchronized (this) {
                if (count < 20) {
                    count++;
                    System.out.println(Thread.currentThread().getName() + "生产了第" + count + "件产品");
                    notify();
                } else {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    }

    public void custome() {
        synchronized (this) {
            if (count > 0) {
                System.out.println(Thread.currentThread().getName() + "消费了第" + count + "件产品");
                count--;
                notify();
            }else {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.18 创建线程方式3

3.18.1 步骤

创建Callable接口的实现类；
重写Callable中的call()方法；
创建实现类的对象；
将实现类对象作为FutureTask的构造器参数，创建FutureTask对象；
将FutureTask对象作为Thread的构造器参数，创建新线程，并调用start方法开启线程(FutureTask实现了Runnable接口)；
调用FutureTask对象的get()方法获取call()方法中的返回值；

3.18.2 实现Callable接口比实现Runnable接口的有什么强大之处？

call()方法有返回值；
call()方法可以抛出异常；
Callable支持泛型；

3.18.3 实例

public class CallableTest implements Callable {
//    重写call()方法
    @Override
    public Object call() throws Exception {
        System.out.println(":12312");
        return null;
    }
}
class Test3{
    public static void main(String[] args) {
//        创建Callable实现类对象
        CallableTest callableTest = new CallableTest();
//        创建FutureTask对象
        FutureTask future = new FutureTask(callableTest);
//        创建并启动线程
        new Thread(future,"Thread-1").start();
        try {
//            获取call()方法的返回值
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

3.19 创建线程方式4：线程池

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。（开发中优先使用这种方法）

3.19.1 优点

不需要频繁创建销毁线程，减少了系统开销；
提高了响应速度；（减少了创建新线程的时间）
便于线程的管理；

3.19.2 步骤

创建线程池；
创建要提交的线程任务；
提交并执行任务；
关闭线程池；

3.19.3 实例

public class ThreadPool {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        1. 创建线程池对象
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
//        设置线程池的属性
        threadPoolExecutor.setCorePoolSize(5);
        threadPoolExecutor.setMaximumPoolSize(10);
//        2. 创建线程任务
        RunnableTest1 runnableTest1 = new RunnableTest1();
        CallableTest1 callableTest = new CallableTest1();
//        3.提交并执行任务
//        submit适用于实现Runnable接口和实现Callable接口的线程
//        返回Future对象，可以调用get()方法的到call()方法的返回值
        Future submit = executorService.submit(callableTest);
        System.out.println(submit.get());
        executorService.submit(runnableTest1);

//        execute只适用于实现Runnable接口的线程
        executorService.execute(runnableTest1);
//        4.关闭线程池
        executorService.shutdown();
    }
}
class RunnableTest1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}
class CallableTest1 implements Callable {

    @Override
    public Object call() throws Exception {
        for (int i = 100; i > 0; i--) {
            System.out.println(i);
        }
        return null;
    }
}

2.30 坦克大战的多线程要点

2.30.1 什么情况下使用多线程

需要多个任务同时执行的时候。例如我方坦克需要键盘控制移动，而发射的子弹需要按一定速度移动，要求两者可以同时移动，所以需要创建一个线程用于子弹位置的计算。

2.30.2 什么情况下启动线程

一般是在创建Runnable实现类的同时启动线程。
在这里插入图片描述

2.30.3 什么情况下结束线程

当不满足条件时，关闭线程。例如子弹位置超出画布边界或者敌方坦克被击毁。

2.30.4 线程中static void sleep()的使用

为了显示动态效果，一般在操作后需要使用sleep方法休眠一段时间，以便将当前的状态绘制出来。
在这里插入图片描述

4. String字符串

4.1 概述

4.1.1 字符串的创建方式

字面量直接创建：String s1 = "abc";
通过new创建：String s2 = new String("abc");

通过字面量创建的字符串的内容位于常量池中，并且常量池中不能存在相同内容的字符串；
通过new创建的字符串会在堆中开辟空间，变量指向堆中内存地址，而字符串的内容也是存放在常量池中；

4.1.2 细节

String被声明为final的，不可以被继承；
String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小；
String内部定义了final char[] value 数组，用于存放字符串数据；
String不可以通过对象[index]的形式获取；
字符串比较内容使用的是equals();

4.1.3 两种创建方式的区别

字符串常量存储在字符串常量池，目的是共享；
字符串非常量对象存储在堆中；

       String s1 = "abc";
       String s2 = "abc";
       String s3 = new String("abc");
       String s4 = new String("abc");
        System.out.println(s1==s2); // true
        System.out.println(s1==s3); // false
        System.out.println(s4==s3); // false

4.1.4 String遍历

通过charAt方法获取str的各位字符

        String str = "abcd";
        for (int i = 0; i < str.length(); i++) {
            System.out.println(str.charAt(i));
        }

4.2 String的不可变性

如果String变量重新赋值，那么不会更改现有的字符串内容，而是重新指定内存区域赋值；
对现有的字符串进行连接操作时，也需要重新指定内存区域赋值；
调用字符串的replace()方法修改字符或者字符串时，也需要重新指定内存区域赋值；

4.3 String拼接

4.3.1 细节

常量与常量的拼接结果在常量池中，常量池中只会存在拼接的结果，且常量池中不会存在相同内容的常量；(final修饰的也是常量)
只要其中一个是变量，结果就在堆中；
如果拼接的结果调用intern()方法，返回值就在常量池中；

4.3.2 面试题–比较

     String s1 = "hello";
     String s2 = "world";
     String s3 = "helloworld";
     String s4 = "hello" + "world";
     String s5 = new String("hello") + "world";
     String s6 = s1 + "world";
     String s7 = s1 + s2;
     System.out.println(s3 == s4); //true
     System.out.println(s3 == s5); //false
     System.out.println(s3 == s6); //false
     System.out.println(s3 == s7); //false
     System.out.println(s3 == s7.intern()); //true
	 System.out.println(s3 == s5.intern()); //true
     s1 += "world";
     System.out.println(s1 == s3); //false
     System.out.println(s1.intern() == s3); //true

	final String s8 = "hello";
	String s9 = s8 + "world";
	 System.out.println(s9 == s3); //true

4.3.3 面试题–产生对象的个数

以下创建对象的个数都是基于常量池不存在创建的字符串情况下：

String s1 = "a"; 创建了1个对象
说明：在字符串常量池中创建了一个字面量为"a"的字符串。
s1 = s1 + "b"; 创建了两个对象：堆中和常量池各一个，相当于s1 = new String("ab")
说明：实际上原来的“a”字符串对象已经丢弃了，现在在堆空间中产生了一个字符串对象s1+“b”（也就是"ab")。
如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。
如果这样的操作放到循环中，会极大影响程序的性能。
String s2 = "ab"; 创建了1个对象
说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。
String s3 = "a" + "b"; 创建了1个对象，等价于String s2 = "ab";
说明：编译阶段会直接将“a”和“b”结合成“ab”，这时如果字符串常量池已存在“ab”，则将s3的引用指向该字符串，如不存在，则在方法区中生成字符串“ab”对象，然后再将s3的引用指向该字符串，并不会创建a和b字符串。
String s4 = s1.intern();
说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。
我觉得是4个对象

4.4 面试题

虽然String是引用数据类型，参数传递的是地址值，但是由于字符串的不可变性，会在内存中重新开辟空间存放"test ok"并赋值给局部变量str，而属性str的值并没有改变；
字符数组也是引用数据类型，但是其内容是可变的，所以字符数组的值会改变。

public class StringTest {
	String str = new String("good");
	char[] ch = { 't', 'e', 's', 't' };
	public void change(String str, char ch[]) {
		str = "test ok";
		ch[0] = 'b'; 
		}
	public static void main(String[] args) {
		StringTest ex = new StringTest();
		ex.change(ex.str, ex.ch);
		System.out.print(ex.str); //good
		System.out.println(ex.ch); //best
} }

4.5 String常用方法

4.5.1 trim()

去除字符串的首尾空格，中间的不管。

4.5.2 int compareTo(String anotherString) – 涉及字符串的排序

比较两个字符串的大小：逐位比较，如果对应位置的字符不同，返回字符的差值；如果对应位置字符都相同，返回字符串长度的差值。

        String s1 = "abcddsfaf";
        String s2 = "abc";
        System.out.println(s1.compareTo(s2)); // 6
        String s3 = "dbcdds";
        String s4 = "abcaa";
        System.out.println(s3.compareTo(s4)); // 3

4.5.3 String substring(int beginIndex)

从指定索引处开始截取字符串直至末尾。

4.5.4 String substring(int beginIndex，int endIndex) 前闭后开

此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

4.5.5 boolean startsWith(String prefix, int toffset)

判断此字符串从给定的索引处toffset开始的子字符串是否以前缀prifix开始。

        String s3 = "dbcdds";
        System.out.println(s3.startsWith("db")); // true
        System.out.println(s3.startsWith("db",1)); // false

4.5.6 boolean contains(CharSequence s)

判断此字符串中是否包含子串s，s可以传入字符串。
严格区分大小写。

        String s3 = "dbcdds";
        System.out.println(s3.contains("bcd")); //true
        System.out.println(s3.contains("bcD"));//false

4.5.7 int indexOf(String str)

返回str在此字符串中第一次出现的索引，没有返回-1。

4.5.8 int indexOf(String str，int fromIndex)

返回str在此字符串指定索引开始的子串中第一次出现的索引，没有返回-1。

        String s3 = "dbcdds";
        System.out.println(s3.indexOf("d",4)); // 4

判断题：方法IndexOf((char ch,-1)返回字符ch在字符串中最后一次出现的位置。❌
IndexOf只会从前向后查找，不会反向查找。

4.5.9 int lastIndexOf(String str)

返回str在此字符串中最后一次出现的索引，没有返回-1。

什么时候indexOf和lastIndexOf返回值相同？
str在字符串中出现了1次或0次。

4.5.10 int lastIndexOf(String str, int fromIndex)

返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索，没有返回-1。

String s3 = "dbcdds";
System.out.println(s3.lastIndexOf("d",2)); // 0

4.5.11 String replace(char oldChar, char newChar)，String replace(CharSequence target, CharSequence replacement)

字符串的替换：可以替换单个字符，也可以替换字符串。

4.5.12 String replaceAll(String regex, String replacement)

使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

将所有的数字变成逗号，然后去除首位的逗号
  String str = "12hello34world5java7891mysql456";
  为什么需要\\，因为只有一个\是把d给转义了，在前面加一个\表示将第二个\转义成一个普通的字符，所以说\\d表示的就是普通字符\d。
  System.out.println(str.replaceAll("\\d+", ",").replaceAll("^,|,$", ""));//hello,world,java,mysql
  正则表达式中"."表示所有的字符，而"\."表示英文句号，而\在java中表示转义，所以需要用\\将\进行转义。
  String str = ".12.hello34world5java7891mysql456.";
  System.out.println(str.replaceAll("\\.", ","));  //,12,hello34world5java7891mysql456,

4.5.13 String replaceFirst(String regex, String replacement)

使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

4.5.14 boolean matches(String regex)

告知此字符串是否匹配给定的正则表达式。

4.5.15 String[] split(String regex)

根据给定正则表达式的匹配拆分此字符串。

   String str = "hello|world|java";
   String[] str1 = str.split("\\|");
   for (int i = 0; i < str1.length; i++) {
       System.out.println(str1[i]);
   }

hello
world
java

4.5.16 String[] split(String regex, int limit)

根据匹配给定的正则表达式来拆分此字符串，limit影响生成的数组长度，该模式最多应用limit-1次

  String str = "hello|world|java";
  String[] str1 = str.split("\\|",2);
  for (int i = 0; i < str1.length; i++) {
      System.out.println(str1[i]);
  }

hello
world|java

4.6 char[]与String之间的转换

4.6.1 String转为char[]

调用String的toCharArray()

    String s2 = "abc123";
    char[] chars1 = s2.toCharArray();

4.6.2 char[]转为String

使用String的构造器

   char[] chars3 = {'a','b','c'};
    String str = new String(chars3);
    System.out.println(str); // abc

4.7 byte[]与String之间的转换(编码/解码)

编码：String转为byte[]，调用String的getBytes() 。(看得懂 -> 看不懂)
解码：byte[]转为String，使用String的构造器。(看不懂 -> 看得懂)
注意：编码解码使用的字符集要一致，不然会发生乱码。

    public void testByte() throws UnsupportedEncodingException {
        String s1 = "abcdef中国";
//        使用getBytes()无参方法，将使用编辑器的字符集进行编码
        byte[] bytes = s1.getBytes();
//        指定字符集进行编码，解码时也要使用此字符集，不然会产生乱码
//        存在异常，需要处理（try或者throws）
        byte[] gbks = s1.getBytes("gbk");

        String s2 = new String(bytes);
        System.out.println(s2); // abcdef中国 编码解码字符集一致，不会乱码
        String s3 = new String(gbks);
        System.out.println(s3); // abcdef�й�  编码解码字符集不一致，发生乱码
        String s4 = new String(gbks,"gbk");
        System.out.println(s4); // abcdef中国 编码解码字符集一致，不会乱码

    }

4.8 练习–字符串反转

将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为”abfedcg”

双指针同步移动
    public void testReverse() {
        String str = "abcdefg";
        char[] chars = str.toCharArray();
        int start = 0;
        int end = 6;
        for (int i = start, j = end; i < j; i++, j--) {
            char temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        System.out.println(chars);
    }

4.9 练习2-- 查找字符串出现次数

获取一个字符串在另一个字符串中出现的次数。
比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

    public void testIndexOf() {
        String str = "abcabdabeabfbab";
        int count = 0;
        int index = 0;
//        index是从找到的ab索引位置+2
        while ((index = str.indexOf("ab", index)) != -1) {
            index += 2;
            count++;
        }
        System.out.println(count);
    }

4.10 练习3–获取两个字符串中最大相同子串

获取两个字符串中最大相同子串。比如：
str1 = "abcwerthelloyuiodef“;str2 = “cvhellobnm”
提示：将短的那个串进行长度依次递减的子串与较长的串比较。

只存在一个最大相同子串

    public String findSame(String str1, String str2) {
        if (str1 == null || str2 == null)
            return null;
        if (str1.length() == 0 || str2.length() == 0)
            return "";
        String minStr = str1.length() >= str2.length() ? str2 : str1;
        String maxStr = str1.length() < str2.length() ? str2 : str1;
        for (int i = 0; i < minStr.length(); i++) {
            for (int start = 0, end = minStr.length() - i; end <= minStr.length(); start++, end++) {
                String str = minStr.substring(start,end);
                if(maxStr.contains(str)){
                    return str;
                }
            }
        }
        return "";
    }

如果存在多个长度相同的最大相同子串。此时先返回String[]，后面可以用集合中的ArrayList替换，较方便

    public String[] findSame1(String str1, String str2) {
        if (str1 == null || str2 == null)
            return null;
        if (str1.length() == 0 || str2.length() == 0)
            return new String[]{};
        String minStr = str1.length() >= str2.length() ? str2 : str1;
        String maxStr = str1.length() < str2.length() ? str2 : str1;
        StringBuilder s = new StringBuilder();
        // 每一轮减少一个字母，内层循环判断所有的组合是否符合题意
        for (int i = 0; i < minStr.length(); i++) {
            for (int start = 0, end = minStr.length() - i; end <= minStr.length(); start++, end++) {
                String str = minStr.substring(start, end);
                if (maxStr.contains(str)) {
                    s.append(str + ",");
                }
            }
       // 如果存在多个长度相同的最大相同子串，内层for循环可以全部找出来，找出来之后就不用再进行下一轮外层循环了
            if (s.length() > 0)
                break;
        }
        String[] split = s.delete(s.length() - 1, s.length()).toString().split(",");
        return split;
    }

4.11 String、StringBuilder、StringBuffer异同

4.11.1 相同点

底层都是使用字符数组存储

4.11.2 不同点

String是不可变的字符序列；final char value[];
StringBuffer是可变字符序列，线程安全但是效率低；char[] value;
StringBuilder是可变字符序列，jdk1.5新增，线程不安全但效率高；char[] value;
StringBuilder和StringBuffer的最大区别就是线程是否安全；

4.11.3 可变字符序列和不可变字符序列

可变字符序列：修改字符串的内容后不会产生新的对象；
不可变字符序列：修改字符串的内容后会产生新的对象；

4.11.4 三者效率比较

StringBuilder(线程不安全)>StringBuffer(线程安全)>String

4.12 StringBuffer源码分析(StringBuilder类似)

4.12.1 创建对象

//        方式1：底层创建了长度为16的char[]
//        char[] value = new char[16];
        StringBuffer stringBuffer = new StringBuffer();
        System.out.println(stringBuffer.length());
        stringBuffer.append('a'); // value[0] = 'a'
        stringBuffer.append('b'); // value[1] = 'b'
        
//      方式2 底层：char[] value = new char["abc".length + 16];
        StringBuffer stringBuffer1 = new StringBuffer("abc");
        System.out.println(stringBuffer1.length());
        
//      方式3：char[] value = new char[30];
        StringBuffer stringBuffer2 = new StringBuffer(30);

4.12.2 如何实现扩容

如果数组容量满了，会创建一个新的数组，长度一般为原来数组长度的2倍+2，并且将原来数组中的内容复制到新数组中。

4.12.3 使用建议

开发中如果需要频繁对字符串进行添加、修改，那么建议使用StringBuffer(int capacity)和StringBuilder(int capacity)，在创建对象时指定容量，避免后面扩容导致效率低下。

4.13 StringBuffer/StringBuilder类的常用方法

方法链的原理：这些方法虽然都有返回值，但是返回值都是当前对象本身，也就意味着调用这些方法会改变当前对象。

 * StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
 * StringBuffer delete(int start,int end)：删除指定位置的内容
 * StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
 * StringBuffer insert(int offset, xxx)：在指定位置插入xxx
 * StringBuffer reverse() ：把当前字符序列逆转
 * public int indexOf(String str)
 * public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
 * public int length()
 * public char charAt(int n )
 * public void setCharAt(int n ,char ch)

      StringBuffer stringBuffer2 = new StringBuffer(30);
        stringBuffer2.append(-1); // 添加元素
        stringBuffer2.append(2);
        stringBuffer2.append(3);
        stringBuffer2.append(4);
        System.out.println(stringBuffer2);
        stringBuffer2.delete(2,4);  // 删除[2,4)之间的元素
        stringBuffer2.replace(2,4,"hello"); // 将[2,4)之间的元素替换成hello
        stringBuffer2.reverse(); // 反转字符串
        stringBuffer2.insert(2,"c"); // 在索引为2的位置插入c，其他元素向后移
        System.out.println(stringBuffer2);
		stringBuffer2.setCharAt(1,'a'); // 只能替换指定索引处的单个字符

4.13 面试题

        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);
        System.out.println(sb.length());// 4
        System.out.println(sb);// null
        StringBuffer sb1 = new StringBuffer(str);
        System.out.println(sb1);// java.lang.NullPointerException

5.JDK8之前日期时间API

5.1 System类

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
时间戳可以用来充当订单号。

5.2 Date类

5.2.1 java.util.Date

两种构造器：
new Date(); 使用无参构造器创建的对象可以获取本地当前时间。
new Date(long l)；自定义毫秒时刻。

方法：
toString()：输出具体的年月日时分秒
getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数(无参构造器表示到本地当前时间为止的毫秒数，有参构造器表示传入的参数)

5.2.2 java.sql.Date(util.Date的子类)

构造器：
new Date(long l); 自定义毫秒时刻。

方法：
toString(): 输出年月日

5.2.3 两种Date转换

方法1：多态，向下转型

  Date d  = new java.sql.Date(1231221321l);
  java.sql.Date date2 = (java.sql.Date)d;

方法2：构造器传入

Date date = new Date(1234211545142l);
java.sql.Date date1 = new java.sql.Date(date.getTime());

5.3 SimpleDateFormat

5.3.1 作用

因为Date类的API不易于国际化，大部分被废弃了，所以使用SimpleDateFormat对Date类进行格式化和解析。
格式化： Date -> String public String format(Date date)
解析：String -> Date public Date parse(String source)

5.3.2 空参构造器

空参输出默认格式

		Date date3 = new Date();
 		SimpleDateFormat sdf = new SimpleDateFormat();
//        格式化：Date -> String
        String format = sdf.format(date3);
        System.out.println(format);  //22-2-7 下午12:46
//        解析：String -> Date
        try {
            Date d = sdf.parse("22-2-7 下午12:42");
            System.out.println(d); // Mon Feb 07 12:42:00 CST 2022
        } catch (ParseException e) {
            e.printStackTrace();
        }

5.3.3 带参构造器

开发中一般使用这种方式，指定格式化和解析的格式。对字符串进行解析时，参数格式和字符串格式一定要相匹配。

y	年
M	月
d	日
H	时
m	分
s	秒

        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = sdf1.format(date3);
        System.out.println(format1); // 2022-02-07 12:46:51

        try {
            Date d = sdf1.parse(format1);
            System.out.println(d); // Mon Feb 07 12:46:51 CST 2022
        } catch (ParseException e) {
            e.printStackTrace();
        }

5.3.4 练习：将字符串转为java.sql.Date

方式1：

        String str = "2021-09-08";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); 参数的格式要与解析的字符串格式相同
        try {
            Date d = sdf.parse(str);
            java.sql.Date date = new java.sql.Date(d.getTime());
            System.out.println(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }

方式2：

        String str = "2018-01-10";
        java.sql.Date date = java.sql.Date.valueOf(str);
        System.out.println(date);

5.3.5 练习：获取一个人的出生天数

    public void test123() {
        String date1 = "1990-01-01";
        Date d1 = getDate(date1); // 把字符串转为Date
        Date d2 = new Date(); // 获取当前日期
        long l = d2.getTime() - d1.getTime();
        long l1 = l / (24 * 60 * 60 * 1000) + 1;
        System.out.println(l1);
    }
    
    public Date getDate(String str) {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
      Date d = null;
      try {
          d = sdf.parse(str);
      } catch (ParseException e) {
          e.printStackTrace();
      }
      return d;
    }

5.4 Calendar类

Calendar对象具有可变性，具体表现在可以通过set方法直接更改自身的值

5.4.1 创建对象

方式1：调用静态方法getInstance(); Calendar instance = Calendar.getInstance();
方式2：通过子类GregorianCalendar构造器创建对象；

5.4.2 get(int field)

用于获取年份、月份、星期、某年的第几天、某星期的第几天等等。

5.4.3 public void set(int field,int value)

将当前Calendar 对象中的字段设置为给定值。

Calendar instance = Calendar.getInstance();
System.out.println(instance.get(Calendar.YEAR)); // 2022
instance.set(Calendar.YEAR,2011);
System.out.println(instance.get(Calendar.YEAR)); // 2011

5.4.4 public void add(int field,int amount)

在当前基础上进行偏移

        instance.add(Calendar.YEAR,10); // +10年
        System.out.println(instance.get(Calendar.YEAR)); // 2032
        instance.add(Calendar.YEAR,-10); // -10年
        System.out.println(instance.get(Calendar.YEAR)); // 2022

5.4.5 public final Date getTime()

将Calendar对象转为Date对象

Date time = instance.getTime();
System.out.println(time);

5.4.6 public final void setTime(Date date)

将Date对象转为Calendar对象，可以用于获取Date中的年月日

  Date d = new Date();
  instance.setTime(d);
  System.out.println(instance.get(Calendar.YEAR)); // 2022

6.JDK8中新日期时间API

6.1 java.time

6.1.1 几个常用的类(使用和Calendar类似)

LocalDate：本地日期
LocalTime：本地时间
LocalDateTime：本地日期时间(使用频率最高)

6.1.2 now()方法

静态方法，根据当地时间创建对象。

     LocalDateTime now = LocalDateTime.now();
     System.out.println(now); // 2022-02-07T16:17:33.847

6.1.3 of()方法

静态方法，根据指定日期/时间创建对象

   LocalDateTime of = LocalDateTime.of(2010, 10, 31, 10, 10, 10);
   System.out.println(of); // 2010-10-31T10:10:10

6.1.4 getXxx()方法

获取年月日时分秒

        System.out.println(now.getDayOfMonth()); // 7 获得月份天数(1-31)
        System.out.println(now.getDayOfYear()); // 38 获得年份天数(1-366)
        System.out.println(now.getDayOfWeek()); // MONDAY 获得星期几(返回一个 DayOfWeek 枚举值)
        System.out.println(now.getMonth()); // FEBRUARY 获取月份
        System.out.println(now.getMonthValue()); // 2  获取本年的第几个月
        System.out.println(now.getHour()); //获得当前对象对应的小时
        System.out.println(now.getMinute()); // 分钟
        System.out.println(now.getSecond()); // 秒

6.1.5 withXxx()方法

设置年月日时分秒，是不可变的，即调用方法后会返回一个新的变量，原来的值不会改变。
withDayOfMonth()/withDayOfYear()/withMonth()/withYear()

 	LocalDateTime now = LocalDateTime.now();
   LocalDateTime localDateTime = now.withDayOfMonth(28);
   System.out.println(localDateTime.getDayOfMonth()); // 28
   System.out.println(now.getDayOfMonth()); // 7

6.1.6 plusXxx()方法

向当前对象添加几天、几周、几个月、几年、几小时，是不可变的。
plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()

        LocalDateTime localDateTime1 = now.plusDays(5);
        System.out.println(localDateTime1.getDayOfMonth());

6.1.7 minusXxx()方法

向当前对象减少几天、几周、几个月、几年、几小时，是不可变的。

        LocalDateTime localDateTime2 = now.minusDays(6);
        System.out.println(localDateTime2.getDayOfMonth());

6.2 Instant类

6.2.1 作用

与java.lang.Date类似，用于获取毫秒数或通过毫秒数获取对象

6.2.2 实例

//        now:获取本初子午线的时间
        Instant i = Instant.now();
        System.out.println(i);
//        atOffset 添加时间偏移量，获取本地时间
        OffsetDateTime offsetDateTime = i.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);

//        toEpochMilli 获取时间戳，相当于Date类的getTime()方法
        long l = i.toEpochMilli();
        System.out.println(l);
//      ofEpochMilli 通过给定毫秒数获取Instant对象，相当于Date类的有参构造器new Date(long millis)
        Instant instant = i.ofEpochMilli(1644282265743l);
        System.out.println(instant);

6.3 DateTimeFormatter

6.3.1 作用

和SimpleDateFormat类似，对时间进行解析和格式化。

6.3.2 实例

方式3:最重要的一种方法
//        通过静态方法ofPattern创建DateTimeFormatter对象，相当于SimpleDateFormat的有参构造器
        DateTimeFormatter d = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//        格式化
        String format = d.format(LocalDateTime.now());
        System.out.println(format);

//        解析
        TemporalAccessor d1= d.parse(format);
        System.out.println(d1);

  //方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化:日期-->字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);
        System.out.println(str1);//2020-05-10T18:26:40.234

        //解析：字符串 -->日期
        TemporalAccessor parse = formatter.parse("2020-05-10T18:26:40.234");
        System.out.println(parse);

        //方式二：
        //本地化相关的格式。如：ofLocalizedDateTime()
        //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        //格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//2020年5月10日 下午06时26分40秒

        //本地化相关的格式。如：ofLocalizedDate()
        //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
        //格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3);//2020-5-10