java8新特性 Stream

今天我们来学习一下java8的新特性，欢迎关注点赞。想要获取学习资料添加qq : 1184905186

一、接口的默认方法

Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，示例如下：

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Formula接口在拥有calculate方法之外同时还定义了sqrt方法，实现了Formula接口的子类只需要实现一个calculate方法，默认方法sqrt将在子类上可以直接使用

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

二、Lambda 表达式

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。

在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");


        Collections.sort(names,(String a,String b)->{

            return a.compareToIgnoreCase(b);
        });

        System.out.println(names);

在这里插入图片描述
对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：

Collections.sort(names,( a, b)->  a.compareToIgnoreCase(b));

三.Stream 接口

java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。Stream的操作可以串行执行或者并行执行。
首先看看Stream是怎么用，首先创建实例代码的用到的数据List：

List<String> list = new ArrayList<>();
        list.add("android");
        list.add("anna");
        list.add("mike");
        list.add("xenia");

Java 8扩展了集合类，可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream。下面几节将详细解释常用的Stream操作：
Filter 过滤

过滤通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于中间操作，所以我们可以在过滤后的结果来应用其他Stream操作（比如forEach）。forEach需要一个函数来对过滤后的元素依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行其他Stream操作。

        list.stream().filter((a)->a.startsWith("a")).forEach(System.out::println);

Sort 排序

排序是一个中间操作，返回的是排序好后的Stream。如果你不指定一个自定义的Comparator则会使用默认排序。

         List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");
        list.stream().sorted((a, b) -> a.compareToIgnoreCase(b)).forEach(System.out::println);
        //不会对原有的集合造成影响
        System.out.println(list);

在这里插入图片描述

Map 映射

中间操作map会将元素根据指定的Function接口来依次将元素转成另外的对象，下面的示例展示了将字符串转换为大写字符串。你也可以通过map来讲对象转换成其他类型，map返回的Stream类型是根据你map传递进去的函数的返回值决定的。

 List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        
        list.stream().map(String::toUpperCase).sorted((a, b) -> a.compareToIgnoreCase(b)).forEach(System.out::println);
        //不会对原有的集合造成影响
        System.out.println(list);

在这里插入图片描述

Match 匹配

Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是最终操作，并返回一个boolean类型的值。

       
        List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        //任意元素是 x 开头
        boolean anyMatch = list.stream().anyMatch((a) -> a.startsWith("x"));
        System.out.println("anyMatch: "+anyMatch);
        //所有元素是 x 开头
        boolean allMatch = list.stream().allMatch((a) -> a.startsWith("x"));
        System.out.println("allMatch: "+allMatch);
        //没有元素是 g 开头
        boolean noneMatch = list.stream().noneMatch((a) -> a.startsWith("g"));
        System.out.println("noneMatch: "+noneMatch);

        //不会对原有的集合造成影响
        System.out.println(list);

anyMatch: true
allMatch: false
noneMatch: true
[android, xenia, anna, mike]

Count 计数

计数是一个最终操作，返回Stream中元素的个数，返回值类型是long。

        List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        list.stream().filter((a) -> a.startsWith("a")).count();//2

Reduce 规约

这是一个最终操作，允许通过指定的函数来讲stream中的多个元素规约为一个元素，规越后的结果是通过Optional接口表示的：

 List<String> list = new ArrayList<>();
        list.add("android");
        list.add("xenia");
        list.add("anna");
        list.add("mike");

        Optional<String> a1 = list.stream().filter((a) -> a.startsWith("a")).reduce((a, b) -> a + "%%%" + b);//2
        System.out.println(a1);//Optional[android%%%anna]

并行Streams

前面提到过Stream有串行和并行两种，串行Stream上的操作是在一个线程中依次完成，而并行Stream则是在多个线程上同时执行。

下面的例子展示了是如何通过并行Stream来提升性能：

首先我们创建一个没有重复元素的大表

        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }

串行排序

        long t0 = System.nanoTime();
        System.out.println(values.stream().sorted().count());
        long t1 = System.nanoTime();

        long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
        System.out.printf("sequential sort took: %d ms",millis);//843ms

并行排序

        long t0 = System.nanoTime();
        System.out.println(values.parallelStream().sorted().count());

        long t1 = System.nanoTime();

        long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
        System.out.printf("parallel sort took: %d ms", millis);//370ms

上面两个代码几乎是一样的，但是并行版的快了50%之多，唯一需要做的改动就是将stream()改为parallelStream()。

风泊月

发布了320 篇原创文章 · 获赞 152 · 访问量 64万+

他的留言板关注