Stream 、异常体系

目录

1️⃣不可变集合

⬛如何创建不可变集合❓

2️⃣Stream流

⬛什么是Stream流

⬛Stream流的获取

 ⬛Stream流的常用API

 ⬛Stream流的综合应用

 ⬛收集Stream流

 3️⃣异常处理

⬛异常体系

 ⬛常见的运行时异常

⬛常见的编译时异常（直接报错）

⬛异常的默认处理流程

 ⬛编译异常的处理机制

 ⬛自定义异常

---

1️⃣不可变集合

⬛如何创建不可变集合❓

        //1不可变的List集合
        List<Double> list = List.of(596.5,700.6,655.5,576.5);
        System.out.println(list);
        //2不可变的Set集合
        Set<String> names = Set.of("伊戈达拉","詹姆斯","库里","维金斯");
        System.out.println(names);
        //3不可变Map集合
        Map<String,Integer> maps = Map.of("java",2,"huawei",3,"iphone",5);
        System.out.println(maps );

总结：定义完成后不可以修改，添加或者删除。

List,Map,Set接口中都存在of方法创建不可变集合

2️⃣Stream流

⬛什么是Stream流

在Java 8 中，得益于Lambda所带来的函数式编程，引入全新Stream流概念

目的：用于简化集合和数组操作的API

⬛Stream流的获取

   

🔔集合获取Stream流的方式是通过调用Stream()方法实现的

 🔔数组获取Stream流通过Stream()方法或者Stream.of()实现的

      /**-----------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>> keyandvalyeStream = maps.entrySet().stream();

        /**-----------数组集合获取流-----------------*/
        String[] strings ={"赵敏","周芷若","灭绝"};
        Stream<String> stringStream = Arrays.stream(strings);
        Stream<String> stringStream2 = Stream.of(strings);

 ⬛Stream流的常用API

 

        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","张无忌","周芷若","赵敏","张强");

        //stream<T>filter(Predicazte<? 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.out.println(size);

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

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

 Map方法、合并流

      //Map加工方法  第一个参数是原材料 -> 第二个参数是加工之后的
        //在每个名字前面加上  中国的
//        list.stream().map(new Function<String, String>() {
//            @Override
//            public String apply(String s) {
//                return "中国的" + s;
//            }
//        });
        list.stream().map(s -> "中国的" + s).forEach(s -> System.out.println(s));

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

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

 

    

 ⬛Stream流的综合应用

 

package com.study.d2_stream;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamAnli {
    public static double allMoney = 0;
    public static double allMoney2 = 0;
    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("詹姆斯",'男',30000,2500,null));
        one.add(new Employee("浓眉",'男',27000,1500,"顶撞上司"));
        one.add(new Employee("库里",'男',29999,3500,null));
        one.add(new Employee("汤普森",'男',22100,3500,null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("朱婷",'女',32100,3500,null));
        two.add(new Employee("袁欣月",'女',22100,2500,null));
        two.add(new Employee("姚明",'男',42100,11500,"打人"));
        two.add(new Employee("郎平",'女',52100,3500,null));

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

       //2统计平均工资 要求去掉最高和最低
        one.stream().sorted((e1,e2) -> Double.compare(e1.getSalary()+e1.getBonus(),e2.getBonus()+ e2.getSalary()))
                .skip(1).limit(one.size() - 2).forEach(e ->{
                    //求出剩余员工的工资总和
            allMoney += (e.getBonus() + e.getSalary());
        });
        System.out.println("平均工资是" + allMoney / (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.getBonus()+ e2.getSalary()))
                .skip(1).limit(one.size() + two.size() - 2).forEach(e ->{
            //求出剩余员工的工资总和
            allMoney2 += (e.getBonus() + e.getSalary());
        });
        //BigDecimal大数据解决精度问题
        BigDecimal a = BigDecimal.valueOf(allMoney2);
        BigDecimal b = BigDecimal.valueOf(one.size() + two.size() - 2);
        System.out.println("开发部门平均工资是" + a.divide(b));

    }
}

 ⬛收集Stream流

 

/**
 收集Stream流到集合或数组中去
 */
public class StreamDemo5 {
    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> zhanglist = s1.collect(Collectors.toList());
        System.out.println(zhanglist);

        List<String> list2 = s1.toList();  //你不可以被修改
        System.out.println(list2);

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

        Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
        Object[] arrs = s2.toArray();
        System.out.println(Arrays.toString(arrs));
    }
}

  s1.collect(Collectors.toList())   toSet   toArray

 3️⃣异常处理

⬛异常体系

 ⬛常见的运行时异常

       //1数组越界异常 ArrayIndexOutOfBoundsException
        int[] arr = {11,22,33};
       // 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;

        //4数学操作异常 ArithmeticException
        //  int c = 10 / 0;

        //5数字转换异常 NumberFormatException
       // String number = "23";
        String number = "23aa";
        Integer it = Integer.valueOf(number);
        System.out.println(it);

运行时异常时因为自己水平有问题

⬛常见的编译时异常（直接报错）

 此时需要抛出异常 Alt+Enter

⬛异常的默认处理流程

 ⬛编译异常的处理机制

🏷️出现异常直接抛出去给调用者，调用者也继续抛出去

🏷️出现异常自己捕获

🏷️前两者结合

异常处理方式一----------------------throws

 

 

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("程序开始");
        try {
            parseTime("2022-11-11 11:11:11");
            System.out.println("成功");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("失败");
        }
        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);

        InputStream is = new FileInputStream("E:/meinv.jpg");
    }
}
//先把方法抛异常出去 继承Exception  然后在main方法中谁调用 谁在 try catch

 ⬛自定义异常

 

public class IleagalException extends Exception{
    public IleagalException() {
    }

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

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            checkage(-22);
        } catch (IleagalException e) {
            e.printStackTrace();
        }
    }
    public static void checkage(int age) throws IleagalException {
        if (age < 0 || age > 200){
            //抛出异常给调用者
            //throw:在方法内部直接创建一个异常对象，从此点抛出
            //throws:在方法申明上的，抛出方法内部的异常
            throw new IleagalException(age + " is illeagal");  //编译异常  若调用运行时异常不需要抛出（RunTimeException）
        }else {
            System.out.println("年龄合法");
        }
    }