21. 不可变集合、Stream、异常

创建不可变集合

 

public class Test {
    public static void main(String[] args) {
        // 不可变的List集合
        List<Double> lists = List.of(569.5 ,700.5 ,523.0 ,570.4);
//        lists.add(689.5); // 异常
//        lists.set(2, 100.2); // 异常
        System.out.println(lists);

        // 不可变的Set集合
        Set<String> names = Set.of("张三" ,"李四");
//        names.add("王麻子"); // 异常
        System.out.println(names);

        // 不可变的Map集合
        Map<String, Integer> maps = Map.of("华为",2 ,"Java" ,1);
//        maps.put("苹果",3); // 异常
        System.out.println(maps);

    }
}

Stream流

Stream流的概述

public class Test {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三", "李四", "张麻子");
        System.out.println(names);

        // 找出姓张的放到新集合
        List<String> zhang = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("张")) {
                zhang.add(name);
            }
        }
        System.out.println(zhang);

        // 找名称长度为3的姓名
        List<String> three = new ArrayList<>();
        for (String name : names) {
            if (name.length() == 3) {
                three.add(name);
            }
        }
        System.out.println(three);
    }
}

/**
 * 使用Stream实现
 */
public class Test {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三", "李四", "张麻子");
        System.out.println(names);

        names.stream().filter(s -> s.startsWith("张") && s.length() == 3).forEach(s -> System.out.println(s));
    }
}

Stream流的获取

 

/**
 目标：Stream流的获取

 Stream流式思想的核心：
 是先得到集合或者数组的Stream流（就是一根传送带）
 然后就用这个Stream流操作集合或者数组的元素。
 然后用Stream流简化替代集合操作的API.

 集合获取流的API:
 (1) default Stream<E> stream();

 小结：
 集合获取Stream流用: stream();
 数组：Arrays.stream(数组)   /  Stream.of(数组);
 */
public class Test {
    public static void main(String[] args) {
        /** --------------------Collection集合获取流-------------------------------   */
        Collection<String> list = new ArrayList<>();
        Stream<String> s = list.stream();

        /** --------------------Map集合获取流-------------------------------   */
        Map<String ,Integer> maps = new HashMap<>();
        // 键流
        Stream<String> keyStream = maps.keySet().stream();
        // 值流
        Stream<Integer> valueStream = maps.values().stream();
        // 键值对(拿整体)
        Stream<Map.Entry<String, Integer>> keyValueStream = maps.entrySet().stream();

        /** ---------------------数组获取流------------------------------   */
        String[] names = {"赵敏","小昭","灭绝","周芷若"};
        Stream<String> nameStream = Arrays.stream(names);

        Stream<String> nameStream2 = Stream.of(names);
    }
}

 

Stream流的常用API（中间操作方法）

 

/**
 目标：Stream流的常用API
 forEach : 逐一处理(遍历)
 count：统计个数
 -- long count();
 filter : 过滤元素
 -- Stream<T> filter(Predicate<? super T> predicate)
 limit : 取前几个元素
 skip : 跳过前几个
 map : 加工方法
 concat : 合并流。
 */
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌" ,"周芷若" ,"赵敏" ,"张强" ,"张三丰" ,"张三丰");

        // Stream<T> filter(Predicate<? super T> predicate)
        list.stream().filter( s -> s.startsWith("张")).forEach(s -> System.out.println(s));

        long size = list.stream().filter(s -> s.length() == 3).count();
        System.err.println(size);

        list.stream().filter( s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));

        list.stream().filter( s -> s.startsWith("张")).skip(2).forEach(s -> System.out.println(s));

        // map加工方法: 第一个参数原材料  -> 第二个参数是加工后的结果。
        // 给集合元素的前面都加上一个：隔壁老王的：
        list.stream().map(s ->  "隔壁老王的" + s).forEach(s -> System.out.println(s));

        // 需求：把所有的名称 都加工成一个学生对象。
        list.stream().map(s -> new Student(s)).forEach(s -> System.out.println(s));

        // 合并流。
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = Stream.of("Java1" ,"Java2");
        Stream<String> s3 = Stream.concat(s1, s2);
        s3.forEach(s -> System.out.println(s));
    }
}

Stream流的综合应用

public class Topperformer {
    private String name;
    private double money; // 月薪

    public Topperformer() {
    }

    public Topperformer(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Topperformer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

public class Employee {
    private String name;
    private char sex;
    private double salary;
    private double bonus;
    private String punish; // 处罚信息

    public Employee(){
    }

    public Employee(String name, char sex, double salary, double bonus, String punish) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.bonus = bonus;
        this.punish = punish;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public String getPunish() {
        return punish;
    }

    public void setPunish(String punish) {
        this.punish = punish;
    }

    public double getTotalSalay(){
        return salary * 12 + bonus;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", punish='" + punish + '\'' +
                '}'+"\n";
    }
}

public class Test {

    public static double allMoneyone = 0;
    public static double allMoneytwo = 0;
    public static double allMoneythree = 0;

    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("猪八戒",'男',30000 , 25000, null));
        one.add(new Employee("孙悟空",'男',25000 , 1000, "顶撞上司"));
        one.add(new Employee("沙僧",'男',20000 , 20000, null));
        one.add(new Employee("小白龙",'男',20000 , 25000, null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("武松",'男',15000 , 9000, null));
        two.add(new Employee("李逵",'男',20000 , 10000, null));
        two.add(new Employee("西门庆",'男',50000 , 100000, "被打"));
        two.add(new Employee("潘金莲",'女',3500 , 1000, "被打"));
        two.add(new Employee("武大郎",'女',20000 , 0, "下毒"));

        // 1. 开发一部的最高工资的员工
        // 指定大小规则了
//        Employee e = one.stream().max(( o1, o2) -> Double.compare((o1.getSalary() + o1.getBonus()), (o2.getSalary() + o2.getBonus())))
//                .get();
//        System.out.println(e);
        Topperformer t = one.stream().max(( o1, o2) -> Double.compare((o1.getSalary() + o1.getBonus()), (o2.getSalary() + o2.getBonus())))
                .map(e -> new Topperformer(e.getName(),e.getSalary() + e.getBonus())).get();
        System.out.println(t);


        // 2. 分别统计2个部门的平均月收入，去掉最高最低工资
        one.stream().sorted(( e1, e2) -> Double.compare((e1.getSalary() + e1.getBonus()),(e2.getSalary() + e2.getBonus())))
                .skip(1).limit(one.size() - 2).forEach(e -> {
                    // 求出总和，剩余员工的工资总和
            allMoneyone += (e.getBonus() + e.getSalary());
        });

        two.stream().sorted(( e1, e2) -> Double.compare((e1.getSalary() + e1.getBonus()),(e2.getSalary() + e2.getBonus())))
                .skip(1).limit(one.size() - 2).forEach(e -> {
            // 求出总和，剩余员工的工资总和
            allMoneytwo += (e.getBonus() + e.getSalary());
        });

        System.out.println("开发第一部的平均工资是：" + allMoneyone / (one.size() - 2));
        System.out.println("开发第二部的平均工资是：" + allMoneytwo / (one.size() - 2));

        // 合并两个集合，再统计
        Stream<Employee> s1 = one.stream();
        Stream<Employee> s2 = two.stream();
        Stream<Employee> s3 = Stream.concat(s1, s2);
        s3.sorted(( e1, e2) -> Double.compare((e1.getSalary() + e1.getBonus()),(e2.getSalary() + e2.getBonus())))
                .skip(1).limit(one.size() + two.size() - 2).forEach(e -> {
            // 求出总和，剩余员工的工资总和
            allMoneythree += (e.getBonus() + e.getSalary());
        });

        BigDecimal a = BigDecimal.valueOf(allMoneythree);
        BigDecimal b = BigDecimal.valueOf((one.size() + two.size()) - 2);
        System.out.println("开发部的平均工资是：" + (a.divide(b,2, RoundingMode.HALF_UP)));

    }
}

收集Stream流

public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌" ,"周芷若" ,"赵敏" ,"张强" ,"张三丰" ,"张三丰");
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));

//        List<String> zhang = s1.collect(Collectors.toList());
//        System.out.println(zhang);

        // 注意：流只能使用一次
//        Set<String> zhang2 = s1.collect(Collectors.toSet());
//        System.out.println(zhang2);

//        Object[] arrs = s1.toArray();
//        String[] arrs = s1.toArray((value) -> new String[value]);
        String[] arrs = s1.toArray(String[] :: new);
        System.out.println("Arrays数组内容：" + Arrays.toString(arrs));
    }
}

 

异常处理

异常概述、体系

 

 

常见运行时异常

public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。");
        /** 1.数组索引越界异常: ArrayIndexOutOfBoundsException。*/
        int[] arr = {1, 2, 3};
        System.out.println(arr[2]);
        // System.out.println(arr[3]); // 运行出错，程序终止

        /** 2.空指针异常 : NullPointerException。直接输出没有问题。但是调用空指针的变量的功能就会报错！！ */
        String name = null;
        System.out.println(name); // null
        // System.out.println(name.length()); // 运行出错，程序终止

        /** 3.类型转换异常：ClassCastException。 */
        Object o = 23;
        // String s = (String) o;  // 运行出错，程序终止

        /** 5.数学操作异常：ArithmeticException。 */
        //int c = 10 / 0;

        /** 6.数字转换异常： NumberFormatException。 */
        //String number = "23";
        String number = "23aabbc";
        Integer it = Integer.valueOf(number); // 运行出错，程序终止
        System.out.println(it + 1);

        System.out.println("程序结束。。。。。");

    }
}

常见编译时异常

异常的默认处理流程

编译时异常的处理机制

public class Test {
    public static void main(String[] args) throws Exception {
        System.out.println("程序开始。。。。。");
        parseTime("2011-11-11 11:11:11");
        System.out.println("程序结束。。。。。");
    }

    public static void parseTime(String date) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。");
        parseTime("2011-11-11 11:11:11");
        System.out.println("程序结束。。。。。");
    }

    public static void parseTime(String date) {
        // ctrl + alt + t
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);
        } catch (Exception e) {
            // 解析出现问题
            e.printStackTrace();
        }
    }
}

 

public class Test {
    public static void main(String[] args) throws Exception{
        System.out.println("程序开始。。。。。");
        // ctrl + alt + t
        try {
            parseTime("2011-11-11 11:11:11");
            System.out.println("成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序结束。。。。。");
    }

    public static void parseTime(String date) throws Exception{
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);
    }
}

运行时异常的处理机制

public class Test {
    public static void main(String[] args) {
        System.out.println("开始");
        try {
            chu(10 ,0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("结束");

    }

    public static void chu(int a ,int b) {
        int c = a / b;
        System.out.println(c);
    }
}

异常处理使代码更稳健的案例

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            try {
                System.out.println("输入价格");
                String priceStr = sc.nextLine();
                // 装换成Double类型
                double price = Double.valueOf(priceStr);

                // 判断价格是否大于0
                if (price > 0) {
                    System.out.println("定价" + price);
                    break;
                } else {
                    System.out.println("价格必须为正数");
                }
            } catch (NumberFormatException e) {
                System.out.println("输入数据有误");
            }
        }
    }
}

自定义异常

 

 

  

/**
 * 自定义的编译时异常
 * 1. 继承Exception
 * 2. 重写构造器
 */
public class myException extends Exception {
    public myException(String message) {
        super(message);
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            checkAge(-2);
        } catch (myException e) {
            e.printStackTrace();
        }


    }
    public static void checkAge(int age) throws myException {
        if (age <= 0) {
            // 抛出去一个异常对象给调用者
            // throw ：在方法内部直接创建一个异常对象，并从此点抛出
            // throws : 用在方法申明上的，抛出方法内部的异常
            throw new myException(age + "的年龄非法");
        }else {
            System.out.println("年龄正确");
        }
    }
}

/**
 * 自定义的运行时异常
 * 1. RuntimeException
 * 2. 重写构造器
 */
public class myException extends RuntimeException {
    public myException(String message) {
        super(message);
    }
}

public class Test {
    public static void main(String[] args) {
            checkAge(-2);
    }
    public static void checkAge(int age) {
        if (age <= 0) {
            // 抛出去一个异常对象给调用者
            // throw ：在方法内部直接创建一个异常对象，并从此点抛出
            // throws : 用在方法申明上的，抛出方法内部的异常
            throw new myException(age + "的年龄非法");
        } else {
            System.out.println("年龄正确");
        }
    }
}