java进阶开发-----stream流，异常体系

（一），不可变集合

import java.util.List;
import java.util.Map;

//不可变集合
public class CollectionDemo {
    public static void main(String[] args) {
        //不可变List
        List<Double> lists= List.of(543.2,134.1,123.4,135.1);
        //lists.add(23.4);
        //lists.set(1.23.4);
        System.out.println(lists.get(2));//可以查看
        //Map和Set集合都一样
        Map<String, Integer> maps = Map.of("ssss",1,"wwww",2);
    }
}

 （二）、Stream流（流水线）

1.Stream初始

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
//初步体验Stream流
//找出姓张两个字的人
public class StreamTest {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三","张威威","张是");
        /*List<String> zhang1 = new ArrayList<>();
        for (String s : list1) {
            if (s.startsWith("张")){
                zhang1.add(s);
            }
        }
        List<String> zhang2 = new ArrayList<>();
        for (String s : zhang1) {
            if(s.length() == 3){
                zhang2.add(s);
            }
        }*/
        //Stream简化集合、数组操作的API，结合Lambda表达式（格式像传送带一样）
        list1.stream().filter(s -> s.startsWith("张")).filter(s ->             s.length()==3).forEach(s -> System.out.println(s));
    }
}

2.Stream流的获取

import java.util.*;
import java.util.stream.Stream;

//Stream流的获取
public class SreamTest2 {
    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> value = maps.values().stream();
        //键值对流
        Stream<Map.Entry<String, Integer>> entries = maps.entrySet().stream();
        //数组
        String[] st = {"aaa","sss","ddd"};
        Stream<String> names = Arrays.stream(st);
        Stream<String> name1 = Stream.of(st);
    }
}

3.Stream流的API

//Stream流API，不会改变原来的元素
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamTest1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张大");
        list.add("张参数");
        list.add("张给");
        list.add("张完全");
        //filter()过滤器
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");
            }
        });//之后Lambda表达式简化
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
        //Lambda取值互不影响
        //limit()取前几个数，skip()跳过前几个数
        //在集合加元素(加工)
        list.stream().map(new Function<String, String>(){

            @Override
            public String apply(String s) {
                return "无敌的" + s;
            }
        });
        list.stream().map(s -> "无双的" + s);
        //对象加工
        list.stream().map(s -> new Student0(s));
        //合并流(Stream.cincat())
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = Stream.of("ww","dd");
        Stream<String> s3 = Stream.concat(s1,s2);
    }
}

4.Stream流的相关应用

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;

public class StreamDemo4 {
    public static double allMoney;
    public static double allMoney1;
    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("aaa",'a',2323,224223,null));
        one.add(new Employee("ddd",'v',3223,238723,"asas"));
        one.add(new Employee("ccc",'a',4523,235323,null));
        one.add(new Employee("ddd",'d',1323,233223,null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("gfd",'f',2376,2243,null));
        two.add(new Employee("adf",'h',3224,2723,null));
        two.add(new Employee("afs",'q',4524,5223,null));
        two.add(new Employee("ryg",'w',4574,5423,null));
        two.add(new Employee("zzx",'t',1321,7523,"adf"));
        //找最大值
        Tapperfor employee = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBouns() , e2.getSalary() + e2.getBouns())).
                map(employee1 -> new Tapperfor(employee1.getName(),employee1.getSalary()+ employee1.getBouns())).get();
        System.out.println(employee);
        one.stream().sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBouns() , e2.getSalary() + e2.getBouns())).skip(1).limit(one.size()-2).forEach(employee1 -> {
            allMoney1 += (employee1.getSalary()+ employee1.getBouns());//skip跳过第一个数，limit取前面的数（在跳过的基础上取）
        });
        //解决精度问题
        BigDecimal a = BigDecimal.valueOf(allMoney1);
        BigDecimal b = BigDecimal.valueOf(one.size()-2);
        System.out.println(a.divide(b,2, RoundingMode.HALF_UP));
    }
}

5.Stream流收集

//收集Stream到数组或集合里
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.function.IntFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo5 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张额外");
        list.add("张稿文");
        list.add("张个人");
        list.add("张的");
        Stream<String> s = list.stream().filter(s1 -> s1.startsWith("张"));
        List<String> zhanglist = s.collect(Collectors.toList());
        //可以toSet,但是是不可变集合
        Set<String> zhanglist1 = s.collect(Collectors.toSet());
        Object[] arrs = s.toArray();//Array.toString(arrs)
        String[] arrs1 = s.toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(zhanglist);
        System.out.println(zhanglist1);//流只能使用一次

    }
}

 （二）、异常机制
1.异常处理类型

//运行时异常，继承RuntimeException
public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始编译...");
        //1.数组异常：ArrayIndexOutOfBoundsException
        int[] arr = {1,2,3,4};
        //System.out.println(arr[4]);
        //2.空指针异常：NullPointerException
        String name = null;
        System.out.println(name);
        //System.out.println(name.length());运行时错误
        //3.类型转换异常：ClassCastExecption
        Object o = 11;
        //String s = (String) o;
        //4.数学操作异常：ArithmeticExecption
        //int c = 10/0;
        //5.数字转换异常：NumberFormatExecption
        String num = "23kk";
        int it = Integer.valueOf(num);
        System.out.println(it);
    }
}

2.异常处理意义（提醒你可能发生的错误）

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExecptionDemo2 {
    public static void main(String[] args) throws ParseException {
        String date = "2015-01-12 10:23:21";
        //创建一个简单的格式化类
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD HH:KK:LL");
        //解析字符串时间成为对象
        Date d = sdf.parse(date);
        System.out.println(d);
    }
}

 3.异常处理使用

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExecptionDemo01 {
    public static void main(String[] args) throws ParseException, FileNotFoundException {
        System.out.println("程序开始");
        parseTime("2011-11-11 11:11:11");//连续抛出对应
        System.out.println("，程序结束...");
    }
    public static void parseTime(String date) throws ParseException, FileNotFoundException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-ddd FF:NN:KK");
        Date d = sdf.parse(date);//连贯抛出
        System.out.println(d);
    
        InputStream is = new FileInputStream("E:/mi");//多次抛出
        //可以直接Exception,但是没有提醒
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExecptionDemo01 {
    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) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-ddd FF:NN:KK");
        Date d = null;//连贯抛出
        try {
            d = sdf.parse(date);
        } catch (ParseException e) {
            //解析出现
            System.out.println("出现了解析时间异常！");
        }
        System.out.println(d);

        try {
            InputStream is = new FileInputStream("E:/mi");//多次抛出
        } catch (FileNotFoundException e) {
            System.out.println("你这文件找不到");
        }
        //有异常就执行catch后面的
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExecptionDemo01 {
    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) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-ddd FF:NN:KK");
            Date d = sdf.parse(date);//连贯抛出
            System.out.println(d);

            InputStream is = new FileInputStream("E:/mi");
        } catch (ParseException e) {
            System.out.println("解析错误");
            //e.printStackTrace();解析异常问题
        } catch (FileNotFoundException e) {
            System.out.println("找文件");
        }/*catch(异常|异常){//Exception e 统领
        }*/
        //有错误之后就处理该异常后直接停止，后面的异常也不处理了
        //还有一种，内部往外抛（throws）,外部解决异常（try,catch）
    }
}

public class ExecptionDemo3 {
    public static void main(String[] args) {
        System.out.println("程序开始...");
        try {
            chu(10,0);
        } catch (Exception e) {
            System.out.println("运算非法");
        }
        System.out.println("程序结束...");
    }
    public static void chu(int a,int b){
        System.out.println(a);
        System.out.println(b);
        int c = a/b;
        System.out.println(c);
    }
}

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true){
            try {
                System.out.println("请输入价格：");
                String price = sc.nextLine();
                //转化为double类型
                double p = Double.valueOf(price);
            } catch (Exception e) {
                System.out.println("用户输入的数据有问题！");
            }
        }
    }
}
//会出现的异常，提前处理，为了让程序更好的执行，让代码更稳健

4.定义异常

public class ExecptionDemo6 {
//定义编译时异常，编译器不会自带的异常定义
    public static void main(String[] args) {
        try {
            checkAge(-23);
        } catch (ItheimaAgelleagaIException e) {
            e.printStackTrace();
        }
    }
    public static void checkAge(int age) throws ItheimaAgelleagaIException {
        if(age < 0 || age > 200){
            //抛出一个异常
            //throw在方法内部创建异常对象，从中抛出
            //thows在方法申明，抛出方法内部异常
            throw new ItheimaAgelleagaIException(age + "is illeagal");
        }else {
            System.out.println("年龄合法！");
        }
    }
}
public class ItheimaAgelleagaIException extends Exception{
//extends RunTimeExecption,可定义运行时异常，也就是声明，但异常不用抛出，运行时才会出现，但建议使用，为了高效的编译代码
    public ItheimaAgelleagaIException() {
    }

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