Stream流的常用方法

public class list_01 {

    /*
     * .filter()方法,是模拟sql查询,
     * 查集合中包含某个元素
     * */

    @Test
    public void filter() {
        List<String> list = Arrays.asList("asd", "qwe", "zxc", "qaz", "wsx");
        //1.查出集合中含有"s"的元素,并转换成list集合
        Collection<String> s1 = list.stream().filter(s -> s.contains("s")).collect(Collectors.toList());
        System.out.println(s1);
        //2.查询出集合中"asd"的个数
        long asd = list.stream().filter(s -> s.equals("asd")).count();
        System.out.println(asd);


    }

    //.distint方法 ,去重
    @Test
    public void distic() {
        List<String> list = Arrays.asList("asd", "qwe", "zxc", "qaz", "wsx", "asd");
        List<String> collect = list.stream().distinct().collect(Collectors.toList());
        System.out.println(collect);
    }
    //sorted 排序(正序)
    @Test
    public void sort(){
        List<Integer> list = Arrays.asList(45, 12, 63, 36, 10, 8, 88);
        //1.排序 遍历输出
       // list.stream().sorted().forEach(num -> System.out.println(num));
        //2.排序
        list=list.stream().sorted().collect(Collectors.toList());
        System.out.println(list);
       // list.stream().
    }
    //倒序
    @Test
    public void usort() {
        List<Integer> list = Arrays.asList(45, 12, 63, 36, 10, 8, 88);
        Stream<Integer> sorted = list.stream().sorted(Comparator.reverseOrder());
        sorted.forEach(num -> System.out.println("倒序"+num));
        Collections.sort(list);
        System.out.println("正序"+list);
        Collections.reverse(list);
        System.out.println("倒序"+list);

    }

    //.filter方法
    @Test
    public void select() {
        ArrayList<String> list = new ArrayList<>();
        list.add("ydaiq");
        list.add("欧阳娜娜");
        list.add("汤唯");
        list.add("迪丽热巴");
        list.add("高圆圆");
        list.add("张三丰");
        list.add("张无忌");
        list.add("张阳");

        //使用Stream流的方式进行筛选
        //筛选以"张"开头的名字
        list.stream().filter(name -> name.startsWith("张"))
                //筛选长度为 3 的名字
                .filter(name -> name.length() == 3)
                //使用Stream流提供的 forEach 方法来输出
                .forEach(name -> System.out.println(name));
        //结果:  张三丰
        //       张无忌
    /*forEach() 方法接收的是一个 Consumer（Java 8 新增的一个函数式接口，接受一个输入参数并且无返回的操作）类型的参数，
    类名 :: 方法名是 Java 8 引入的新语法，System.out 返回 PrintStream 类，println 方法你应该知道是打印的。
    stream.forEach(System.out::println); 相当于在 for 循环中打印*/

        Stream<String> stream = list.stream().filter(name -> name.contains("阳"));
        stream.forEach(System.out::println);


    }
    //map()
    //该接口需要一个 Function 函数式接口作为参数,可以将当前流中的类型转换为另外一种类型.
    @Test
    public void map_01(){

            //创建一个流
            Stream<String> stream = Stream.of("1", "2", "4");  //String
            //使用map方法进行元素类型转换,将String类型转换为Integer类型

            Stream<Integer> stream1 = stream.map(obj -> Integer.parseInt(obj));
            //遍历
            stream1.forEach(i -> System.out.print(i));  //Integer
            //结果:1 2 4
    }
    //long count()
    //统计个数,是一个终极方法,所以不能够使用链式编程,返回值是 long 类型
    @Test
    public void count(){
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        System.out.println(list.stream().count());
    }
    //limit
    //用于截取一定长度的流中元素,是一个延时方法
    @Test
    public void limit_01(){
        String[]arr={"喜羊羊","美羊羊","灰太狼","红太狼"};
        Stream<String> str = Stream.of(arr);
        str.limit(2).forEach(name -> System.out.println(name+" "));


    }
    //concat
    //将两个流连接成一个,返回一个连接好的流
    @Test
    public void concat_01(){
        //获取两个Stream流
        String[] str = {"喜羊羊","美羊羊"};
        Stream<String> stream = Stream.of(str);
        Stream<String> stream2 = Stream.of("ydaiq", "wzz", "nicai", "zhangsan");

        //使用concat方法
        Stream<String> concatStream = Stream.concat(stream, stream2);

        //遍历
        concatStream.forEach(name -> System.out.print(name+" "));
        //结果:喜羊羊 美羊羊 ydaiq wzz nicai zhangsan
        //流穿换成数组
        Object[] objects = concatStream.toArray();
        //数组转换成集合
        List<Object> objects1 = Arrays.asList(objects);
        System.out.println(objects1);


    }
    //集合中元素的长度
    @Test
    public void length_01(){
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<Integer> stream = list.stream().map(String::length);
        stream.forEach(System.out::println);

    }
    /*
    * Stream 类提供了三个方法可供进行元素匹配，它们分别是：

    anyMatch()，只要有一个元素匹配传入的条件，就返回 true。

    allMatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全部匹配，则返回 true。

    noneMatch()，只要有一个元素匹配传入的条件，就返回 false；如果全部匹配，则返回 true。

    * */
    @Test
    public void match(){
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("王"));
        boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
        boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("沉"));
        System.out.println(anyMatchFlag);
        System.out.println(allMatchFlag);
        System.out.println(noneMatchFlag);

    }
    //.findFirst方法,获取集合第一个元素
    @Test
    public void first01(){
        List<String> list = Arrays.asList("qew", "asd", "zxc");
        Optional<String> first = list.stream().findFirst();
        System.out.println(first.get());
    }
}