JavaSE：Java8新特性

1.　　案例题目

　　　　　　准备一个List集合，并放入Person类型的对象，将集合中所有成年人过滤出来，放到另外一个集合，并打印出来。

 未使用Stream接口时：

public class ListPersonTest {

    public static void main(String[] args) {

        // 1.准备一个List集合并放入Person类型的对象后打印
        List<Person> list = new LinkedList<>();
        list.add(new Person("zhangfei", 30));
        list.add(new Person("xiaoqiao", 17));
        list.add(new Person("zhouyu", 20));
        list.add(new Person("zhangfei", 30));
        list.add(new Person("guanyu", 35));
        list.add(new Person("liubei", 40));
        for (Person tp: list) {
            System.out.println(tp);
        }

        System.out.println("-------------------------------------------------------");
        // 2.将List集合中所有成年人过滤出来并放入另外一个集合中打印
        List<Person> list1 = new LinkedList<>();
        for (Person tp : list) {
            if (tp.getAge() >= 18) {
                list1.add(tp);
            }
        }
        for (Person tp : list1) {
            System.out.println(tp);
        }
　　　　}
　　}

2.　　基本概念

　　　　　　<1>java.util.stream.Stream接口，是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选等操作

　　　　　　<2>Stream接口，借助于Lambda表达式，极大地提高编程效率和程序可读性，同时它提供串行和并行两种模式进行汇聚操作，

　　　　　　　　并发模式能够充分利用多核处理器的优势。

3.　　使用步骤

　　　　　　<1>创建Stream，通过一个数据源来获取一个流

　　　　　　<2>转换Stream, 每次转换返回一个新的Stream对象

　　　　　　<3>对Stream进行聚合操作并产生结果

4.　　创建方式

　　　　　　<1>　　方式一：通过调用集合的默认方法来获取流，如： default Stream stream()

　　　　　　<2>　　方式二：通过数组工具类中的静态方法来获取流，如： static IntStream stream (int[] array)

　　　　　　<3>　　方式三：通过Stream接口的静态方法来获取流，如：static Stream of (T... values)　　

　　　　　　<4>　　方式四：通过Strean接口的静态方法来获取流，如： static Stream generate (Supplier <? extends T> s)

5.　　中间操作

　　   筛选与切片的常用方法如下：

方法声明	功能介绍
Stream filter(Predicate <? super T> predicate)	返回一个包含匹配元素的流
Stream distinct()	返回不包含重复元素的流
Stream limit(long maxSize)	返回不超过给定元素数量的流
Stream skip(long n)	返回丢弃前n个元素后的流

　　　映射的常用方法如下：

方法声明	功能介绍
Stream map(Function<? super T, ? extends R> mapper)	返回每个处理过元素组成的流
Stream flatMap (Function<? super T, ? extends Stream<? extends R>> mapper)	返回每个被替换过元素组成的流，并将所有流合成一个流

　　    排序的常用方法如下：

方法声明	功能介绍
Stream sorted()	返回经过自然排序后元素组成的流
Stream sorted(Comparator <? super T> comparator)	返回经过比较器排序后元素组成的流

6.　　终止操作

　　　　　　匹配与查找的方法如下：

Optional findFirst()	返回该流的第一个元素
boolean allMatch(Predicate<? super T> predicate)	返回所有元素是否匹配
boolean noneMatch (Predicate <? super T> predicate)	返回没有元素是否匹配
Optional max (Comparator <? super T> comparator)	根据比较器返回最大元素
Otional min (Comparator <? super T> compatator)	根据比较器返回最小元素
long count()	返回元素的个数
void forEach(Consumer <? super T> action)	对流中每个元素执行操作

　　　　　　规约的常用方法如下：

Optional reduce(BinaryOperator accumulator)

返回结合后的元素值

　　　　　　收集的常用方法如下：

<R,A>R collect (Collector <? super T,A,R> collector)

使用收集器，对元素进行处理

7.　　使用Stream接口，实现案例题目(1.)的功能

package com.lagou.task22;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ListPersonTest {

    public static void main(String[] args) {

        // 1.准备一个List集合并放入Person类型的对象后打印
        List<Person> list = new LinkedList<>();
        list.add(new Person("zhangfei", 30));
        list.add(new Person("xiaoqiao", 17));
        list.add(new Person("zhouyu", 20));
        list.add(new Person("zhangfei", 30));
        list.add(new Person("guanyu", 35));
        list.add(new Person("liubei", 40));
        for (Person tp: list) {
            System.out.println(tp);
        }

        System.out.println("-------------------------------------------------------");
        // 2.将List集合中所有成年人过滤出来并放入另外一个集合中打印
        List<Person> list1 = new LinkedList<>();
        for (Person tp : list) {
            if (tp.getAge() >= 18) {
                list1.add(tp);
            }
        }
        for (Person tp : list1) {
            System.out.println(tp);
        }

        System.out.println("-------------------------------------------------------");
        // 3.使用Stream接口实现上述功能
        list.stream().filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() >= 18;
            }
        }).forEach(new Consumer<Person>() {
            @Override
            public void accept(Person person) {
                System.out.println(person);
            }
        });

        System.out.println("-------------------------------------------------------");
        // 4.使用lambda表达式对上述代码进行优化
        //list.stream().filter(person -> person.getAge() >= 18).forEach(person -> System.out.println(person));
        list.stream().filter(person -> person.getAge() >= 18).forEach(System.out::println);

        System.out.println("-------------------------------------------------------");
        // 5.实现对集合中元素通过流跳过2个元素后再取3个元素后打印
        list.stream().skip(2).limit(3).forEach(System.out::println);

        System.out.println("-------------------------------------------------------");
        // 6.实现集合中所有元素中的年龄获取出来并打印
        list.stream().map(new Function<Person, Integer>() {
            @Override
            public Integer apply(Person person) {
                return person.getAge();
            }
        }).forEach(System.out::println);

        //list.stream().map(person -> person.getAge()).forEach(System.out::println);
        list.stream().map(Person::getAge).forEach(System.out::println);

        System.out.println("-------------------------------------------------------");
        // 7.实现集合中所有元素的自然排序并打印
        list.stream().sorted().forEach(System.out::println);

        System.out.println("-------------------------------------------------------");
        // 8.判断集合中是否没有元素的年龄是大于45岁的
        boolean b1 = list.stream().noneMatch(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() > 45;
            }
        });
        System.out.println("b1 = " + b1); // true

        b1 = list1.stream().noneMatch(person -> person.getAge() > 45);
        System.out.println("b1 = " + b1); // true

        System.out.println("-------------------------------------------------------");
        // 9.按照指定的比较器规则获取集合所有元素中的最大值
        Optional<Person> max = list.stream().max(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("按照年龄排序后的最大值是：" + max);

        max = list.stream().max((o1, o2) -> o1.getAge() - o2.getAge());
        System.out.println("按照年龄排序后的最大值是：" + max);

        System.out.println("-------------------------------------------------------");
        // 10.实现将集合中所有元素的年龄映射出来并进行累加后打印
        Optional<Integer> reduce = list.stream().map(Person::getAge).reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        });
        System.out.println("最终所有年龄的累加和是：" + reduce); // 172

        //reduce = list.stream().map(Person::getAge).reduce(((integer, integer2) -> integer + integer2));
        reduce = list.stream().map(Person::getAge).reduce((Integer::sum));
        System.out.println("最终所有年龄的累加和是：" + reduce); // 172

        System.out.println("-------------------------------------------------------");
        // 11.实现将集合中所有元素的姓名映射出来并收集到集合中打印
        list.stream().map(Person::getName).collect(Collectors.toList()).forEach(System.out::println);
    }
}