1.JAVA8新特性Stream流

最新推荐文章于 2023-12-13 20:55:07 发布
最新推荐文章于 2023-12-13 20:55:07 发布
阅读量615 收藏 4
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jkjkjksaggh/article/details/123592458
版权

目录

1.1 JAVA8新特性

1.2 接口定义方法

1.3 Lambda表达式

1.3.1 Lambda表达式的规范

1.3.2 函数接口定义

1.3.3 Lambda的基础语法

快速写出lambda表达式(new Consumer)

Lambda表达式精简写法的进

1.4 Lambda表达式遍历LIst

1.5 Stream流

*什么是stream流*

1.6 List转Set集合

1.7 List转换map

1.8 Stream将Reduce求和

1.9 Stream的Max和Min

1.10 StreamMatch 匹配

1.11 StreamFor过滤器

1.12 Stream 的排序sorted（略）

1.13 Stream 的分页limit 和 skip

1.14 并行流和串行流的区别

2 方法引入

2.1 方法引入之实例方法引入

2.2 构造函数方法的引入

2.3 对象方法引入的使用方法

3 java8新特性Optional

3.1 Optional判断对象是否为空

3.2 Optional过滤和判断默认值

默认值

过滤

3.3 Optional实战代码优化案例

3.4 orElseGet与orElse

继续简化，修改成方法引入的形式

1 JAVA8新特性

1.接口中默认方法修饰为普通方法

2.lambda表达式（重点）

3.函数接口

4.方法与构造函数引用 类名称：方法名称

5.Stream接口（重点）

1.2 接口定义方法

在JDK 1.8开始 支持使用static和default 修饰 可以写方法体，不需要子类重写。

方法：

普通方法 可以有方法体

抽象方法 没有方法体需要子类实现 重写。

​
public interface javaService {
    //不需要再impl书写实现
    void get();
}

​

1.3 Lambda表达式

  • LAMBADA 好处： 简化我们匿名内部类的调用。

  • Lambda+方法引入 代码变得更加精简。

​
public interface javaService {
    //不需要再impl书写实现
    void get();
}

​
public static void main(String[] args) {
        //lambda表达式
        ((javaService) () -> System.out.println("获取get数据")).get();
        //这个接口实现写在了下方
        new javaService() {
            @Override
            public void get() {
                System.out.println("获取get数据");
            }
        }.get();
    }

1.3.1 Lambda表达式的规范

使用Lambda表达式 依赖于函数接口

  1. 在接口中只能够允许有一个抽象方法
  2. 在函数接口中定义object类中方法
  3. 使用默认或者静态方法
  4. @FunctionalInterface 表示该接口为函数接口

1.3.2 函数接口定义

  1. 在接口中只能有一个抽象方法
  2. @FunctionalInterface 标记为该接口为函数接口
  3. 可以通过default 修饰为普通方法
  4. 可以定义object类中的方法

1.3.3 Lambda的基础语法

（） 参数列表

-> 分隔

{ } 方法体

(a,b)->{ }

快速写出lambda表达式(new Consumer)

list.forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        
    }
});

Lambda表达式精简写法的进

public interface javaService {
    //不需要再impl书写实现
    String get(int i,int j);
}
public static void main(String[] args) {
        //lambda表达式
        javaService javaservice = (i,j)->{
            return i+"==="+j;
        };
        System.out.println(javaservice.get(1,1));
    }

进一步简化：

  • 如果方法体中只有一条语句的情况下 可以不需要写{}

  • 如果方法体只有一条return的情况下不需要些{}和return

String s = ((javaService)(i,j) -> i+"=="+j).get(1,2);

1.4 Lambda表达式遍历LIst

    
public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        //正常遍历
//        for (String s: list) {
//            System.out.println(s);
//        }
       list.forEach(s -> {
           System.out.println(s);
       }); 
    }

1.5 Stream流

*什么是stream流*

Stream 是JDK1.8 中处理集合的关键抽象概念，Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

Stream ：非常方便精简的形式遍历集合实现 过滤、排序等。

1.6 List转Set集合

public static void main(String[] args) {
        ArrayList<School> Schools = new ArrayList<>();
        Schools.add(new School("eee","wwww"));
//        Schools.add(new School("aaa","sss"));
//        Schools.add(new School("aaa","sss"));
        /**
         * school的属性值都是相等的 但是new了两个对象 这两个对象的内存地址是不一样的 所以没去重
         */
        School school = new School("aaa","sss");
        Schools.add(school);
        Schools.add(school);
        /**
         * 创建流有两种方式：
         * 1.串行流stream()    单线程
         * 2.并行流parallelStream()    多线程
         * 并行流比串行流效率要高
         */
        Set<School> set = Schools.stream().collect(Collectors.toSet());
        System.out.println(set);
    }

1.7 List转换map

public static void main(String[] args) {
        ArrayList<School> Schools = new ArrayList<>();
        Schools.add(new School("eee","wwww"));
        Schools.add(new School("rrr","eee"));
        Schools.add(new School("aaa","sss"));
        Map<String, School> map = Schools.stream().collect(Collectors.toMap(new Function<School, String>() {
            @Override
            public String apply(School school) {
                return school.getName();
            }
        }, new Function<School, School>() {
            @Override
            public School apply(School school) {
                return school;
            }
        }));
        map.forEach(new BiConsumer<String, School>() {
            @Override
            public void accept(String s, School school) {
                System.out.println(s+"==="+school);
            }
        });

简化：

public static void main(String[] args) {
        ArrayList<School> Schools = new ArrayList<>();
        Schools.add(new School("eee","wwww"));
        Schools.add(new School("rrr","eee"));
        Schools.add(new School("aaa","sss"));
        Map<String, School> map = Schools.stream().collect(Collectors.toMap(school -> school.getName(), school -> school));
        map.forEach((s, school) -> System.out.println(s+"==="+school));
    }

1.8 Stream将Reduce求和

Stream.of用于为给定元素创建顺序流。我们可以传递单个元素或多个元素。

public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
        Optional<Integer> reduce = integerStream.reduce((integer, integer2) -> integer + integer2);
        System.out.println(reduce);
        }

1.9 Stream的Max和Min

public static void main(String[] args) {
        ArrayList<School> Schools = new ArrayList<>();
        Schools.add(new School("eee",44));
        Schools.add(new School("rrr",55));
        Schools.add(new School("aaa",11));
        Schools.stream().max((o1, o2) -> o1.getObjId()-o2.getObjId());
    }

1.10 StreamMatch 匹配

  • anyMatch表示，判断的条件里，任意一个元素成功，返回true

  • allMatch表示，判断条件里的元素，所有的都是，返回true

  • noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

public static void main(String[] args) {
        ArrayList<School> Schools = new ArrayList<>();
        Schools.add(new School("eee",44));
        Schools.add(new School("rrr",55));
        Schools.add(new School("aaa",11));
        boolean b = Schools.stream().anyMatch(new Predicate<School>() {
            @Override
            public boolean test(School school) {
                return "eee".equals(school.getName());
            }
        });
        System.out.println(b);
    }

1.11 StreamFor过滤器

public static void main(String[] args) {
        ArrayList<School> Schools = new ArrayList<>();
        Schools.add(new School("eee",44));
        Schools.add(new School("rrr",55));
        Schools.add(new School("aaa",11));
        Schools.add(new School("aaa",20));
        Schools.stream().filter(new Predicate<School>() {
            @Override
            public boolean test(School school) {
                return "aaa".equals(school.getName()) && school.getObjId() >= 20;
            }
        }).forEach(new Consumer<School>() {
            @Override
            public void accept(School school) {
                System.out.println(school);
            }
        });
    }

1.12 Stream 的排序sorted（略）

1.13 Stream 的分页limit 和 skip

public static void main(String[] args) {
        ArrayList<School> Schools = new ArrayList<>();
        Schools.add(new School("eee",44));
        Schools.add(new School("rrr",55));
        Schools.add(new School("aaa",11));
        Schools.add(new School("aaa",20));
        //mysql limit(0,2)  这里skip(1)表示跳过一条，limit(2)取两条数据
          Schools.stream().skip(1).limit(2).forEach(new Consumer<School>() {
          @Override
          public void accept(School school) {
              System.out.println(school);
          }
      });
    }

1.14 并行流和串行流的区别

串行流：单线程的方式操作； 数据量比较少的时候。

并行流：多线程方式操作；数据量比较大的时候，原理：

Fork join 将一个大的任务拆分n多个小的子任务并行执行，

最后在统计结果，有可能会非常消耗cpu的资源，确实可以

提高效率。

注意：数据量比较少的情况下，不要使用并行流。

2 方法引入

什么是方法引入

方法引入：需要结合lambda表达式能够让代码变得更加精简。

  1. 匿名内部类使用
  2. Lambda调用匿名内部类
  3. 方法引入

方法引入

  1. 静态方法引入： 类名::（静态）方法名称
  2. 对象方法引入 类名:: 实例方法名称
  3. 实例方法引入 new对象 对象实例::方法引入
  4. 构造函数引入 类名::new

需要遵循一个规范：

方法引入 方法参数列表、返回类型与函数接口参数列表与返回类型必须 要保持一致。

public interface javaService {
    void get(int i);
}
public class Test {
    public static void main(String[] args) {
        //正常调用
//        javaService javaService = (i) -> {
//            Test.test11(i);
//        };
//        javaService.get(1);
        //方法引用
        javaService test11 = Test::test11;
        test11.get(1);
    }
private static void test11(int i){
    System.out.println("方法");
}
}

2.1 方法引入之实例方法引入

方法引入 方法参数列表、返回类型与函数接口参数列表与返回类型必须 要保持一致。

public interface javaService {
    String get();
}
public class Test {
    public static void main(String[] args) {
        //lambda表达式写法
//        javaService java = ()-> "lambda表达式";
        //方法引用的写法
        javaService java = Test::objGet;
    }
    private static String objGet(){
        return "引用方法之实例方法";
    }
}

2.2 构造函数方法的引入

当返回类型是一个对象的时候，可以使用构造函数方法的引入

构造函数的引入：遵循的规范：函数接口返回值是对象,::new

public interface javaService {
    School get();
}
public class Test {
    public static void main(String[] args) {
        //lambda表达式写法
//        javaService java = ()->{
//            return new School();
//        };
        //构造方法的引入(注意这里不是类了，而是实体类)
        javaService java = School::new;
​
    }
}

2.3 对象方法引入的使用方法

Test必须和这个类相同

public interface javaService {
    String get(Test test);
}
public class Test {
    public static void main(String[] args) {
        javaService java = Test::objGet;
    }
}

3 java8新特性Optional

3.1 Optional判断对象是否为空

public static void main(String[] args) {
    String name = "111";
    /**
     * ofNullable 可以允许传递一个空值,会抛异常
     * of   不可以传递一个空值，会报空指针异常
     */
    Optional<String> name1 = Optional.ofNullable(name);
    System.out.println(name1.get());
    /**
     * 如果name1为空返回false，不为空返回会true
     */
    boolean present = name1.isPresent();
}

3.2 Optional过滤和判断默认值

默认值

public static void main(String[] args) {
    String name = null;
    Optional.ofNullable(name).orElse("如果为空默认值为");
}

过滤

public static void main(String[] args) {
    String name = null;
    Optional.ofNullable(name).filter(new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return "qq".equals(s);
        }
    }).isPresent();
}

3.3 Optional实战代码优化案例

public static void main(String[] args) {
        String name = null;
        Optional.ofNullable(name).ifPresent(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("不为空");
            }
        });
        //简化
        Optional.ofNullable(name).ifPresent(s -> System.out.println("不为空"));
        //可以调用构造方法引用
        Optional.ofNullable(name).ifPresent(System.out::print);
    }

3.4 orElseGet与orElse

public class Test {
    private static School school;
    public static void main(String[] args) {
        System.out.println(Test.getSchool());
    }
​
   public static School getSchool(){
//        if (school == null){
//            school = createSchool();
//        }
//        return school;
       /**
        * orElseGet-----写函数接口的形式赋值默认值           全局
        * orElse------直接传默认值            方法中
        */
       return Optional.ofNullable(school).orElseGet(new Supplier<School>() {
           @Override
           public School get() {
               school = createSchool();
               return school;
           }
       });
   }
​
   private static School createSchool(){
        return new School("1111",111);
   }
​
}

继续简化，修改成方法引入的形式

public class Test {
    private static School school;
    public static void main(String[] args) {
        System.out.println(Test.getSchool());
    }
​
   public static School getSchool(){
//        if (school == null){
//            school = createSchool();
//        }
//        return school;
       /**
        * orElseGet-----写函数接口的形式赋值默认值           全局
        * orElse------直接传默认值            方法中
        */
       return Optional.ofNullable(school).orElseGet(Test::orElseGet);
   }
​
   private static School createSchool(){
        return new School("1111",111);
   }
    //修改成方法引入
   private static School orElseGet(){
       school = createSchool();
       return school;
   }
}

public static String  getSchool(){
    //优化前的写法
//       School school = new School("aaa", 111);
//       if (school!=null){
//           String name = school.getName();
//           if (name!=null){
//               return name.toLowerCase();
//           }
//       }
//       return null;
        //优化后的写法
       return Optional.ofNullable(school).map(School -> School.getName()).map(name -> name.toLowerCase()).orElseGet(null);
   }

码神仙
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java8的新特性.doc
01-09
自己整理的java8新特性及demo 1. Lambda表达式 1 2. 方法的引用 6 3. 构造器引用 7 4. 函数式(Functional)接口 7 5. 四大函数式接口 8 6. Stream 11 7. Map接口的新方法： 19 8. 并行流与串行流 20 9. ...
java8新特性-最新
12-18
此文件为某知名培训机构的讲义，内容是 java8新特性 Lambda表达式 Stream流 内容比较新颖。
8. Java8新特性-默认方法（default method）
elegent Developer's 的博客
01-19 1404
传统上（< JDK8）接口中定义的方法都是public abstract的，都是没有实现的，实现接口的类必须为接口中定义的每一个方法提供实现，否则会有编译错误。 但一旦库的设计者需要更新接口，向其中加入新的方法，这种方式就会出现问题。 因为现存的实现类都不在库设计者的控制范围内，当项目升级JDK版本后，这些实体类为了适配更改后的接口，需要再修改，尤其是JDK8是非常重要的版本更新增加了大量方法。 所以库设计者为了避免出现大规模更改代码，方便大家升级到JDK8，引入了新的机制，即JDK8之后接口现在支持
java8 stream四大接口_【JDK8特性】Stream接口详解
weixin_33295562的博客
02-28 731
一、概念普及Java8新添加了一个特性：流Stream。Stream让开发者能够以一种声明的方式处理数据源(集合、数组等)，它专注于对数据源进行各种高效的聚合操作(aggregate operation)和大批量数据操作 (bulk data operation)。Stream API将处理的数据源看做一种Stream(流)，Stream(流)在Pipeline(管道)中传输和运算，支持的运算包含...
java8新特性 —— Stream流
LastNight_Will的博客
07-20 400
简单来说，我们可以使用 java.util.Stream 对一个集合（包含一个或多个元素）做各种操作。这些操作可能是 中间操作（中间操作会返回一个 Stream 流） 亦或是 终端操作（终端操作会返回一个结果）。需要注意的是，你只能对实现了 java.util.Collection 接口的类做流的操作。Stream 流支持同步执行，也支持并发执行。
Java8 新特性——Stream流
weixin_47203903的博客
12-08 1006
流Stream，可以让你以一种声明的方式处理数据。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。Stream（流）是一个来自数据源的元素队列并支持聚合操作和以前的Collection操作不同， Stream操作还有两个基础的特征：Stream提供以下功能：在 Java 8 中, 集合接口有两个方法来生成流：stream(
Java新特性Stream流详解
qq_42077317的博客
10-13 862
Stream是Java 8中非常重要的一个API，本文详细介绍了Java Stream流的概念、使用方法。通过Stream流，开发人员可以以声明式的方式对数据进行操作，使代码更加简洁、易读。iterate方法接受两个参数，第一个为初始化值，第二个为进行的函数操作，因为iterator生成的流为无限流，通过limit方法对流进行了截断，只生成3个偶数。API添加的一个新的抽象，以一种声明性方式处理数据集合（侧重对于源数据计算能力的封装，并且支持序列与并行两种操作方式）。1.创建Stream流。
Java8新特性Stream流实例详解
08-29
Stream流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。这篇文章主要介绍了Java8新特性Stream流的相关资料，需要的朋友参考下吧
java8新特性 stream流的方式遍历集合和数组操作
08-18
主要介绍了java8新特性 stream流的方式遍历集合和数组操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
java8新特性之流（Stream）操作总结
心藏_的博客
08-30 2299
java8新特新之Stream流的操作总结
Java8新特性：StreamAPI（超详解）
weixin_52533007的博客
03-31 7388
用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道。Stream 自己不会存储元素。Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
Java8新特性Stream详解
最新发布
程序员Forlan的博客
12-13 1559
本文详细介绍了Java中的Stream API，包括Stream的定义，操作分类以及具体操作方法。同时，通过综合使用示例，展示了Stream在实际问题解决中的能力。
Java8新特性之stream流
m0_51014049的博客
03-16 188
Java 8引入的Stream API提供了一种新的处理集合的方式，它可以使代码更加简洁和易读，同时还可以通过并行处理来提高程序的性能。
Java8新特性-Stream
qq_39093474的博客
04-27 471
Stream作为Java8的一大亮点，它与java.io包里的和是完全不同的概念，Stream是对集合的包装，通常和Lambda一起使用，使用stream可以支持许多操作，如 map, filter, limit, sorted, count, min, max, sum, collect 等等。流（Stream)到底是什么呢？是数据渠道，用于操作数据源（集合，数组等）所生成的元素序列。集合讲的是数据，流讲的是计算。Java8中的lambda。
JDK8新特性(Stream流)
chuyouyinghe的专栏
06-27 1292
一、Stream流的概念Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作，在新版的JPA【连接数据库】中，也已经加入了Stream。二、为什么要使用Stream流?每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环 是做事情的方式，而不是目的。每个需求都要循环一次，还要搞一个新集合来装数据，如果希望再次遍历，只能再使 用另一个循环从头开始。
简单使用lambda表达式
qq_44716544的博客
07-24 804
什么是lambda表达式？ Lambda 是一个 匿名函数，我们可以把 Lambda 表达式理解为是 一段可以传递的代码（将代码像数据一样进行传递）。 使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升 Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或 箭 头操作符。 它将 Lambda 分为两个部分：左侧：指定了 Lambda 表达式需要的参 参
Java8新特性Stream流
理想主义的花终将盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
12-26 989
​Stream不是集合元素，也不是数据结构，并不保存数据，它是有关算法和计算的，使用起来更像一个高级的迭代器，我们只需要给出需要对其流中的元素执行什么操作，Stream就会隐式的在内部进行遍历，作出相应的数据操作。​ Stream的处理是单向的，这一点和迭代器一样，数据只能遍历一次，一次过后就用完了，下一次得重头来，每次转换原有的Stream对象不会改变，而是返回一个新的Stream对象，这样就允许了操作可以是链式的。​
【Java8新特性】Stream流
m0_46628950的博客
07-08 708
在《java8 in action》书中，作者说目前我们在几乎所有开发中都会用到集合，但是目前集合在程序开发中的表现还不够完美，比如你利用集合处理大量数据时，你不得不面对性能问题，不得不考虑进行并行代码的编写，这些工作都是比较繁重的，于是作者便创造了Stream 流。相比较Collection集合来说，Stream在开发中就具有许多独特的优点。以声明式的方式处理数据集合——更简洁，更易读可复合——更灵活可并行——无需写任何多线程代码，Stream API自动处理这些问题，性能更好。
java1.8新特性stream流
09-12
Java 8引入了stream流作为一种新的特性。stream流是对集合进行处理的一种方式，它提供了一种函数式编程的...总结来说，Java 8新特性的stream流提供了一种方便、简洁的方式来处理集合数据，可以更高效地进行操作和处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值