尚硅谷

8_多线程

1.程序、线程、进程的理解

01程序

概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态代码

02进程

概念：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有其自身的产生、存在、消亡的过程。——生命周期
说明：进程作为资源分配单位，系统在运行时会为每个进程分配不同的内存区域

03线程

概念：进程可以进一步细分为线程，是程序内部的一条执行路径
说明：线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销小
内存结构：

进程可以细化为多个线程
每个线程拥有自己独立的：栈、程序计数器
多个线程，共享同一个进程中的机构：方法区和堆

并行与并发

01并行和并发的理解

并行：多个cpu同时执行多个任务。比如：多个人同时做不同的事
并发：一个cpu同时执行多个任务

创建多线程的两种方式

方式一：继承Thread类的方式

1.创建一个继承于Thread类的子类
2.重写Thread类中的run()—>将此线程执行的操作声明到run()方法中
3.创建Thread类的子类的对象
4.通过此对象调用start()方法
说明两个问题：
启用一个线程必须调用start方法，不能调用run方法来启动
如果再启动一个线程，必须重新创建一个Thread类的子类的对象，调用此对象的start方法

方式二：实现Runnable接口的方式

1.创建一个实现了Runnable接口的子类
2.在实现类中实现Runnable接口中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.用Thread类的对象来调用start()

两种方式对比：
开发中：优先选择实现Runnable接口的方式
原因：1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个j线程共享数据的情况
联系:public class Thread implements Runnable
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
都需要调用start方法来启动

Thread类中的常用方法

常用方法

1.start():启动当前线程，调用当前线程的run()
2.run():重写Thread类中的run()—>将此线程执行的操作声明到run()方法中
3.currentThread():静态方法，返回执行当前线程的代码的线程
4.getName():获取当前线程的名字
5.setName():设置当前线程的名字
6.yiled():释放当前cpu的执行权
7.join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态直到线程b完全执行完，线程a才结束阻塞状态
8stop():已过时。执行此方法时，强制结束当前线程
9.sleep(Long millitime):让当前线程睡眠，指定millitime毫秒。在指定毫秒下该线程是阻塞状态
10.isAlive():判断当前线程是否存活

线程优先级

MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 默认优先级
设置和获取当前线程的优先级
getPriority():获取当前线程的优先级
setPriority(int p)：设置当前线程的优先级
说明：高优先级要抢占低优先级的线程cpu执行权。但只是从概率上讲

线程通信：wait()/notify()/notifyAll():此三个方法是定义在Object类中
java线程分为：守护线程和用户线程

线程的生命周期

线程同步(解决线程安全问题)

在java中通过同步机制，解决线程安全问题
同步解决了线程安全问题，操作同步代码时，其他线程等待，相当于一个单线程的过程，效率低

解决线程安全问题方式一：同步代码块

synchronized(同步监视器){
//需要被同步的代码
}

实现runnable接口的方法（售票问题）

package day17;
/**
 * @author Lilei
 * @date 2021/11/18-@17:39
 */
public class Window1 implements Runnable{
    private int ticket=100;
    Object object=new Object();
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (object) {//同步监视器可以使用this，因为此时的this是唯一的Window1对象
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
class WindowTest1{
    public static void main(String[] args) {
        Window1 w1= new Window1();
        Thread t1=new Thread(w1);
        Thread t2=new Thread(w1);
        Thread t3=new Thread(w1);
        t1.setName("窗口一：");
        t2.setName("窗口二：");
        t3.setName("窗口三：");
        t1.start();
        t2.start();
        t3.start();
    }
}

继承Thread类

package day18.java;
/**
 * @author Lilei
 * @date 2022/1/7-@18:31
 */
class Window extends Thread{
    private static  int ticket=100;
    private static Object object=new Object();//static保证锁是唯一的
    @Override
    public void run() {
        while (true){
            try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            //synchronized(Window.class) Class class=Window.class,Window.class只会加载一次
            synchronized(object){
                if (ticket>0){
                    System.out.println(getName()+":卖票，票号为："+ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}
public class WindowsTest {
    public static void main(String[] args) {
        Window w1=new Window();
        Window w2=new Window();
        Window w3=new Window();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w3.start();
        w2.start();
    }
}

说明：1.操作共享数据的代码，即需要被同步的代码
2.共享数据：多个线程共同操作的变量
3.同步监视器:俗称：锁。任何一个类的对象都可以充当一个锁
要求多个线程必须用同一把锁

解决线程安全问题方式二：同步方法

如果操作共享数据的完整代码声明在一个方法中，我们可以将此方法声明为同步的。
非静态的同步代码块，同步监视器是this
静态的同步代码块，同步监视器是当前类本身
解决实现Runnable接口的线程安全问题

package day18.java;
/**
 * @author Lilei
 * @date 2022/1/7-@19:04
 *
 *
 * 出现重票错票线程安全问题
 * 问题出现原因：当某个线程操作买票的过程，尚未完成操作时，其他线程参与进来，也操作车票
 * 如何解决：当一个线程在操作共享数据，其他线程不能参与进来，直到线程a操作完成，其他线程才可以造成，即使a阻塞，也不能改变
 *
 */
class Window3 implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    private synchronized void show() {//同步监视器即使this
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号：" + ticket);
            ticket--;
        }
    }
}
public class WindowTest3{
    public static void main(String[] args) {
        Window3 window3=new Window3();
        Thread t1=new Thread(window3);
        Thread t2=new Thread(window3);
        Thread t3=new Thread(window3);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

解决继承Thread类的线程安全问题

package day18.java;
/**
 * @author Lilei
 * @date 2022/1/7-@18:31
 */
class Window2 extends Thread {
    private static int ticket = 100;
    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    private static synchronized void show() {//同步监视器是Window2.class
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w1=new Window2();
        Window2 w2=new Window2();
        Window2 w3=new Window2();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w3.start();
        w2.start();
    }
}

解决单例模式中的线程安全问题

package day18.exe;
/**
 * @author Lilei
 * @date 2022/1/11-@16:35
 */
public class BankTest {
    public static void main(String[] args) {
        Bank bank1=Bank.getInstance();
        Bank bank2=Bank.getInstance();
        System.out.println(bank1==bank2);
    }
}
//懒汉式单例
class Bank{
    private Bank(){}
    private static Bank instance=null;
    public static Bank getInstance(){
        //方式一：效率稍差
//        synchronized (Bank.class){
//            if (instance==null){
//                instance=new Bank();
//            }
//            return instance;
//        }
        //方式二：效率更高
        if (instance==null){
            synchronized (Bank.class){
                if (instance==null){
                    instance=new Bank();
                }
            }
        }
        return instance;
    }
}

线程的死锁问题

不同的线程分别占用对方需要的共享资源不放弃，都在等对方释放自己需要的共享资源，就形成了死锁
出现死锁后，不会出现异常、提示，只是所有线程都在阻塞状态，无法继续

解决线程安全问题方式三：Lock锁—jdk5.0新增

package day18.exe;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @author Lilei
 * @date 2022/1/11-@17:29
 */
class Window implements Runnable{
    private int ticket=100;
//1.实例化ReetrantLock
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try{
                //调用锁方法
                lock.lock();
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":售票，票号："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //调用解锁方法
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w=new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

面试题：synchronized与Lock方式的异同
相同：都可解决线程安全问题
不同：synchronized机制在执行完相应的同步代码后，会自动的释放同步监视器
Lock需要手动的去启动同步（lock.lock()），同时结束也需要手动结束（lock.unlock()）
优先使用顺序：Lock锁—>同步代码块（已经进入方法体，分配了相应资源）—>同步方法（在方法体外面）
面试题：如何解决线程安全问题？有集中方式？
（synchronized）同步代码块 同步方法 Lock锁

线程通信

例子：使用两个线程打印1-100

package day18.exe;
/**
 * @author Lilei
 * @date 2022/1/11-@21:55
 */
public class CommunicationTest {
    public static void main(String[] args) {
        Number num = new Number();
        Thread t1 = new Thread(num);
        Thread t2 = new Thread(num);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}
class Number implements Runnable{
    private int number=1;
    @Override
    public void run() {
        while (true) {
            synchronized(this){
                notifyAll();
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        //调用wait方法使线程进入阻塞，可以释放同步监视器
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

涉及到三个方法：
wait():一旦执行此方法，当前线程就会进入阻塞状态，并释放同步监视器
notify():一旦执行此方法，就会唤醒一个被wait的线程
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程
说明：1.只能出现在同步代码块或者同步方法中
2.调用者必须是同步代码块或同步方法中的同步监视器
3.三个方法定义在java.long.Object类中。

面试题：sleep()和wait()的异同
相同点：一旦执行方法，都可以使当前线程进入阻塞状态。
不同点：1.两个方法声明的位置不同Threa()类中声明sleep()，Object类中声明wait()
2.调用的范围要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步方法或同步代码块中。
3.关于是否是否同步监视器：如果两个方法都写在同步代码块或同步方法中，sleep方法不会释放同步监视器，wait方法会释放同步监视器

JDK5.0新增创建线程方式

方式一：实现Callable接口

与Runnable相比，Callable功能更强大一些
1.相比run()方法，可以有返回值
2.方法可以抛出异常
3.支持泛型的返回值
4.需要借助FutureTask类，比如获取返回值结果

package day18.java;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * @author Lilei
 * @date 2022/1/25-@21:09
 */
//1.创建一个实现Callable接口的实现类
class NumThread implements Callable{
    //2.实现call方法，将需要执行的操作写在此方法中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 1; i <100 ; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建callable接口实现类的对象
        NumThread numThread=new NumThread();
        //4.将此callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取Callable中call方法的返回值
          Object sum=futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式二：使用线程池

好处：1.提高响应速度（减少线程创建时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于管理
corePoolSize：核心池大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间会终止

9常用类

字符串相关类

String

String类：代表字符串，字符串是常量用双引号引起来表示
String实现了Serializable接口：表示字符串是支持序列化的
实现了Comparable接口：表示String可比较大小
String对象的字符内容是存储在一个字符数组value[]中 fianl char[] value
String类是一个final类，代表不可变的字符序列，不可被继承
体现：当对字符串重新赋值，需要重新指定内存区域，不能使用原有的value赋值
当对现有字符串进行连接操作时，也需要重新指定内存区域赋值
当调用String的replace方法修改指定字符或字符串时，也需要重新指定内存区域赋值
通过字面量的方式给一个字符串赋值，此时的字符串值声明在字符串常量池中
常量池中不会存放相同内容的字符串

String实例化的方式

方式一：通过字面量定义的方式
方式二：通过new+构造器的方式

    @Test
    public void test(){
        String s1="javaee";
        String s2="hadoop";
        String s3="javaeehadoop";
        String s4="javaee"+"hadoop";
        String s5=s1+"hadoop";
        String s6="javaee"+s2;
        String s7=s1+s2;
        String s8=s5.intern();//返回值得到的s8使用的是常量池中已经存在的"javaeehadoop"
        System.out.println(s3==s4);//true
        System.out.println(s3==s5);//false
        System.out.println(s3==s6);//false
        System.out.println(s3==s6);//false
        System.out.println(s3==s7);//false
        System.out.println(s5==s6);//false
        System.out.println(s5==s7);//false
        System.out.println(s6==s7);//false
        System.out.println(s3==s8);//true
    }

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

String的常用方法1

int length():返回字符串长度：return value.length
char charAt(int index):返回某索引处的字符 return value[index]
boolean isEmpty():判断是否是空字符串：return value.length==0
String toLowerCase():使用默认语言环境，将String中的所有字符转换为小写
String toUpperCase():使用默认语言环境，将String中的所有字符转换为大写
String trim():返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString):与equals方法类似，忽略大小写
String concat(String str):将指定字符串连接到此字符串结尾，等价于用“+”
int compareTo(String anotherString):比较两个字符串大小
String substring(int beginIndex):返回一个新字符串，他是此字符串的从beginIndex开始截取
String substring(int beginIndex，int endIndex):返回一个新字符串，他是此字符串的从beginIndex到endIndex（不包含）截取

    @Test
    public  void test2(){
        /*
    int length():返回字符串长度：return value.length
    char charAt(int index):返回某索引处的字符 return value[index]
    boolean isEmpty():判断是否是空字符串：return value.length==0
    String toLowerCase():使用默认语言环境，将String中的所有字符转换为小写
    String toUpperCase():使用默认语言环境，将String中的所有字符转换为大写
    String trim():返回字符串的副本，忽略前导空白和尾部空白
    boolean equals(Object obj):比较字符串的内容是否相同
    boolean equalsIgnoreCase(String anotherString):与equals方法类似，忽略大小写
    String concat(String str):将指定字符串连接到此字符串结尾，等价于用“+”
    int compareTo(String anotherString):比较两个字符串大小
    String substring(int beginIndex):返回一个新字符串，他是此字符串的从beginIndex开始截取
    String substring(int beginIndex，int endIndex):返回一个新字符串，他是此字符串的从beginIndex到endIndex(不包含)截取
         */
        String s1="Helloworld";
        String s2="helloworld";
        System.out.println(s1.length());
        System.out.println(s1.charAt(5));
        System.out.println(s1.isEmpty());
        System.out.println(s1.toUpperCase());
        System.out.println(s1.toLowerCase());
        String s3="   he  l  o wo rld   ";
        String s4 = s3.trim();//去除首尾空格
        System.out.println(s3);
        System.out.println(s4);
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));
        String s5="abc";
        String s6=s1.concat(s5);
        System.out.println(s6);
        String s7="abd";
        System.out.println(s5.compareTo(s7));
        String s8=s1.substring(3);
        System.out.println(s8);
        String s9=s1.substring(3,6);
        System.out.println(s9);
    }

String的常用方法2

boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix，int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时，返回true
int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str，int formIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str，int formIndex):返回指定子字符串在此字符串中最右边出现处的索引，从指定的索引开始
indexOf和lastIndexOf方法如果未找到都返回-1

    public void test3(){
         /*
         boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
         boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
         boolean startsWith(String prefix，int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
          */
        String str1="helloworld";
        System.out.println(str1.endsWith("ld"));
        System.out.println(str1.startsWith("he"));
        System.out.println(str1.startsWith("ll", 2));
              String str2="wo";
        System.out.println(str1.contains(str2));
        System.out.println(str1.indexOf(str2));
        System.out.println(str1.indexOf(str2,6));
    }

什么情况下，indexOf（str）和lastIndexOf（str）返回值相同？
情况一：只存在一个str 情况二：不存在str

String的常用方法3

 替换：<br />String replace(char oldChar, char newChar):返回一个新的字符串它是通过用newChar替换此字符串中出现的所有oldChar得到的。<br />String replace(CharSequence target,CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。<br />String replaceAll(String regex，String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。<br />String replaceFirst(String regex，String replacement):使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。<br />string split(String regex):根据给定正则表达式的匹配拆分此字符串<br />匹配：<br />boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。<br />切片：<br />string split(String regex):根据给定正则表达式的匹配拆分此字符串<br />Stringl split(String regex， int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

    @Test
    public void test4(){
        /*
        替换：
   String replace(char oldChar, char newChar):返回一个新的字符串它是通过用newChar替换此字符串中出现的所有oldChar得到的。
   String replace(CharSequence target,CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
   String replaceAll(String regex，String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。
   String replaceFirst(String regex，String replacement):使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。
   string split(String regex):根据给定正则表达式的匹配拆分此字符串
   匹配：
   boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。
   切片：
   string split(String regex):根据给定正则表达式的匹配拆分此字符串
   Stringl split(String regex， int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
         */
        String str1="甘肃某某某";
        String str2 = str1.replace('某', '谋');
        System.out.println(str1);
        System.out.println(str2);
        String str3 = str1.replace("甘肃", "天津");
        System.out.println(str3);
        String str4="123java456mysql78web9";
        //把字符串数字替换为逗号，并且结果开头或结尾有逗号要去掉
        String str5 = str4.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        System.out.println(str5);
        String str6="123456";
        //判断字符串是不是全部由数字组成
        System.out.println(str6.matches("\\d+"));
        String str7="0571-4534289";
        //判断是否为一个杭州的固定电话
        System.out.println(str7.matches("0571-\\d{7,8}"));
        String str8="hello|world|java";
        String [] strs=str8.split("\\|");
        for (int i = 0; i <strs.length; i++) {
            System.out.println(strs[i]);
        }
        String str9="hello.world.java";
        String [] strings=str9.split("\\.",2);
        for (int i = 0; i <strings.length ; i++) {
            System.out.println(strings[i]);
        }
    }

String与基本数据类型、包装类之间的转换

String—->基本数据类型、包装类：调用包装类的静态方法：parseXxx（str）
基本数据类型、包装类—->String：调用Sting承载的valueOf（xxx）方法

    @Test
    public void test5(){
        String s1="123";
        int i = Integer.parseInt(s1);
        String str2 = String.valueOf(i);
    }

String与char[]之间的转换

String—->char[]:调用String的toCharArray()
char[]—->String:调用String的构造器

  @Test
    public void test6() {
        String str1 = "abc123";
        char[] chars = str1.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
        char[] chars1= new char[]{'h', 'e', 'l', 'l', 'o'};
        String string = new String(chars1);
        System.out.println(string);
    }

String和byte[]之间的转换

string—->byte[]:调用String的getBytes()
byte[]——->String :调用String的构造器
编码：字符串—->字节（看得懂—->看不懂的二级制数据）
解码：字节—->字符串（看不懂的二进制—->看得懂）
说明：解码时，要求解码使用的字符集必须与编码使用的字符集相同，否则会出现乱码

    @Test
    public void test7() throws UnsupportedEncodingException {
         String str1="abc123中国";
         byte[] bytes=str1.getBytes();
        System.out.println(Arrays.toString(bytes));//使用默认字符集转换
        byte[] gbks= new byte[0];
        try {
            gbks = str1.getBytes("gbk");//使用gbk字符集转换
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println(Arrays.toString(gbks));
        String str2=new String(bytes);//使用默认字符集解码
        System.out.println(str2);
        String str3=new String(gbks);//出现乱码。原因：编码集和解码集不一致
        System.out.println(str3);
        String str4=new String(gbks,"gbk");
        System.out.println(str4);
    }

StringBuffer和StringBuilder

String、StringBuffer、StringBuilder的异同

String:不可变的字符序列；底层使用char[]存储
StringBuffer：可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder：可变的字符序列；jdk5.0新增，线程不安全的，效率高；底层使用char[]存储

源码分析：

String str=new String();//new char [0];
String str1=new String(“abc”);new char[]{‘a’,’b’,’c’}
StringBuffer sbq1=new StringBuffer();//new char[16];底层创建了一个长度为16的数组
sb1.append(‘a’);//value[0]=’a’;
sb1.append(‘b’);//value[1]=’b’;
StringBuffer sb2=new StringBuffer(“abc”);//char[] value=new char[“abc”.length+16]
//问题一：SYstem.out.println(sb2.length);//3
//问题二：扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组
默认情况下扩容为原来的2倍+2，同时将原有数组中的元素复制到新的数组中
指导意义：开发中建议使用：StringBuffer(int capacity)或StringBuilder(int capacity)

StringBuffer的常用方法:

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):修改指定位置字符
总结：增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch);repLace(int start, int end，string str);
查：charAt(int n )
插：insert(int offset, xxx)
长度：length()
遍历：for（）+charAt

    @Test
    public void test(){
        StringBuffer s1=new StringBuffer("abc");
        s1.append("1");
        s1.append(1);
        System.out.println(s1);
//        s1.delete(2,4);
//        s1.replace(2,4,"hello");
//        s1.insert(2,"false");
//        s1.reverse();
        String s2=s1.substring(1,3);
        System.out.println(s2);
    }

String、StringBuffer、StringBuilder三者效率对比
StringBuilder>StringBuffer>String

常见算法题目

1.模拟一个trim方法，去除字符串两端的空格

2.将一个字符串进行反转。将字符串指定部分反转。

public class StringDemo {
    //方法一：先转换为char[]
    public String reverse(String str,int startIndex,int endIndex){
        if (str!=null){
            char[] arr = str.toCharArray();
            for (int x=startIndex,y=endIndex;x<y;x++,y--){
                char temp=arr[x];
                arr[x]=arr[y];
                arr[y]=temp;
            }
            return new String(arr);
        }
        return null;
    }
    //方法二：String的拼接操作
    public String reverse1(String str,int startIndex,int endIndex){
        if (str!=null){
            String reverseStr=str.substring(0,startIndex);
            for (int i=endIndex;i>=startIndex;i--){
                reverseStr+=str.charAt(i);
            }
            reverseStr+=str.substring(endIndex+1);
            return reverseStr;
        }
        return null;
    }
        //方法三：使用StringBuffer、StringBuilder替换String
    public String reverse2(String str,int startIndex,int endIndex){
        if (str!=null){
            StringBuilder builder=new StringBuilder(str.length());
            builder.append(str.substring(0,startIndex));
            for (int i=endIndex;i>=startIndex;i--){
                builder.append(str.charAt(i));
            }
            builder.append(str.substring(endIndex+1));
            return builder.toString();
        }
        return null;
    }
    @Test
    public void test(){
         String s="abcdefg";
         String reverse=reverse1(s,2,5);
        System.out.println(reverse);
    }
}

3.获取一个字符串在另一个字符串中的次数

public class StringDemo1 {
    /*
    获取一个字符串在另一个字符串中的字数
    如“ab"在"abkkcadkabfkabkskab"
     */
    /**
      获取sunStr在mainStr中出现的次数
     * @param mainStr
     * @param subStr
     * @return
     */
    public int getCount(String mainStr,String subStr){
        int mainLength=mainStr.length();
        int subLength=subStr.length();
        int count=0;
        int index=0;
        if (mainLength>=subLength){
            //方法一：
//           while ((index=mainStr.indexOf(subStr))!=-1){
//                count++;
//                mainStr=mainStr.substring(index+subStr.length());
//            }
            //方法二：
            while ((index=mainStr.indexOf(subStr,index))!=-1){
                count++;
                index+=subLength;
            }
            return count;
        }else {
            return 0;
        }
    }
    @Test
    public void test(){
        String mainStr="abkkcadkabfkabkskab";
        String subStr="ab";
        int count = getCount(mainStr, subStr);
        System.out.println(count);
    }
}

4.获取两个字符串中最大相同子串

public class StringDemo2 {
    /*
     获取两个字符串中最大相同子串
     如str1=“abcwerthelloyuiodef”,str2="cvhellobnm"
     提示：将短的字符串进行长度一次递减的子串与较长的串比较
     */
        public String getMaxString(String str1,String str2){
            if(str1!=null&&str2!=null){
                String MaxString = (str1.length()>= str2.length()) ? str1 : str2;
                String MinString = (str1.length() < str2.length()) ? str1 : str2;
                for (int i=0;i<MinString.length();i++){
                    for (int x = 0, y =MinString.length()-i;y<=MinString.length();x++,y++){
                        System.out.println(x+"::::"+y);
                        String subStr = MinString.substring(x, y);
                        if (MaxString.contains(subStr)){
                            return subStr;
                        }
                    }
                }
            }
            return null;
        }
        @Test
    public void test(){
            String str1="abcwerthelloyuiodef";
            String str2="cvhellobnm";
            String maxStr = getMaxString(str1, str2);
            System.out.println(maxStr);
        }
}

jdk8之前的日期时间API

java.lang.System类

1.System类中的currentTimeMillis()

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

  @Test
    public void test(){
        long time=System.currentTimeMillis();
        System.out.println(time);
    }

java.util.date类

1.两个构造器的使用
》//构造器一：创建了一个对应当前时间的Date对象
》//构造器二：创建指定毫秒数的Date对象
2.两个方法的使用
》tostring():显示当前的年月日时分秒
》getTime():获取当前Date对象对应的毫秒数。时间戳

@Test
    public void test1(){
        //构造器一：创建了一个对应当前时间的Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.getTime());
        //构造器二：创建指定毫秒数的Date对象
        Date date2 = new Date(1645429322318L);
        System.out.println(date2);
    }

java.sql.Date对应着数据库中的日期类型变量

如何实例化

java.sql.Date date3 = new java.sql.Date(2323235656424L);//2043-08-15

util.Date>>>sql.Date对象

     //情况一：
        Date date4=new java.sql.Date(2323235656424L);
        java.sql.Date date5=(java.sql.Date)date4;
        //情况二：
        Date date6=new Date();
        java.sql.Date date7=new java.sql.Date(date6.getTime());

SimpleDateFormat

SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析
1.两个操作：
1.1格式化：日期——》指定格式的字符串
1.2解析：格式化的逆过程，字符串—->日期
2.SimpleDateFormat的实例化 ```java

@Test
public void testSimpleDateFormat() throws ParseException {
    //实例化SimpleDateFormat
    SimpleDateFormat sdf = new SimpleDateFormat();
    //格式化
    Date date = new Date();
    System.out.println(date);
    String format = sdf.format(date);
    System.out.println(format);
    //解析
    String str="22/2/22 上午2:22";
    Date date1 = sdf.parse(str);
    System.out.println(date1);
    //***********按照指定方式格式化和解析************************
    SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    //格式化
    String format1 = sdf1.format(date);
    System.out.println(format1);
    Date date2 = sdf1.parse("2022-02-22 04:56:22");
    System.out.println(date2);
}

<a name="G5Tfs"></a>
### Calendar(日历)类
_Calendar日历类（抽象类）的使用_
```java
@Test
    public void testCalendar(){
        //实例化
        //方式一：创建子类（GregorianCalender）的对象
        //方式二：调用其静态方法getInstance
        Calendar instance = Calendar.getInstance();
        System.out.println(instance.getClass());
        //常用方法
        //get()
        int days = instance.get(instance.DAY_OF_MONTH);
        System.out.println(days);
        System.out.println(instance.get(instance.DAY_OF_YEAR));
        //set()
        instance.set(instance.DAY_OF_MONTH,22);
        days=instance.get(instance.DAY_OF_MONTH);
        System.out.println(days);
        //add()
        instance.add(instance.DAY_OF_MONTH,3);
        days=instance.get(instance.DAY_OF_MONTH);
        System.out.println(days);
        //getTime():日历类----》》Date
        Date date = instance.getTime();
        System.out.println(date);
        //setTime():Date--->>日历类
        Date date1 = new Date();
        instance.setTime(date1);
        System.out.println(instance.get(instance.DAY_OF_MONTH));
    }

jdk8中新日期时间API

背景
可变性：像日期时间这样的类应该都是不可变的。
偏移量：Date中年份是从1900年开始的，月份都是从0开始的
格式化：格式化只对Date有用，对Calendar则不行
此外，他们也不是线程安全的，不能处理闰秒等

LocalDate、LocalTime、LocalDateTime的使用

 @Test
    public void test1(){
        //now()：获取当前时间日期、时间或者日期加时间
        LocalDate nowDate = LocalDate.now();
        LocalTime nowTime = LocalTime.now();
        LocalDateTime nowDateTime = LocalDateTime.now();
        System.out.println(nowDate);
        System.out.println(nowTime);
        System.out.println(nowDateTime);
        //of()：设置指定日期时间没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 12, 13, 23, 53);
        System.out.println(localDateTime1);
        //getXxx()：获取相关属性
        System.out.println(nowDateTime.getMonth());
        System.out.println(nowDateTime.getDayOfMonth());
        System.out.println(nowDateTime.getDayOfWeek());
        System.out.println(nowDateTime.getMonthValue());
        //withXxx():设置相关的属性(体现不可变性)
        LocalDate localDate = nowDate.withDayOfMonth(23);
        System.out.println(localDate);
        System.out.println(nowDate);
        LocalDateTime localDateTime = nowDateTime.withHour(3);
        System.out.println(localDateTime);
        System.out.println(nowDateTime);
    }

Instant 瞬时

时间线上的一个瞬时点。可能被用来记录应用程序中事件时间戳

    @Test
    public void test2(){
        //now()：获取本初子午线对应的标准时间
        Instant instant = Instant.now();
        System.out.println(instant);
        //添加时间的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);
        //toEpochMilli():获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数
        long toEpochMilli = instant.toEpochMilli();
        System.out.println(toEpochMilli);
        //ofEpochMilli():通过给定的毫秒数获取Instant实例-->Date(Long millis)
        Instant instant1 = instant.ofEpochMilli(1650285961834L);
        System.out.println(instant1);
    }

DateTimeFormatter

格式化解析日期时间（类似于SimpleDateFormat）

  @Test
    public void test3(){
        //实例化方式：
        //方式一：预定义的标准格式。如：IOS_LOCAL_DATE_TIME;IOS_LOCAL_DATE:IOS_LOCAL_TIME
        DateTimeFormatter formatter=DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化:日期->字符串
        LocalDateTime localDateTime=LocalDateTime.now();
        String format = formatter.format(localDateTime);
        System.out.println(localDateTime);
        System.out.println(format);
        //解析：字符串->日期：
        TemporalAccessor parse = formatter.parse(format);
        System.out.println(parse);
        //方式二：本地化相关格式。如：ofLocalizedDateTime()
        //FormatStyle.LONG/FormatStyle.MEDIUM/FormatStyle.SHORT
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        //格式化
        String format1 = formatter1.format(localDateTime);
        System.out.println(format1);
        //解析
        TemporalAccessor parse1 = formatter1.parse(format1);
        System.out.println(parse1);
        //ofLocalizedDate()
        //FormatStyle.FULL/FormatStyle.LONG/FormatStyle.MEDIUM/FormatStyle.SHORT:适用于LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
        //格式化
        LocalDate localDate = LocalDate.now();
        String format2 = formatter2.format(localDate);
        System.out.println(format2);
        //解析
        TemporalAccessor parse2 = formatter2.parse(format2);
        System.out.println(parse2);
        //方式三：自定义格式.如：ofPattern("yyyy-MM-dd hh:mm:ss")
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //格式化
        String format3 = formatter3.format(localDateTime);
        System.out.println(format3);
        //解析
        TemporalAccessor parse3 = formatter3.parse(format3);
        System.out.println(parse3);
    }

其他API

Zoneld：包含所有的时区信息，一个时区的ID
ZoneldDateTime：一个在IOS-8601日历系统时区的日期时间
Clock：使用时区提供对当前即时、日期和时间的访问时钟
持续时间：Duration：用于计算两个时间间隔
日期间隔：Period：用于计算两个日期间隔
TempporalAdjuster:时间校正器。
TempporalAdjuster：通过静态方法提供大量的常用TemporalAdjuster的实现

与传统日期的处理转换

java比较器

一、说明:Java中的对象，正常情况下，只能进行比较: ==或!=。不能使用〉或<的但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。如何实现﹖使用两个接口中的任何一个: Comparable或Comparator

Comparable

Comparable接口的使用举例：自然排序
1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
2.像String、包装类重写CompareTo()方法以后，进行了从小到大的排列
3.重写CompareTo(obj)的规则：
如果当前对象this大于形参对象obj，则返回正整数，
如果当前对象this小于形参对象obj，则返回负整数，
如果当前对象this等于形参对象obj，则返回0
4.对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写CompareTo(obj)方法，在CompareTo(obj)方法说明如何排序。

    @Test
    public void test1(){
        String[] arr=new String[]{"aa","bb","cc","KK","MM","GG"};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

例题

重写了CompareTo()方法，按照指定属性排序

public class Goods implements Comparable{
    private String name;
    private double price;
    public Goods() {
    }
    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
        //指明按照商品比较大小方式   :按价格从低到高
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods goods=(Goods)o;
            if (this.price>goods.price){
                return 1;
            }else if (this.price<goods.price){
                return -1;
            }else {
                return 0;
            }
            //方式二：
            //return Double.compare(this, price, goods.price);
        }
        throw new RuntimeException("传入的数据类型不一致!!!");
    }

   @Test
    public void test2(){
        Goods[] goods=new Goods[4];
        goods[0]=new Goods("leisheMouse",34);
        goods[1]=new Goods("dellMouse",43);
        goods[2]=new Goods("xiaomiMouse",12);
        goods[3]=new Goods("huaweiMouse",65);
        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
    }

Comparator

1.背景：

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前操作，那么可以考虑使用Comparator的对象排序

2.重写Compare（Object o1，Object o2）方法，比较o1和o2大小

如果返回正整数，则表示o1大于o2，如果返回负整数，表示o1小于o2，如果返回零，则表示相等

    @Test
    public void test3(){
        String[] arr=new String[]{"aa","bb","cc","KK","MM","GG"};
        Arrays.sort(arr, new Comparator<String>() {
            //按照字符串从大到小
            @Override
            public int compare(String o1, String o2) {
                if (o1 instanceof String && o2 instanceof String){
                    String s1=(String) o1;
                    String s2=(String) o2;
                    return -s1.compareTo(s2);
                }
               throw new RuntimeException("输入数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
    }