并发修改、类型转换、枚举查找异常

可迭代对象在遍历的同时做修改，则会报并发修改异常

public class Main {
    public static class User {
        private String name;
        public User(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
    }
    private static void concurrentModificationException(ArrayList<User> users) {
        // 直接使用 for 循环会触发并发修改异常
        // 抛出 java.util.ConcurrentModificationException
        for (User user : users) {
            if ("Bob".equalsIgnoreCase(user.getName())) {
                users.remove(user);
            }
        }
        // 使用迭代器则不会触发异常
        Iterator<User> iter = users.iterator();
        while (iter.hasNext()){
            User user = iter.next();
            if ("Bob".equalsIgnoreCase(user.getName())){
                iter.remove();
            }
        }
    }
    public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>(
                Arrays.asList(new User("Linda"), new User("Bob"))
        );
        concurrentModificationException(users);
    }
}

类型转换不符合 Java 的继承关系，则会报类型转换异常

public class Parent{}
public class Son1 extends Parent{}
public class Son2 extends Parent{}
public static void main(String[] args) {
    Parent p1 = new Son1();
    Parent p2 = new Son2();
    // 如果将 p2 强转为 Son1，则会抛出 ClassCastException，即类型转换异常
    Son1 s = (Son1) p2;
    // 如果需要知道某个类是否是某个类的实例，有两种方法：
    // 1.instanceof 关键字
    p2 instanceof Son1
    // 2.获取 Class 的名称
    p2.getClass().getName()
}

枚举在查找时，如果枚举值不存在，不会返回空，而是直接抛出异常：

// 自定义枚举类
public static enum EnumType {
    ERROR_CODE(1001, "错误"),
    SUCCESS_CODE(2001, "成功");
    Integer code;
    String value;
    EnumType(Integer code, String value) {
        this.code = code;
        this.value = value;
    }
}
// 通过字符串查找枚举值
private static EnumType enumType(String type){
    // 当 type 在枚举类中不存在时，会抛出 java.lang.IllegalArgumentException 异常
    return EnumType.valueOf(type);
}
/* 解决办法 */
// 1.对异常进行捕获
private static EnumType enumType(String type){
    try {
        return EnumType.valueOf(type);
    } catch (IllegalArgumentException exception){
        return null;
    }
}
// 2.通过循环判断，避免异常，但效率较低
private static EnumType enumType(String type){
    for (EnumType value : EnumType.values()) {
        if (value.name().equals(type)){
            return value;
        }
    }
    return null;
}
// 3.静态 Map 索引，只有在 Map 索引建立时有一次循环
private static final Map<String,EnumType> typeIndex = new HashMap<>(EnumType.values().length);
static {
    // 静态代码块实现初始化
    for (EnumType value : EnumType.values()) {
        typeIndex.put(value.name(),value);
    }
}
private static EnumType enumType(String type){
    return typeIndex.get(type);
}