创建流的5种方式、筛选、映射、排序

一、创建流的5种方式

/**
     * 创建流的5种方式
     */
    public static void test1() {
        //1.可以通过Collection系列集合提供的stream()或paralleStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();


        //2.通过Arrays中的静态方法stream()获取数组流
        Employee[] emps = new Employee[10];
        Stream<Employee> stream2 = Arrays.stream(emps);

        //3.通过Stream类中的静态方法of()
        Stream<String> stream3 = Stream.of("aaa", "bbb", "ccc");


        //4.创建无限流
        //迭代（种子[起始值]，参数返回值相同的函数式流）
        Stream<Integer> stream4 = Stream.iterate(0, x -> x + 2);
        stream4.limit(10).forEach(System.out::println);//方法引用，所以不能再写成x->System.out::println,这就lambda和方法引用2掺儿了

        //5.生成 （供给型lambda流）
        //
        Stream<Double> generate = Stream.generate(() -> Math.random());
        generate.limit(5)
                .forEachOrdered(System.out::println);//方法引用，所以不能再写成x->System.out::println,这就lambda和方法引用2掺儿了
    }

 

 

二、筛选与切片

/**
     * 筛选与切片
     * filter   接收Lambda，从流中排除某些元素
     * limit    截断流，使袁术不超过给定的数量。
     * skip(n)  跳过元素，返回一个扔掉了前n个元素的流。若元素中不足n个，则返回一个空流。与limit(n)互补
     * distinct 筛选，通过流产生的元素的hashCode() 和 equals()去除重复元素
     */
    public static void test2() {
        List<Employee> emps = Arrays.asList(
                new Employee(101, "张三", 18, 9999.99),
                new Employee(102, "李四", 59, 6666.66),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );


        Stream<Employee> stream = emps.stream()
                                      .filter(x -> { //中间操作，不会执行任何操作
            System.out.println("Stream API 的中间操作");
            return x.getAge() > 35;
        });

        //终止操作：一次性执行全部内容，即"惰性求值"
        stream.forEach(System.out::println);


    }

执行结果：

Stream API 的中间操作
Stream API 的中间操作
Employee [id=102, name=李四, age=59, salary=6666.66]
Stream API 的中间操作
Stream API 的中间操作
Stream API 的中间操作
Employee [id=105, name=田七, age=38, salary=5555.55]

 

 

 

映射

<R> Stream<R> map(Function<? super T, ? extends R> mapper);
Funciton是函数型接口，只有一个入参，那么这个入参即【类:实例方法】调用的类对应的类型。
Funciton没有第二个参数，所以【类:实例方法】--> 【实例方法】没有参数。

    
    public static void test5() {
        Arrays.asList("aaa","bbb","ccc").stream()
                                        .map(x -> x.toUpperCase())
                                        .forEach(System.out::println);

        System.out.println("---------------");
        emps.stream()
            .map(Employee::getAge)
//            .map(x -> x*100)
            .forEach(System.out::println);

    }

 

    /**
     * 字符串转字符流
     * @param str
     * @return
     */
    public static Stream<Character> filterCharacter(String str) {
        List<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    /**
     * map流套流,相当于Collection.add(Collection) [['a','a','a'],['b','b','b'],['c','c','c']]
     */
    public static void test6() {
        Stream<Stream<Character>> streamStream = Arrays.asList("aaa", "bbb", "ccc").stream()
                .map(TestStream::filterCharacter);
        streamStream.forEach(x -> {
            x.forEach(System.out::println);
        });
    }

    /**
     * flatMap流套流相当于Collection.addAll(Collection)['a','a','a','b','b','b','c','c','c']
     */
    public static void test7() {
        Stream<Character> streamStream = Arrays.asList("aaa", "bbb", "ccc").stream()
                .flatMap(TestStream::filterCharacter);
        streamStream.forEach(System.out::println);
    }

 

 

排序

/**
     * sorted  默认排序
     * sorted(Comparator) 定制化排序
     */
    public static void test8() {
        emps.stream().sorted((x,y) -> {
           if(x.getAge() == y.getAge()) {
               return x.getName().compareTo(y.getName());
           } else {
               return Integer.compare(x.getAge(),y.getAge());
           }
        }).forEach(System.out::println);
    }