Java-Stream流，异常捕获

Stream流

获取流

public class Streamdemo {
    public static void main(String[] args) {
        //所有集合都可以直接创建流
        List<String> names = new ArrayList<>();
        Set<String> nameset = new HashSet<>();
        Stream<String> name =names.stream();
        Stream<String> nameset1 =nameset.stream();
        System.out.println(name);

        //map创建流
        Map<String,Integer> maps = new HashMap<>();
        // 键流
        Stream<String> mapString = maps.keySet().stream();
        // 值流
        Stream<Integer> mapValue= maps.values().stream();
        // 键值对流
        Stream<Map.Entry<String, Integer>> keyandvalue =  maps.entrySet().stream();


        //数组流
        String[] strlist = {"a","b","c"};
        Stream<String> str1 = Stream.of(strlist);
        Stream<String> str2 = Arrays.stream(strlist);
        
    }
}

 常用api

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class Streamdeom2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        List<String> list1 = new ArrayList<>();
        Collections.addAll(list,"张*","张**","张***","张****");
        Collections.addAll(list1,"王*","王**","王***","王****");
//        list.stream().findFirst()
        list.stream().limit(3).forEach(s->System.out.println(s)); //前三位
        list.stream().skip(3).forEach(s->System.out.println(s)); //跳过前三位
        list.stream().filter(s -> s.startsWith("张")).forEach(s->System.out.println(s)); //过滤
        list.stream().distinct().forEach(s->System.out.println(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> newlist = list.stream();
        Stream<String> newlis1 = list1.stream();
        Stream.concat(newlist,newlis1).forEach(s -> System.out.println(s));  //合并流
        list.stream().sorted((e1,e2)->Double.compare(e1.getMoney() , e2.getMoney()))  //排序
        list.stream().max((e1,e2)->Double.compare(e1.getMoney() , e2.getMoney())) //取最大值

}
}
class Student{
    private String name;

    public Student(){};

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

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

    public String getName() {
        return name;
    }

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

收集成数组或集合

public class tolistdemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"王*","王**","王***","王****");
        Stream<String>  newstream = list.stream().filter(s -> s.startsWith("王"));
        List<String> list2 = newstream.collect(Collectors.toList()); //转成可变list
        list2.add("java");
        System.out.println(list2);
//        List<String> list2 = newstream.tolist() //转成不可变list

        Stream<String>  newstream1 = list.stream().filter(s -> s.startsWith("王"));
        Set<String> set1 = newstream1.collect(Collectors.toSet()); //转成set
        System.out.println(set1);
        Stream<String>  newstream2 = list.stream().filter(s -> s.startsWith("王"));
        Object[] list3 = newstream2.toArray(); //转成数组
        System.out.println(Arrays.toString(list3));
    }
}

 异常捕获

public class Trydemo {
    public static void main(String[] args) {
        String str = null;
        try {
           pritnlen(str);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("统一使用捕获所有异常，其他异常捕获了解即可");
        }finally{
            System.out.println("最后必执行");
      }
        
    }
    public static void pritnlen(String s){
        System.out.println(s.length());
    }
}

自定义异常捕获

public class Test {
    public static void main(String[] args) throws defineException {
        praseint(1);
        praseint1(-1);
    }

    public static void praseint(double d) throws defineException {
        if(d<0 || d>200){
            throw new defineException("编译时有异常，且需要把异常throws往上抛");
        }else {
            System.out.println("数据正确");
        }
    }

    public static void praseint1(double d) {
        if(d<0 || d>200){
            throw new definerunException("运行时有异常，异常throws可不往上抛");
        }else {
            System.out.println("数据正确2");
        }
    }
}

自动释放资源

package com.ruqi;


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class Filecopy {
    public static void main(String[] args) {
        filecopy("D:\\KwDownload\\song\\新建文本文档.txt","D:\\zhengqinjie\\新建文件夹\\1建.txt");
    }

    private static void filecopy(String tagetFile, String afterCopyFile) {
        //try(资源对象){}
        try (InputStream in = new FileInputStream(tagetFile);
             OutputStream out = new FileOutputStream(afterCopyFile);
             ){

            byte[] buffer = new byte[1024];
            int len;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
            System.out.println("复制完成");
        }catch (Exception e ){
            e.printStackTrace();
        }
    }
}