业务代码-整合框架-存储-缓存常见错误详解一

一. java空指针和异常：

1.什么是空指针异常（java.lang.NullPointException)：

1.1常见的空指针异常案例：

public class WhatIsNpe {

    public static class User {

        private String name;
        private String[] address;

        public void print() {
            System.out.println("This is User Class!");
        }

        public String readBook() {
            System.out.println("User Read Imooc Escape!");
            return null;
        }
    }

    /**
     * <h2>自定义一个运行时异常</h2>
     * */
    public static class CustomException extends RuntimeException {}

    public static void main(String[] args) {

        // 第一种情况: 调用了空对象的实例方法
//        User user = null;
//        user.print();

        // 第二种情况: 访问了空对象的属性
//        User user = null;
//        System.out.println(user.name);

        // 第三种情况: 当数组是一个空对象的时候, 取它的长度
//        User user = new User();
//        System.out.println(user.address.length);

        // 第四种情况: null 当做 Throwable 的值
//        CustomException exception = null;
//        throw exception;

        // 第五种情况: 方法的返回值是 null, 调用方直接去使用
        User user = new User();
        System.out.println(user.readBook().contains("MySQL"));
    }
}

2.赋值时自动拆箱出现空指针：

2.1需要装箱拆箱的类型有：

2.2自动拆箱时出现的空指针异常：

public class UnboxingNpe {

    private static int add(int x, int y) {
        return x + y;
    }

    private static boolean compare(long x, long y) {
        return x >= y;
    }

    public static void main(String[] args) {

        // 1. 变量赋值自动拆箱出现的空指针，Long赋值给long会自动拆箱
        // javac UnboxingNpe.java
        // javap -c UnboxingNpe.class
        Long count = null;
        long count_ = count;

        // 2. 方法传参时自动拆箱引发的空指针，add()方法里的参数是基本数据类型，传入的参数是Integer类型，会自动拆箱
//        Integer left = null;
//        Integer right = null;
//        System.out.println(add(left, right));

        // 3. 用于大小比较的场景，compare()方法里的参数是基本数据类型，传入的参数是Integer类型，会自动拆箱
//        Long left = 10L;
//        Long right = null;
//        System.out.println(compare(left, right));
    }
}

2.3规避自动拆箱应发空指针类型：

• 基本数据类型优于包装器类型，优先考虑使用基本类型
• 对于不确定的包装器类型，一定要校验是否是null
• 对于值为null的包装器类型，考虑是否可以赋值为0

3.字符串，数组，集合在使用时出现空指针：

• 字符串使用equals时报空指针错误
• 对象数组虽然new出来了，但是如果没有初始化，一样会报空指针错误
• List对象add null不报错，但是addAll不能添加null，否则会报空指针错误

public class BasicUsageNpe {

    private static boolean stringEquals(String x, String y) {
        return x.equals(y);
    }

    public static class User {
        private String name;
    }

    public static void main(String[] args) {

        // 1. 字符串使用 equals 可能会报空指针错误
//        System.out.println(stringEquals("xyz", null));  // 不会报错，打印false
//        System.out.println(stringEquals(null, "xyz"));  // 会报错，因为equals前面是null，null引用会报错

        // 2. 对象数组 new 出来, 但是元素没有初始化
//        User[] users = new User[10];
//        for (int i = 0; i != 10; ++i) {
//            users[i] = new User();
//            users[i].name = "imooc-" + i;  // 会报错，users[i]元素没有初始化，就是null
//        }

        // 3. List对象ddAll传递null会抛出空指针；add 传递null不会报错
        List<User> users = new ArrayList<User>();
        User user = null;
        List<User> users_ = null;
        users.add(user);        // 不会报错
        users.addAll(users_);   //会报错
    }
}

4.optional是容器类，代表存在与不存在，避免空指针异常：

/**
 1. <h1>学会 Optional, 规避空指针异常</h1>
 2. */
@SuppressWarnings("all")
public class OptionalUsage {

    private static void badUsageOptional() {

        Optional<User> optional = Optional.ofNullable(null);  // 创建optional实例
        User user = optional.orElse(null); // good
        user = optional.isPresent() ? optional.get() : null; // bad
    }

    public static class User {
        private String name;

        public String getName() {
            return name;
        }
    }

    private static void isUserEqualNull() {

        User user = null;
        if (user != null) {
            System.out.println("User is not null");
        } else {
            System.out.println("User is null");
        }

        Optional<User> optional = Optional.empty();  // 创建optional实例
        if (optional.isPresent()) {
            System.out.println("User is not null");
        } else {
            System.out.println("User is null");
        }
    }

    private static User anoymos() {
        return new User();
    }

    public static void main(String[] args) {

        // 没有意义的使用方法
        isUserEqualNull();

        User user = null;
        Optional<User> optionalUser = Optional.ofNullable(user);
        // 存在即返回, 空则提供默认值
        optionalUser.orElse(new User());
        // 存在即返回, 空则由函数去产生
        optionalUser.orElseGet(() -> anoymos());
        // 存在即返回, 否则抛出异常
        optionalUser.orElseThrow(RuntimeException::new);

        // 存在才去做相应的处理
        optionalUser.ifPresent(u -> System.out.println(u.getName()));

        // map 可以对 Optional 中的对象执行某种操作, 且会返回一个 Optional 对象
        optionalUser.map(u -> u.getName()).orElse("anymos");

        // map 是可以无限级联操作的
        optionalUser.map(u -> u.getName()).map(name -> name.length()).orElse(0);
    }
}

5.try catch 处理异常

1. 使用异常不要只是返回码，应该返回更加详细的内容
2. 主动捕获检查性异常，并对异常详细打印日志或者短信
3. 保持代码整洁，一个方法中不要有多个try catch 或者嵌套try catch
4. 捕获更加具体的异常，而不是通用的Exception
5. 合理的设计自定义异常类

/**
 * <h1>Java 异常处理</h1>
 * */
@SuppressWarnings("all")  //屏蔽编译器警告
public class ExceptionProcess {

    private static class User {}

    /**
     * <h2>Java 异常本质 -- 抛出异常</h2>
     * */
    private void throwException() {
        User user = null;
        // 对user进行业务处理
        if (null == user) {
            // 抛出异常
            throw new NullPointerException();
        }
    }

    /**
     * <h2>不能捕获空指针异常</h2>
     * */
    private void canNotCatchNpeException() {
        try {
            throwException(); //抛出异常
        } catch (ClassCastException cce) { // 类型转换异常 ClassCastException
            System.out.println(cce.getMessage()); // 打印异常类信息
            System.out.println(cce.getClass().getName()); // 打印异常类名称
        }
    }

    /**
     * <h2>能够捕获空指针异常</h2>
     * */
    private void canCatchNpeException() {
        try {
            throwException(); //抛出异常
        } catch (ClassCastException cce) { // 类型转换异常 ClassCastException
            System.out.println(cce.getMessage()); // 打印异常类信息
            System.out.println(cce.getClass().getName()); // 打印异常类名称
        } catch (NullPointerException npe) { // 空指针异常 NullPointerException
            System.out.println(npe.getMessage());
            System.out.println(npe.getClass().getName());
        }
    }

    public static void main(String[] args) {
        ExceptionProcess process = new ExceptionProcess();
        // 能够捕获空指针异常
        process.canCatchNpeException();
        // 不能够捕获空指针异常
        process.canNotCatchNpeException();
    }
}

结果如下：

6.编码中常见的异常（并发修改，类型转换，枚举查找）：

1. 可迭代对象在遍历的同时做修改，则会报并发修改异常
2. 类型转换不符合java的继承关系，则会报类型转换异常
3. 枚举在查找时，如果枚举值不存在，不会返回空，而是直接抛出异常

枚举类：

package com.imooc.java.escape;

/**
 * <h1>员工类型枚举类</h1>
 * */
public enum StaffType {

    RD,
    QA,
    PM,
    OP;
}

package com.imooc.java.escape;

import com.google.common.base.Enums;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * <h1>编码中的常见的异常</h1>
 * */
@SuppressWarnings("all")
public class GeneralException {

    /**
     * 定义user类型
     */
    public static class User {

        private String name;

        /**
         * 构造函数
         */
        public User() {}

        public User(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    /**
     * 定义继承User类的Manager类
     */
    public static class Manager extends User {}

    /**
     * 定义继承User类的Worker类
     */
    public static class Worker extends User {}

    /**
     * 定义typeIndex常量
     */
    private static final Map<String, StaffType> typeIndex = new HashMap<>(
            StaffType.values().length
    );

    /**
     * 静态代码块，对枚举进行一次遍历，并把遍历结果放在常量typeIndex上
     */
    static {
        for (StaffType value : StaffType.values()) {
            typeIndex.put(value.name(), value);
        }
    }

    /**
     * 并发修改异常
     * @param users
     */
    private static void concurrentModificationException(ArrayList<User> users) {

        // 直接使用 for 循环会触发并发修改异常。在遍历的同时删除对象会触发异常
//        for (User user : users) {
//            if (user.getName().equals("imooc")) {
//                users.remove(user);
//            }
//        }

        // 使用迭代器则没有问题。使用迭代器删除对象不会触发异常
        Iterator<User> iter = users.iterator();
        while (iter.hasNext()) {
            User user = iter.next();
            if (user.getName().equals("imooc")) {
                iter.remove();
            }
        }
    }

    /**
     * 根据类型值获取枚举类对象
     * @param type
     * @return
     */
    private static StaffType enumFind(String type) {

        //根据类型值获取枚举类对象
//        return StaffType.valueOf(type);

        // 1. 最普通、最简单的实现
//        try {
//            return StaffType.valueOf(type);
//        } catch (IllegalArgumentException ex) { // IllegalArgumentException参数异常
//            return null;
//        }

        // 2. 改进的实现, 但是效率不高
//        for (StaffType value : StaffType.values()) {
//            if (value.name().equals(type)) {
//                return value;
//            }
//        }
//        return null;

        // 3. 静态 Map 索引, 只有一次循环枚举的过程
//        return typeIndex.get(type);

        // 4. 使用 Google Guava Enums, 需要相关的依赖
        return Enums.getIfPresent(StaffType.class, type).orNull();
    }

    public static void main(String[] args) {

        // 1. 并发修改异常
//        ArrayList<User> users = new ArrayList<User>(
//                Arrays.asList(new User("qinyi"), new User("imooc"))
//        );
//        concurrentModificationException(users);

        // 2. 类型转换异常
//        User user1 = new Manager();
//        User user2 = new Worker();

//        Manager m1 = (Manager) user1; //不会产生类型转换异常
//        Manager m2 = (Manager) user2; //会产生类型转换异常，因为user2是Worker类，Worker类与Manager类无联系

//        System.out.println(user2.getClass().getName()); //查看user2对象的类名称
//        System.out.println(user2 instanceof Manager); //instanceof确定user2是否是Manager类

        // 3. 枚举查找异常
        System.out.println(enumFind("RD"));
        System.out.println(enumFind("abc"));
    }
}

7.解决使用try finally的资源没有关闭隐患
资源释放 ：打开了资源，使用完之后手动释放(关闭)
资源泄露 ：打开了资源，使用之后由于某种原因忘记或出现异常等等没有手动释放

try finally的问题与改进方案：

• 对单个资源的操作基本不会有问题
• 当同时操作多个资源时，代码沉余，且存在资源泄露的风险
• try-with-resources不仅比try-finally方便，而且不容易出错，可以用在单个资源，多个资源中

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.Buffer;

/**
 * <h1>解决使用 try finally 的资源泄露隐患</h1>
 * */
public class Main {

    /**
     * <h2>传统的方式实现对资源的关闭</h2>
     * */
    private String traditionalTryCatch() throws IOException {

        // 1. 单一资源的关闭
//        String line = null;
        // 输出流
//        BufferedReader br = new BufferedReader(new FileReader(""));
//        try {
              // 读取一行数据
//            line = br.readLine();
//        } finally {
//            br.close();
//        }
//        return line;

        // 2. 多个资源的关闭
        // 第一个资源，输入流
        InputStream in = new FileInputStream("");
        try {
            // 第二个资源，输出流
            OutputStream out = new FileOutputStream("");
            try {
                byte[] buf = new byte[100];
                int n;
                // 读取文件
                while ((n = in.read(buf)) >= 0)
                    // 输出文件
                    out.write(buf, 0, n);
            } finally {
                out.close();
            }
        } finally {
            in.close();
        }

        return null;
    }

    /**
     * <h2>java7 引入的 try with resources 实现自动的资源关闭</h2>
     * */
    private String newTryWithResources() throws IOException {

        // 1. 单个资源的使用与关闭
//        try (BufferedReader br = new BufferedReader(new FileReader(""))) {
//            return br.readLine();
//        }

        // 2. 多个资源的使用与关闭
        try (FileInputStream in = new FileInputStream("");
             FileOutputStream out = new FileOutputStream("")
        ) {
            byte[] buffer = new byte[100];
            int n = 0;
            while ((n = in.read(buffer)) != -1) {
                out.write(buffer, 0, n);
            }
        }
        return null;
    }

    public static void main(String[] args) throws MyException {

//        AutoClose autoClose = new AutoClose();
//        try {
//            autoClose.work();
//        } finally {
//            autoClose.close();
//        }

        try (AutoClose autoClose = new AutoClose()) {
            autoClose.work();
        }
    }
}

/**
 * 定义AutoClose类
 */
public class AutoClose implements AutoCloseable {

    @Override
    public void close() {
        System.out.println(">>> close()");
        throw new RuntimeException("Exception in close()");
    }

    public void work() throws MyException {
        System.out.println(">>> work()");
        throw new MyException("Exception in work()");
    }
}

/**
 * 自定义异常 MyException
 */
public class MyException extends Exception {

    public MyException() {
        super();
    }

    public MyException(String message) {
        super(message);
    }
}

二，java计算，集合，接口

1.Bigdecimal 用于精确计算的类：

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * <h1>数值计算</h1>
 */
@SuppressWarnings("all")
public class NumberAndTime {

    /**
     * <h2> scale 需要与小数位匹配 </h2>
     */
    private static void scaleProblem() {
        BigDecimal decimal = new BigDecimal("12.222");
        // 给decimal设置精度为2，因为12.222精度是3，设置为2会丢失精度，下面这样写会报错
        BigDecimal result = decimal.setScale(2);
        // 给decimal设置精度为12，因为12.222精度是3，设置为12不会丢失精度，下面这样不会报错，不够后面会用0补
        BigDecimal result = decimal.setScale(12);
        System.out.println(result);
        // 给decimal设置精度为2，设置BigDecimal.ROUND_HALF_UP舍入方式，四舍五入，不会报错
        BigDecimal result = decimal.setScale(2, BigDecimal.ROUND_HALF_UP);
        System.out.println(result);
    }

    /**
     * <h2> BigDecimal 做除法时出现除不尽的情况 </h2>
     */
    private static void divideProblem() {
        // 30除以7，因为30除不尽7，会报错
        System.out.println(new BigDecimal(30).divide(new BigDecimal(7)));
        // 30除以7，虽然30除不尽7，但是进行了四舍五入，保留2两位小数，不会报错
        System.out.println(
                new BigDecimal(30).divide(new BigDecimal(7), 2, BigDecimal.ROUND_HALF_UP)
        );
    }

    /**
     * <h2> 精度问题导致比较结果和预期的不一致 </h2>
     */
    private static void equalProblem() {
        BigDecimal bd1 = new BigDecimal("0");
        BigDecimal bd2 = new BigDecimal("0.0");
        // equals会比较精度是否一致，再判断数字
        System.out.println(bd1.equals(bd2));  // false
        // compareTo只判断值 大于返回正数，小于返回负数，等于返回0
        System.out.println(bd1.compareTo(bd2) == 0); // true
    }

    public static void main(String[] args) throws Exception {
//        scaleProblem();
//        divideProblem();
//        equalProblem();

    }
}

2.SimpleDateFormat 注意点：

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * <h1>时间计算</h1>
 */
@SuppressWarnings("all")
public class NumberAndTime {
    /**
     * <h2>
     *     SimpleDateFormat 可以解析大于/等于它定义的时间精度
     *     但是不能解析小于它定义的时间精度
     * </h2>
     */
    private static void formatPrecision() throws Exception {
        // 定义时间SimpleDateFormat
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String time_x = "2020-03-01 10:00:00";
        String time = "2020-03";
        // 可以解析大于/等于它定义的时间精度，把string转换为时间格式
        System.out.println(sdf.parse(time_x));  // Sun Mar 01 0：00：00 CST2020
        // 不能解析小于它定义的时间精度，会报错
        System.out.println(sdf.parse(time)); // 报错
    }

    /**
     * <h2> SimplleDateFormat 存在线程安全问题 </h2>
     */
    private static void threadSafety() {
        // 定义时间SimpleDateFormat
        SimpleDateFormat sdf = new SimpleDateFormat(
                "yyyy-MM-dd HH:mm:ss");
        // 定义线程池
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(
                        10, 100, 1, TimeUnit.MINUTES,
                        new LinkedBlockingDeque<>(1000)
                );
        while (true) {
            threadPoolExecutor.execute(() -> {
                String dateString = "2020-03-01 10:00:00";
                try {
                    // 把string类型转换为时间格式
                    Date parseDate = sdf.parse(dateString);
                    // 再把时间格式转换为string类型
                    String dateString2 = sdf.format(parseDate);
                    // 比较最后和开始的string是否一致
                    System.out.println(dateString.equals(dateString2));
                } catch (ParseException ex) {
                    ex.printStackTrace();
                }
            });
        }
    }

    public static void main(String[] args) throws Exception {
//        formatPrecision();
        threadSafety();
    }
}

3.for循环与迭代器 ：

任何实现Iterable接口的对象，都可以使用for-each循环处理

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

/**
 * <h1>小小 for 循环, 沾上集合出大问题</h1>
 * */
@SuppressWarnings("all")
public class ForeachOptimize {

    private static Collection<Integer> left =
            Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    private static Collection<Integer> right =
            Arrays.asList(1, 2, 3, 4, 5);

    /**
     * <h2>集合迭代经常犯的错误</h2>
     * */
    private static void wrongIterator() {

//        // 传统方式 - 使用索引（没问题)
//        int[] xyz = new int[]{1, 2, 3, 4, 5};
//        for (int i = 0; i != xyz.length; ++i) {
//            System.out.println(xyz[i]);
//        }
//
//        // 传统方式 - 迭代器（没问题）
//        for (Iterator<Integer> i = left.iterator(); i.hasNext(); ) {
//            System.out.println(i.next());
//        }

        // 嵌套迭代容易出现问题（有问题，l.next()会在循环right时被next，会照成left会被提前next，导致报错
//        for (Iterator<Integer> l = left.iterator(); l.hasNext(); ) {
//            for (Iterator<Integer> r = right.iterator(); r.hasNext(); ) {
//                System.out.println(l.next() * r.next());
//            }
//        }

        // 正确的用法, 嵌套迭代（没问题)
//        for (Iterator<Integer> l = left.iterator(); l.hasNext(); ) {
//            Integer tmp = l.next();
//            for (Iterator<Integer> r = right.iterator(); r.hasNext(); ) {
//                System.out.println(tmp * r.next());
//            }
//        }

        // 直接用foreach更简单如下（没问题)
        for (Integer l : left) {
            for (Integer r : right) {
                System.out.println(l * r);
            }
        }
    }

    private static void square(int value) {
        System.out.println(value * value);
    }

    public static void main(String[] args) {

        wrongIterator();

        // Java8 Iterable.forEach vs for-each(没问题）
        for (Integer l : left) {
            square(l);
        }
        left.forEach(l -> square(l));
        left.forEach(ForeachOptimize::square);
    }
}

4，Lombox常用注解：

注解解析：编译器使用javac对代码进行编译的过程中会先对源代码进行分析，生成一个抽象语法树，然后去调用实现了lombox程序，抽象语法树进行处理，在使用了@Get，@Set注解的时候，会对抽象语法树进行修改，追加get，set方法，然后用修改后的抽象语法树去生成java字节码。

4.1.iPhone属性命名使用@Data会变成iphone，要注意不能一个字母小写，第二个字母大写的命名

import lombok.Data;

/**
 * <h1>Java Object</h1>
 * */
@Data
public class Personal {

    private String iPhone;
    private String name;
    private String userName;
}

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * <h1>lombok 工具的使用以及需要避免的坑</h1>
 * */
public class Main {

    /**
     * <h1>lombok 第一个坑</h1>
     * */
    private static void singleAlphabetHump() throws Exception {

        ObjectMapper mapper = new ObjectMapper();

        Personal personal = new Personal();
        personal.setIPhone("8.1");

        // {"name":null,"userName":null,"iphone":"8.1"}
//        System.out.println(mapper.writeValueAsString(personal));

        String json = "{\"name\": \"qinyi\"," +
                "\"userName\": \"qinyi-imooc\",\"iphone\":\"8.1\"}";

        Personal personal1 = mapper.readValue(json, Personal.class);
        System.out.println(personal1);
    }
}

4.2 AppleComputer类的id，name属性是继承父类的，这种要使用equals要在子类AppleComputer中加@EqualsAndHashCode(callSuper = true)，表示也比较继承分类的id，name。否则在子类中用equals不会比较父类的属性。

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Computer {

    private Integer id;
    private String name;
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;

@EqualsAndHashCode(callSuper = true)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AppleComputer extends Computer {

    private long price;
    private String color;

    public AppleComputer(Integer id, String name, long price, String color) {

        super(id, name);
        this.price = price;
        this.color = color;
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * <h1>lombok 工具的使用以及需要避免的坑</h1>
 * */
public class Main {
    /**
     * <h2>lombok 的第二个坑</h2>
     * */
    private static void equalsAndHashCodeBug() {

        AppleComputer computer1 = new AppleComputer(
                1, "Mac Pro", 1L, "yellow"
        );
        AppleComputer computer2 = new AppleComputer(
                2, "Mac Air", 1L, "yellow"
        );

        System.out.println(computer1.equals(computer2));
    }

    public static void main(String[] args) throws Exception {

//        singleAlphabetHump();

        equalsAndHashCodeBug();
    }
}

5.抽象类和接口：
抽象类 ：子类的通用特性，就是子类都有的特性，包含了属性和行为。对类本质的抽象，表达的是is a的关系。
接口 ：定义行为，并不关心谁去实现，不是所有子类都有的行为。对行为的抽象，表达的是like a 的关系。

**抽象类与接口的相同点：**接口中的方法（java8改变了这一语法）和抽象类中的抽象方法都不能有方法体，并且必须在子类中实现。都可以被继承，但是不能被实例化。
抽象类与接口的不同点：使用的语法不同，抽象类用extends，接口用implements。接口中只能定义常量，不能表达对象状态，抽象类可以。接口中的方法必须是public类型的，抽象类没有限制。类可以同时实现多个接口，但是只能继承一个抽象类

三.泛型，反射，编译优化

1. Serializable接口：一个标记接口，不用实现任何方法，标记当前类对象是可以序列化的

序列化：将对象写入到IO流中

反序列化：从Io流中恢复对象

（1）序列化，反序列化例子：

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;

/**
 * <h1>Java Object</h1>
 * */
@Setter
@Getter
@ToString
public class People implements Serializable {

    private Long id;

    public People() {}

    public People(Long id) {
        this.id = id;
    }
}

/**
 * <h1>序列化和反序列化</h1>
 * */
@SuppressWarnings("all")
public class Main {

    /**
     * <h1>序列化和反序列化 People 对象</h1>
     * */
    private static void testSerializablePeople() throws Exception {

        //1.序列化的步骤
        // 用于存储序列化的文件
        File file = new File("/tmp/people_10.java_");
        People p = new People(10L);
        // 创建一个输出流
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(file)
        );
        // 输出可序列化对象
        oos.writeObject(p);
        // 关闭输出流
        oos.close();

        // 2.反序列化的步骤
        // 创建一个输入流
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(file)
        );
        // 得到反序列化的对象
        Object newPerson = ois.readObject();
        // 关闭输入流
        ois.close();
        System.out.println(newPerson);
    }
    
public static void main(String[] args) throws Exception {
        testSerializablePeople();
    }

注意：

• 子类实现序列化接口，父类没有实现，如果父类有无参构造方法，子类可以实现序列化，否则会报错
• 类中存在引用对象，这个引用对象是可序列化的才能实现序列化
• 同一个对象多次序列化，只会序列化一次，后面的保存序列化的编号，所以如果在第一次序列化后，在改对象属性值再进行序列化，这样还是保存的是第一次序列化数据。

2.泛型：参数化类型，就是将类型由原来的具体的类型参数化

泛型作用：在不创建新类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型

import java.util.ArrayList;
import java.util.List;

/**
 * <h1>理解泛型</h1>
 * */
@SuppressWarnings("all")
public class Genericity {

    /**
     * <h2>简单使用泛型</h2>
     * */
    private static void easyUse() throws Exception {

        List<String> left = new ArrayList<>();
        List<Integer> right = new ArrayList<>();

//        System.out.println(left.getClass());
//        System.out.println(left.getClass() == right.getClass());

//        if (left instanceof ArrayList<Double>) {}
//        if (left instanceof ArrayList) {
//
//        }
//
//        if (left instanceof ArrayList<?>) {}

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.getClass().getMethod("add", Object.class).invoke(list, "abcd");
        list.getClass().getMethod("add", Object.class).invoke(list, 1.2);

        for (int i = 0; i != list.size(); ++i) {
            System.out.println(list.get(i));
        }
    }

    /**
     * <h2>泛型是先检查再编译</h2>
     * */
    private static void checkAndCompile() {

        ArrayList<String> list = new ArrayList<>();
        list.add("1234");
//        list.add(123);
    }

    /**
     * <h2>泛型不支持继承</h2>
     * */
    private static void genericityCanNotExtend() {

        // 第一类错误
//        ArrayList<String> first = new ArrayList<Object>();
//
//        ArrayList<Object> list1 = new ArrayList<>();
//        list1.add(new Object());
//        ArrayList<String> list2 = list1;

        // 第二类错误
//        ArrayList<Object> second = new ArrayList<String>();
//
//        ArrayList<String> list1 = new ArrayList<>();
//        list1.add(new String());
//        ArrayList<Object> list2 = list1;
    }

    /**
     * <h2>泛型类型变量不能是基本数据类型</h2>
     * */
    private static void baseTypeCanNotUseGenericity() {

//        List<int> invalid = new ArrayList<>();
    }

    /**
     * <h2>泛型的类型参数只能是类类型, 不能是简单类型</h2>
     * */
    private static <T> void doSomething(T... values) {
        for (T value : values) {
            System.out.println(value);
        }
    }

    public static void main(String[] args) throws Exception {

//        easyUse();

        Integer[] ints1 = new Integer[]{1, 2, 3};
        int[] ints2 = new int[]{1, 2, 3};

        doSomething(ints1);
        System.out.println("----------------");
        doSomething(ints2);
    }
}

3.不是所有的字符串拼接都使用StringBuilder：

（1）循环里面使用"+"去拼接字符串，会造成空间浪费，每次拼接的结果都需要创建新的不可变类；时间浪费，创建的新不可变类需要初始化，产生大量临时对象，影响young gc，full gc。

（2）StringBuffer和StringBuilder的区别：

线程安全：StringBuffer线程安全和StringBuilder不安全

缓冲区：StringBuffer使用缓冲区和StringBuilder不使用缓冲区

性能：StringBuffer性能远大于StringBuilder

四.java线程安全

多线程操作变量过程：

1.Synchronized关键字：

• Synchronized方法不会被继承，需要在子类中重新指定
• Synchronized可以标注在方法声明，方法体中
• jdk对Synchronized进行了优化，主要表现在偏向锁，轻量级锁，重量级锁

public class MainActive implements Runnable {

    private int value = 0;

    @Override
    public synchronized void run() {

        String name = Thread.currentThread().getName();

        while (true) {

            if (value < 1000) {
                System.out.println(name + " start : " + value);
                value++;
                System.out.println(name + " done : " + value);
            } else {
                break;
            }
        }
    }
}

2.阻塞队列的核心定义：支持两个附加操作的队列

• 队列空则等
• 队列满则等

四种处理方法：

生产者：

import java.util.concurrent.BlockingQueue;

/**
 * <h1>生产者</h1>
 * */
// 实现Runnable接口，让Producer交给一个独立的线程去执行
public class Producer implements Runnable {

    // 定义阻塞队列
    private final BlockingQueue<Integer> blockingQueue;
    private static int element = 0;

    // 构造函数，给阻塞队列初始化
    public Producer(BlockingQueue<Integer> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

//    @Override
//    public void run() {
//
//        while (element < 100) {
//            System.out.println("Produce: " + element);
              // 给阻塞队列添加element，在队列满时不会等待，会返回false，会导致没有消费所有生成的生产者
//            blockingQueue.offer(element++);
//        }
//
//        System.out.println("Produce Done!");
//    }

    @Override
    public void run() {

        try {
            while (element < 100) {
                System.out.println("Produce: " + element);
                blockingQueue.put(element++);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Produce Done!");
    }
}

消费者：

import java.util.concurrent.BlockingQueue;

/**
 * <h1>消费者</h1>
 * */
// 实现Runnable接口，让Producer交给一个独立的线程去执行
public class Consumer implements Runnable {

    // 定义阻塞队列
    private final BlockingQueue<Integer> blockingQueue;

    // 构造函数，给阻塞队列初始化
    public Consumer(BlockingQueue<Integer> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {

        try {
            while (true) {
                // 在阻塞队列中取元素
                int value = blockingQueue.take();
                System.out.println("Consume: " + value);
                if (value >= 99) {
                    break;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Consumer Done!");
    }
}

阻塞队列的应用：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * <h1>阻塞队列的应用</h1>
 * */
public class Main {

    public static void main(String[] args) {

        // 3是容量
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(
                3, true
        );

        Producer producer = new Producer(blockingQueue);
        Consumer consumer = new Consumer(blockingQueue);

        // 创建线程
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

3.CopyOnWrite 是一种优化策略，是一种延时懒惰策略，是对读写分离思想的实现

优点：并发读不需要加锁，提高了程序的并发读

缺点：内存占用问题（因为会复制，再写），一致性问题（因为读是读旧容器，写是在新容器，只能保证最终一致性，不能保证实时一致性）

适应场景：适合读多写少的场景
CopyOnWrite 对比 Collections.synchronizedList：

• 它们都可以实现线程安全的集合(列表)
• CopyOnWrite 的写操作不仅需要加锁，而且内部对数组进行了 copy，所以，写性能比Collections.synchronizedList 要差
• Collections.synchronizedList 读操作有 synchronized 关键字修饰，而 CopyOnWrite是直接读，所以，读性能CopyOnWrite 更好

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * <h1>使用 CopyOnWrite 并发读写不会抛出异常</h1>
 * */
public class TaskPoolNoProblem {

    private static final List<String> tasks = new CopyOnWriteArrayList<>();

    public static void main(String[] args) throws Exception {

        for (int i = 0; i != 10; ++i) {
            tasks.add("task-" + i);
        }

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    tasks.add("task-x");
                }
            }
        });
        thread.setDaemon(true);
        thread.start();

        Thread.sleep(1000L);

        for (String task : tasks) {
            System.out.println(task);
        }
    }
}

4.jdk线程池的核心思想：

jdk中线程池的核心实现类是ThreadPoolExecutor

ThreadPoolExecutor 怎么同时维护线程以及执行任务：

线程池的运行状态：

线程池的状态转换图：

jdk线程池的错误用法：

• 固定大小的线程池会导致内存急剧上升
• jdk提供的线程池不符合需求，自己定义线程池，但是线程池参数很多，容易出错
  

/**
 * <h1>读书的任务</h1>
 * */
public class Reading implements Runnable {

    private int count;
    private String name;

    public Reading(int count, String name) {
        this.count = count;
        this.name = name;
    }

    @Override
    public void run() {

        while (count > 0) {

            System.out.println(Thread.currentThread().getName() + " reading " + name);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }

            --count;
        }
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class EasyUseThreadPool {

    /**
     * <h1>简单使用线程池</h1>
     * */
    private static void useFixedThreadPool(int threadCount) {

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        Runnable runnable01 = new Reading(3, "Java 编程思想");
        Runnable runnable02 = new Reading(2, "Spring 实战");
        Runnable runnable03 = new Reading(3, "SpringBoot 实战");
        Runnable runnable04 = new Reading(1, "MySQL 权威指南");
        Runnable runnable05 = new Reading(2, "SpringCloud 实战");

        executor.execute(runnable01);
        executor.execute(runnable02);
        executor.execute(runnable03);
        executor.execute(runnable04);
        executor.execute(runnable05);

        executor.shutdown();
    }

    /**
     * <h2>自定义线程池</h2>
     * */
    private static void customThreadPool() {

        // 自定义线程池
        ThreadPoolExecutor custom1 = new ThreadPoolExecutor(
                1, 1, 30, TimeUnit.MINUTES,
                new ArrayBlockingQueue<Runnable>(2)
        );
        // 自定义线程池
        ThreadPoolExecutor custom2 = new ThreadPoolExecutor(
                1, 1, 30, TimeUnit.MINUTES,
                new ArrayBlockingQueue<Runnable>(2),
                // 拒绝策略
                new CustomRejectHandler()
        );

        for (int i = 0; i != 5; ++i) {
            custom2.execute(new Reading(3, "Java 编程思想"));
        }

        custom2.shutdown();
    }

    // 自定义拒绝策略
    private static class CustomRejectHandler implements RejectedExecutionHandler {

        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

            try {
                // executor.getQueue() 拿到阻塞队列
                executor.getQueue().put(r);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

//        useFixedThreadPool(3);
        customThreadPool();
    }
}

怎么监控线程池的运行状态：

import java.util.Date;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * <h1>自定义线程池工厂, 带有监控功能</h1>
 * */
public class ExecutorsUtil extends ThreadPoolExecutor {

    // 线程池的关闭，统计已经执行的，正在执行的阻塞的的线程池
    @Override
    public void shutdown() {
        System.out.println(
                String.format(this.poolName +
                                "将会被关闭的. 已经执行的: %d," +
                        "正在执行的: %d, 阻塞的: %d",
                        this.getCompletedTaskCount(),
                        this.getActiveCount(),
                        this.getQueue().size()
                )
        );
        super.shutdown();
    }

    // 线程池即将关闭，统计已经执行的，正在执行的阻塞的的线程池
    @Override
    public List<Runnable> shutdownNow() {
        System.out.println(
                String.format(this.poolName +
                                "将会被关闭的. 已经执行的: %d," +
                                "正在执行的: %d, 阻塞的: %d",
                        this.getCompletedTaskCount(),
                        this.getActiveCount(),
                        this.getQueue().size()
                )
        );
        return super.shutdownNow();
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        // 当前线程的开始时间
        startTimes.put(String.valueOf(r.hashCode()), new Date());
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        // 获取开始时间
        Date startDate = startTimes.remove(String.valueOf(r.hashCode()));
        // 结束的时间
        Date finishDate = new Date();
        // 任务执行的时间
        long diff = finishDate.getTime() - startDate.getTime();
        System.out.println(String.format("任务执行的时间: %d", diff));
    }

    // 固定大小线程池方法
    public static ExecutorService newFixedThreadPool(int nThreads, String poolName) {
        return new ExecutorsUtil(
                nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingDeque<>(), poolName
        );
    }

    // 存储每个线程任务开始执行的时间
    private ConcurrentHashMap<String, Date> startTimes;
    // 线程池的名称
    private String poolName;

    // 编写构造方法
    public ExecutorsUtil(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                         TimeUnit unit, BlockingQueue<Runnable> workQueue,
                         String poolName) {
        // 调用父类的构造函数
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, new ExecutorsUtil.EventThreadFactory(poolName));
        this.startTimes = new ConcurrentHashMap<>();
        this.poolName = poolName;
    }

    // 自定义线程池工厂
    static class EventThreadFactory implements ThreadFactory {

        // 原子类AtomicInteger，poolNumber存储线程池的编号
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        // 把线程池的线程放在线程池组里
        private final ThreadGroup group;
        // 线程的编号
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        // 用来给线程池起一个名字
        private final String namePrefix;

        EventThreadFactory(String poolName) {
            SecurityManager s = System.getSecurityManager();
           // 线程池组 s.getThreadGroup()获取线程池组；Thread.currentThread().getThreadGroup()获取当前线程的线程池组
            group = (s != null) ? s.getThreadGroup()
                    : Thread.currentThread().getThreadGroup();
            namePrefix = poolName + "-pool-" + poolNumber.getAndIncrement()
                    + "-thread";
        }

        @Override
        public Thread newThread(Runnable r) {
            // 新增线程
            Thread t = new Thread(
                    // group线程池组 r要执行的任务 namePrefix + threadNumber.getAndIncrement()当前线程的名称
                    group, r, namePrefix + threadNumber.getAndIncrement(),
                    // 0 默认值为0，当前线程指定栈的大小
                    0
            );
            // 判断是否是守护方式
            if (t.isDaemon()) {
                // 设置不是守护方式
                t.setDaemon(false);
            }
            // 检验优先级
            if (t.getPriority() != Thread.NORM_PRIORITY) {
                // 设置为一个正常优先级的线程
                t.setPriority(Thread.NORM_PRIORITY);
            }
            return t;
        }
    }
}

import java.util.concurrent.ExecutorService;

/**
 * <h1>可监控的线程池</h1>
 * */
public class Main {

    public static void main(String[] args) {

        ExecutorService executorService = ExecutorsUtil.newFixedThreadPool(
                10, "imooc-qinyi-"
        );

        Runnable runnable01 = new Reading(3, "Java 编程思想");
        Runnable runnable02 = new Reading(2, "Spring 实战");
        Runnable runnable03 = new Reading(3, "SpringBoot 实战");
        Runnable runnable04 = new Reading(1, "MySQL 权威指南");
        Runnable runnable05 = new Reading(2, "SpringCloud 实战");

        executorService.execute(runnable01);
        executorService.execute(runnable02);
        executorService.execute(runnable03);
        executorService.execute(runnable04);
        executorService.execute(runnable05);

        executorService.shutdown();
    }
}

4.1ThreadLocal ：每个线程需要自己独立的实例且该实例需要在多个方法中被使用

ThreadLocal误区：不支持继承，遇到线程池，如果不及时清理现场，会造成数据混乱

ThreadLocal的实现方式，维护线程与实例的映射：

方式一：

方式二：