java8新特性学习2

Z时代
2024-01-10
分类：综合

java

六、Stream API

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式

流(Stream) 到底是什么呢？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算！”
注意：
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。（也就是中间操作不会立即执行）

Stream操作分为三个步骤

 1、创建 Stream一个数据源（如：集合、数组），获取一个流

2、中间操作一个中间操作链，对数据源的数据进行处理

　 3、终止操作(终端操作)一个终止操作，执行中间操作链，并产生结果

　步骤一：创建Stream的四种方式

package com.bjsxt.stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
 * stream的三个步骤
 * 1、创建stream
 * 2、中间操作
 * 3、终止操作（终端操作）
 */
public class TestStream01 {
    public static void main(String[] args){
        test01();
    }
    /**
     * 创建stream的四种方式
     */
    public static void test01(){
        // 1、可以通过Collection系列集合提供的stream()或parallelStream()
        List<String> list=new ArrayList<String>();
        Stream<String> stream=list.stream();
        // 2、可以通过Arrays中的静态方法stream()获取数据流
        String[] strArr=new String[10];
        Stream<String> stream2=Arrays.stream(strArr);
        // 3、通过Stream类中的静态方法of()
        Stream<String> stream3=Stream.of("aa","bb","cc");
        // 4、创建无限流
        //方式一：迭代,使用Stream.iterate()方法
        Stream<Integer> stream4=Stream.iterate(0,(x)->x+2);
        //方式二：生成,使用Stream.generate()方法
        Stream<Double> stream5=Stream.generate(()->Math.random());
        stream5.forEach(System.out::println);   //这个forEach()方法是终端操作，打印用
    }
}

步骤二：中间操作

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

　　中间操作有很多种，主要有三种

　　1、筛选与切片

package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
 * stream
 * 中间操作
 */
public class TestStream02 {
    public static List<Person> list= Arrays.asList(
        new Person(1,"段然涛",18),
        new Person(2,"李飞宇",34),
        new Person(3,"卢晓倩",25),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(5,"罗泽成",12)
    );
    public static void main(String[] args){
    }
    /**
     * filter()方法
     */
    public static void tesst01(){
        Stream<Person> stream=list.stream();    //获取流
        stream.filter((per)->per.age>18)    //filter()接收 Lambda ， 从流中排除某些元素，会进行隐式迭代
                .forEach(System.out::println);  //这个是终端操作，这里使用只是方便打印
    }
    /**
     * limit()方法
     */
    public static void tesst02(){
        Stream<Person> stream=list.stream();    //获取流
        stream.filter((per)->per.age>18)    //filter()接收 Lambda ， 从流中排除某些元素
                .limit(2) //截断流，使其元素不超过给定数量。也就是只要筛选出来的前两个，这里操作类似于短路（&&），当筛选出来两个后，后面的就不再迭代，提高效率
                .forEach(System.out::println);  //这个是终端操作，这里使用只是方便打印
    }
    /**
     * skip()方法
     */
    public static void tesst03(){
        Stream<Person> stream=list.stream();    //获取流
        stream.filter((per)->per.age>18)    //filter()接收 Lambda ， 从流中排除某些元素
                .skip(2) //跳过前两个元素，跟limit刚好相反
                .forEach(System.out::println);  //这个是终端操作，这里使用只是方便打印
    }
    /**
     *distinct()方法
     */
    public static void tesst04(){
        Stream<Person> stream=list.stream();    //获取流
        stream.filter((per)->per.age>18)    //filter()接收 Lambda ， 从流中排除某些元素
                .distinct() //筛选，通过流所生成元素的 hashCode() 和 equals() 去 除重复元素
                .forEach(System.out::println);  //这个是终端操作，这里使用只是方便打印
    }
}

　　2、映射

package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
 * stream
 * 中间操作
 */
public class TestStream03 {
    public static List<Person> list= Arrays.asList(
        new Person(1,"段然涛",18),
        new Person(2,"李飞宇",34),
        new Person(3,"卢晓倩",25),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(5,"罗泽成",12)
    );
    public static void main(String[] args){
        tesst02();
    }
    /**
     * map()方法
     */
    public static void tesst01(){
        Stream<Person> stream=list.stream();    //获取流
        stream.map((person -> person.getName()))    //接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
                .forEach(System.out::println);
        System.out.println("-----------------------------------------------------------------------------");
        List<String> list=Arrays.asList("aa","bb","cc");
        list.stream().map(str->str.toUpperCase())
                .forEach(System.out::println);
    }
    /**
     * flatMap()方法
     */
    public static void tesst02(){
        List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
        Stream<Stream<Character>> stream=strList.stream().map(TestStream03::splitString);
        stream.forEach(sm->sm.forEach(System.out::println));    //如果使用map需要这样遍历
        System.out.println("------------------------------");
        /**
         * map和flatMap的区别就如集合中add(集合)和addAll(集合)的区别
         */
        Stream<Character> stream2 = strList.stream()
                .flatMap(TestStream03::splitString);    //接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        stream2.forEach(System.out::println);
    }
    public static Stream<Character> splitString(String str){
        List<Character> list=new ArrayList<Character>();
        for(Character c:str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }
}

　　3、排序

package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
 * stream
 * 中间操作
 */
public class TestStream04 {
    public static List<Person> list= Arrays.asList(
        new Person(1,"段然涛",18),
        new Person(2,"李飞宇",34),
        new Person(3,"卢晓倩",25),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(5,"罗泽成",12)
    );
    public static void main(String[] args){
        tesst02();
    }
    /**
     * sorted()方法,按照自然顺序排序
     */
    public static void tesst01(){
        List<String> list=Arrays.asList("bb","aa","dd","ee");
        list.stream()
                .sorted()
                .forEach(System.out::println);
    }
    /**
     * sorted(Comparator<? super T> comparator)方法,需要传一个比较器过去，按照指定的比较器进行排序
     */
    public static void tesst02(){
        list.stream().sorted((e1,e2)->{
            if(e1.age==e2.age){
                return e1.name.compareTo(e2.name);
            }else{
                return e1.age.compareTo(e2.age);
            }
        }).forEach(System.out::println);
    }
}

步骤三：终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void，终止操作也有多种

　　1、查找与匹配

package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
/**
 * stream
 * 终止操作
 */
public class TestStream05 {
    public static List<Person> list= Arrays.asList(
        new Person(1,"段然涛",18),
        new Person(2,"李飞宇",34),
        new Person(3,"卢晓倩",25),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(4,"李小静",67),
        new Person(5,"罗泽成",12)
    );
    public static void main(String[] args){
        tesst01();
    }
    /**
     * 终止操作
     * allMatch——检查是否匹配所有元素
     * anyMatch——检查是否至少匹配一个元素
     * noneMatch——检查是否没有匹配的元素
     * findFirst——返回第一个元素
     * findAny——返回当前流中的任意元素
     * count——返回流中元素的总个数
     * max——返回流中最大值
     * min——返回流中最小值
     */
    public static void tesst01(){
        boolean b1=list.stream().allMatch(person -> person.getAge()>10);    //是否所有人的年龄大于10
        System.out.println(b1);
        boolean b2=list.stream().anyMatch(person -> person.getAge()>100);    //是否至少一个人的年龄大于100
        System.out.println(b2);
        boolean b3=list.stream().noneMatch(person -> person.getAge()>100);    //没有一个人的年龄大于100
        System.out.println(b3);
        Optional<Person> optional=list.stream() //Optional是一个容器。java8新出的，防止空指针异常
                .findFirst();    //取第一个
        Person person=optional.get();
        System.out.println(person);
        Optional<Person> optiona2=list.stream()
                .findAny(); //取任何一个
        Person person2=optional.get();
        System.out.println(person2);
        Long ll=list.stream().count();  //个数
        System.out.println(ll);
        Optional<Person> optiona3=list.stream().max((e1,e2)->{  //  取最大值，根据指定比较器
            if(e1.age==e2.age){
                return e1.name.compareTo(e2.name);
            }else{
                return e1.age.compareTo(e2.age);
            }
        });
        System.out.println(optiona3.get());
        Optional<Person> optiona4=list.stream().min((e1,e2)->{  //  取最小值，根据指定比较器
            if(e1.age==e2.age){
                return e1.name.compareTo(e2.name);
            }else{
                return e1.age.compareTo(e2.age);
            }
        });
        System.out.println(optiona4.get());
    }
}

　　2、归约

package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.stream.Collector;
import java.util.stream.Collectors;
/**
 * stream
 * 终止操作
 */
public class TestStream06 {
    public static List<Person> list= Arrays.asList(
        new Person(1,"段然涛",18),
        new Person(2,"李飞宇",34),
        new Person(3,"卢晓倩",25),
        new Person(4,"李小静",67),
        new Person(4,"李小静",18),
        new Person(4,"李小静",67),
        new Person(5,"罗泽成",12)
    );
    public static void main(String[] args){
        tesst01();
    }
    /**
     *reduce()规约    可以将流中元素反复结合起来，得到一个值。返回 T
     */
    public static void tesst01(){
        List<Integer> list1=Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer integer=list1.stream().reduce(0, (x,y)->x+y);    //0是起始值。然后0+1+2+3+4+5+...
        System.out.println(integer);
        System.out.println("---------------------------------------------");
        Optional<Integer> optional=list.stream()
                .map(Person::getAge)
                .reduce(Integer::sum);
        System.out.println(optional.get());
    }
｝

　　3、收集

package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.stream.Collector;
import java.util.stream.Collectors;
/**
 * stream
 * 终止操作
 */
public class TestStream06 {
    public static List<Person> list= Arrays.asList(
        new Person(1,"段然涛",18),
        new Person(2,"李飞宇",34),
        new Person(3,"卢晓倩",25),
        new Person(4,"李小静",67),
        new Person(4,"李小静",18),
        new Person(4,"李小静",67),
        new Person(5,"罗泽成",12)
    );
    public static void main(String[] args){
        tesst02();
    }/**
     * collect(Collector c)方法
     * 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
     * Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。
     * 但是Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例
     */
    public static void tesst02(){
        //收集姓名放入list
        List<String> list2=list.stream()
                .map(Person::getName)
                .collect(Collectors.toList());
        list2.forEach(System.out::println);
        System.out.println("--------------------------------------------");
        //收集姓名放入set
        Set<String> set=list.stream()
                .map(Person::getName)
                .collect(Collectors.toSet());
        set.forEach(System.out::println);
        System.out.println("--------------------------------------------");
        //收集姓名放入指定的集合
        LinkedHashSet<String> linkedHashSet=list.stream()
                .map(Person::getName)
                .collect(Collectors.toCollection(LinkedHashSet::new));
        linkedHashSet.forEach(System.out::println);
        System.out.println("--------------------------------------------");
        //收集总个数
        Long count=list.stream()
                .collect(Collectors.counting());
        System.out.println(count);
        System.out.println("--------------------------------------------");
        //收集平均值
        Double integer=list.stream()
                .collect(Collectors.averagingDouble(Person::getAge));
        System.out.println(integer);
        System.out.println("--------------------------------------------");
        //收集总和
        Integer sum=list.stream()
                .collect(Collectors.summingInt(Person::getAge));
        System.out.println(sum);
        System.out.println("--------------------------------------------");
        //收集最大值
        Optional<Person> optional=list.stream()
                .collect(Collectors.maxBy((p1,p2)->Integer.compare(p1.getAge(),p2.getAge())));
        System.out.println(optional.get());
        System.out.println("--------------------------------------------");
        //收集最小值
        Optional<Person> optional2=list.stream()
                .collect(Collectors.maxBy((p1,p2)->-Integer.compare(p1.getAge(),p2.getAge())));
        System.out.println(optional2.get());
        System.out.println("--------------------------------------------");
        //分组,名字相同的分为一组
        Map<String,List<Person>> map=list.stream()
                .collect(Collectors.groupingBy(Person::getName));
        System.out.println(map);
        System.out.println("--------------------------------------------");
        //分组,名字相同的分为一组,名字相同再根据年龄分组
        Map<String,Map<String,List<Person>>> map1=list.stream()
                .collect(Collectors.groupingBy(Person::getName,Collectors.groupingBy((p)->{
                    if(p.getAge()>20){
                        return "青年";
                    }else{
                        return  "老年";
                    }
                })));
        System.out.println(map1);
        System.out.println("--------------------------------------------");
        //分区，只能分为两个区，true和false两个区,根据年龄40分为两个区
        Map<Boolean,List<Person>> map2=list.stream()
                .collect(Collectors.partitioningBy((e)->e.getAge()>40));
        System.out.println(map2);
        System.out.println("--------------------------------------------");
        //求总和。平均值。总数、最大值、最小值等等
        DoubleSummaryStatistics dss= list.stream()
                .collect(Collectors.summarizingDouble(Person::getAge));
        System.out.println(dss.getSum());
        System.out.println(dss.getAverage());
        System.out.println(dss.getCount());
        System.out.println("--------------------------------------------");
        //把姓名按照“，”分割
        String str=list.stream()
                .map(Person::getName)
                .collect(Collectors.joining(","));
        System.out.println(str);
        System.out.println("--------------------------------------------");
    }
}

七：并行流和串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。java8中的并行流底层就是采用的java的Fork/Join 框架

package com.bjsxt.forkJoin;
import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.stream.LongStream;
/**
 * Created by Administrator on 2019/3/7.
 */
public class TestForkJoin {
    public static void main(String[] args){
        test02();
    }
    public static void test02(){
        long start = System.currentTimeMillis();
        Long sum = LongStream.rangeClosed(0L, 10000000000L)
                .parallel()　　//切换到并行流
                .sum();
        System.out.println(sum);
        long end = System.currentTimeMillis();
        System.out.println("耗费的时间为: " + (end - start));
    }
}

这里有必要简单介绍下Fork/Join框架

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总

Fork/Join 框架与传统线程池的区别
采用 “工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能

案例：计算start与end之间的值的总和

package com.bjsxt.forkJoin;
import java.util.concurrent.RecursiveTask;
/**
 * 计算start与end之间的值的总和
 */
public class ForkJoinCalculate extends RecursiveTask<Long> {
    private long start;
    private long end;
    private static final long THRESHOLD = 100000L; //临界值
    public ForkJoinCalculate(long start, long end) {
        this.start = start;
        this.end = end;
    }
    /**
     *
     * @return
     */
    @Override
    protected Long compute() {
        long length=end-start;
        if(length<THRESHOLD){   //已经小于临界值
            long sum=0;
            for(long i=start;i<=end;i++){
                sum+=sum+i;
            }
            return sum;
        }else{  //没到临界值，需要继续分割任务
            long middle=(start+end)/2;
            ForkJoinCalculate left=new ForkJoinCalculate(start,middle);
            left.fork();
            ForkJoinCalculate right=new ForkJoinCalculate(middle+1,end);
            right.fork();
            return left.join()+right.join();
        }
    }
}

package com.bjsxt.forkJoin;
import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.stream.LongStream;
/**
 * Created by Administrator on 2019/3/7.
 */
public class TestForkJoin {
    public static void main(String[] args){
        test01();
    }
    public static void test01(){
        Instant strat=Instant.now();
        ForkJoinPool forkJoinPool=new ForkJoinPool();
        ForkJoinCalculate forkJoinCalculate=new ForkJoinCalculate(0,100000000000L);
        long sum=forkJoinPool.invoke(forkJoinCalculate);
        System.out.println(sum);
        Instant end=Instant.now();
        System.out.println("计算耗时:"+ Duration.between(strat,end).toMillis());
    }
}

八、Optional 类

Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常

package com.bjsxt.optiona;
import com.bjsxt.Person;
import java.util.Optional;
/**
 * 一、Optional 容器类：用于尽量避免空指针异常
 *     Optional.of(T t) : 创建一个 Optional 实例
 *     Optional.empty() : 创建一个空的 Optional 实例
 *     Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 *     isPresent() : 判断是否包含值
 *     orElse(T t) :  如果调用对象包含值，返回该值，否则返回t
 *     orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 *     map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
 *     flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
 */
public class TestOptiona {
    public static void main(String[] args){
        test01();
    }
    public static void test01(){
        Optional<Person> optional=Optional.of(new Person());    //如果of()方法里面的值为null,下面一句会发生空指针异常
        Person p=optional.get();    //获取Optional容器中的值
        System.out.println(p);
    }
    public static void test02(){
        Optional<Person> optional=Optional.empty(); //创建一个空的 Optional 实例
        Optional<Person> optiona2=Optional.ofNullable(new Person());//若 参数 不为 null,创建 Optional 实例,否则创建空实例
    }
    public static void test03(){
        Optional<Person> optiona2=Optional.ofNullable(new Person());//若 参数 不为 null,创建 Optional 实例,否则创建空实例
        if(optiona2.isPresent()){   //判断Optional容器中是否包含值
            System.out.println("有值。。。");
        }
        Person p1 = optiona2.orElse(new Person(1,"张三",23)); //如果容器值为空，则值为orElse()方法的参数
        System.out.println(p1);
        Person p2 = optiona2.orElseGet(() -> new Person()); //同orElse()，只不过参数是一个函数式接口
        System.out.println(p2);
    }
    public void test04(){
        Optional<Person> op = Optional.of(new Person(1,"张三",23));
        Optional<String> op2 = op.map(Person::getName);
        System.out.println(op2.get());
        Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName()));
        System.out.println(op3.get());
    }
}