011—JAVA新特性StreamAPI

创建 Stream方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

• public default Stream<E> stream() : 返回一个顺序流

• public default Stream<E> parallelStream() : 返回一个并行流

创建 Stream方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

• public static <T> Stream<T> stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

• public static IntStream stream(int[] array)：返回一个整型数据流

• public static LongStream stream(long[] array)：返回一个长整型数据流

• public static DoubleStream stream(double[] array)：返回一个浮点型数据流

创建 Stream方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

• public static<T> Stream<T> of(T... values) : 返回一个顺序流

创建 Stream方式四：创建无限流

• public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f):返回一个无限流

• public static<T> Stream<T> generate(Supplier<T> s) ：返回一个无限流

流的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

public class MiddleTest {
    @Test
    public void test05(){
        String [] strArr = {"hello","hello","kitty","Bob"};
        Arrays.stream(strArr)
                .flatMap(new Function<String, Stream<?>>() {
                    @Override
                    public Stream<?> apply(String s) {

                        System.out.print(s + " ");
                        System.out.println("---------------");
                        return Stream.of(s.split("")).distinct();
                    }
                }).forEach(System.out::println);


    }
    @Test
    public void test04(){

        Stream.of("hello","world")
                .map(String::toUpperCase)
                .forEach(System.out::println);
    }
    @Test
    public void test03(){
        Stream.of(7,6,1,2,3,4,5,1,2,3,7,8,9)
                .distinct()//去重
                .sorted()  //默认从小到大排序
//                .sorted((Integer::compare)
                .sorted(Comparator.reverseOrder())//倒叙
                .limit(3)//限制长度
                .skip(2)//跳过指定数量
                .forEach(System.out::println);

    }
    @Test
    public void test02(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Stream<Integer> integerStream = list.stream().filter((e) -> e % 2 == 0);

        System.out.println("list = " + list);

        /*//1:创建流
        Stream<Integer> stream = list.stream();
        //2中间操作
        Stream<Integer> stream1 = stream.distinct();
        //3：终止操作
        stream1.forEach(System.out::println);*/



    }
    @Test
    public void test01(){
        //1:创建流
        Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7);
        //2:中间操作
        /*stream.filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer % 2 == 0;
            }
        }).forEach(System.out::println);*/
        Stream<Integer> stream1 = stream.filter(integer -> true);
        //3:终止操作
        stream1.forEach(System.out::println);
    }

 

 流的终结操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void。流进行了终止操作后，不能再次使用。

 

public class EndTest {
    @Test
    public void test04() {
        List<Integer> list = Stream.of(1, 3, 5, 7, 9, 2, 4)
                .filter(k -> k % 2 != 0)
                .collect(Collectors.toList());//将奇数保存到数组中

        System.out.println("list = " + list);


    }

    @Test
    public void test03() {
        Stream.of(1, 3, 5, 6, 9, 2, 4)
                .filter(k -> k % 2 == 0)
                .forEach(System.out::println);


        Optional<Integer> max = Stream.of(1, 3, 5, 6, 9, 2, 4)
                .filter(k -> k % 2 == 0)
                .max(new Comparator<Integer>() {
                    @Override
                    public int compare(Integer o1, Integer o2) {
                        return o2 - o1;
                    }
                });
//                .max(Integer::compareTo);

        System.out.println("max = " + max);


    }
    @Test
    public void test02(){
        Optional<Integer> first = Stream.of(1, 3, 7, 9, 2, 4)
                .sorted()
                .peek(System.out::println)
                .findFirst();
        System.out.println("first = " + first);
       /* Stream<Integer> peek = Stream.of(1, 3, 7, 9, 2, 4)
                .sorted()
                .peek(System.out::println);*/
//        peek.forEach(System.out::println);

    }
    @Test
    public void test01(){

        /*boolean b = Stream.of(1, 3, 5, 7, 9, 2, 4)
                .filter(k -> k % 2 != 0) //过滤
                .allMatch(c -> c % 2 != 0)//匹配所有
                ;*/
//        System.out.println("b = " + b);
        Stream.of(1,3,5,7,9,2,4)
                .filter(k -> k % 2 == 0)
                .forEach(System.out::println);


    }

}

练习

现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以 下若干操作步骤：

1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。

2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。

3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。

4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。

5. 将两个队伍合并为一个队伍；存储到一个新集合中。

6. 根据姓名创建 Person 对象；存储到一个新集合中。

7. 打印整个队伍的Person对象信息。

public class Person {

    private String name;
    public Person(){}

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

    public String getName() {
        return name;
    }

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

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

public class PersonTest {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
//第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
        //第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
        List<String> list1 = one.stream()
                .filter(name -> name.length() == 3)
                .collect(Collectors.toList());
        System.out.println("list1 = " + list1);
        //第一个队伍筛选之后只要前3个人；存储到一个新集合中。
        List<String> list2 = one.stream()
                .limit(3)
                .collect(Collectors.toList());
        System.out.println("list2 = " + list2);
        //第二个队伍只要姓张的成员姓名；存储到一个新集合中。
        List<String> list3 = two.stream()
                .filter(str -> str.charAt(0) == '张')
                .collect(Collectors.toList());
        System.out.println("list3 = " + list3);
        //第二个队伍筛选之后不要前2个人；存储到一个新集合中。
        List<String> list4 = two.stream()
                .skip(2)
                .collect(Collectors.toList());
        System.out.println("list4 = " + list4);

        //将两个队伍合并为一个队伍；存储到一个新集合中。
        Stream<String> stream1 = one.stream();
        Stream<String> stream2 = two.stream();
        //Stream<String> concatStream = Stream.concat(stream1, stream2);
        /*List<String> list5 = concatStream.collect(Collectors.toList());
        System.out.println("list5 = " + list5);*/

        //根据姓名创建 Person 对象；存储到一个新集合中。
       /*concatStream.map(new Function<String, Person>() {
           @Override
           public Person apply(String s) {

               return new Person(s);
           }
       });*/
       //终止的流将不能进行二次操作
        Stream.concat(stream1, stream2).map(Person::new).forEach(System.out::println);


    }

}