精华内容
下载资源
问答
  • java1.8常用的Lamdba表达式 Stream API

    千次阅读 2019-08-15 23:50:18
    Lambda表达式是一个匿名函数,运用Lambda表达式可以极大的提高编程效率程序可读性。 Java 8 中的 Stream 是对集合(Collection)对象功能的增强,对集合进行各种非常便利、高效的聚合操作,或者大批量数据操作。 ...

    Lambda表达式是什么,有什么用?

    Lambda表达式是一个匿名函数,运用Lambda表达式可以极大的提高编程效率和程序可读性。
    Java 8 中的 Stream 是对集合(Collection)对象功能的增强,对集合进行各种非常便利、高效的聚合操作,或者大批量数据操作。
    Stream 可以理解为高级版本的 Iterator。同时它提供串行和并行两种模式进行汇聚操作,并发模式能够充分利用多核处理器的优势,使用 fork/join 并行方式来拆分任务和加速处理过程。
     

    了解下lamdba表达式的组成:

    (str) -> System.out.println(str)

    左边代表参数,右边代表主体。

    (str) :代表参数,不写类型会根据上下文获取(str1),也可以自己定义参数(String str1),也可以有多个参数(String str1,String str2),也可以无参()。

    ->     :  理解为“转到”的意思

    System.out.println(str) : 代表主体,如果是代码块加上花括号{System.out.println(str1); System.out.println(str2);}

    废话少说,下面介绍下在项目中经常用到的Lamdba表达式

    常用的Lamdba表达式

    代替匿名内部类

    //before
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("123");
        }
    }).start();
    
    //after
    new Thread(() -> System.out.println("456")).start();

    forEach:循环List

    List<String> list = Arrays.asList("2", "b", "10", "4", "6", "aa", "b", "ccdf");
    
    //before
    for (String str : list) {
        System.out.println(str);
    }
    
    //after
    list.forEach((str) -> System.out.println(str));
    
    // double colon operator
    list.forEach(System.out::println);
    
    System.out.println("**********************************************");
    
    //before
    for (String str : list) {
        if (str.equals("a")) {
            System.out.println(str);
        }
    }
    
    //after
    list.forEach((str) -> {
        if (str.equals("a")) {
            System.out.println(str);
        }
    });

    sort :  对List进行排序

    List<String> list = Arrays.asList("2", "b", "10", "4", "6", "aa", "b", "ccdf");
    
    //before
    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });
    
    //after
    Comparator<String> sortByName = ((String s1, String s2) -> (s1.compareTo(s2)));
    list.sort(sortByName);
    
    //or
    list.sort((String s1, String s2) -> s1.compareTo(s2));

    map : 它的作用就是把 input Stream 的每一个元素,映射成 output Stream 的另外一个元素。

    List<String> list = Arrays.asList("a", "a", "b", "c", "d", "g", "a", "z", "c");
    
    //转换成大写
    List<String> output = list
            .stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
    System.out.println(output);
    
    //每个元素 都 加上"字母"
    List<String> collect = list
            .stream()
            .map(s -> s + "字母")
            .collect(Collectors.toList());
    System.out.println(collect);

    reduce  :  依照运算规则把 Stream 里所有的元素组合起来

    List<String> list = Arrays.asList("a", "a", "b", "c", "d", "g", "a", "z", "c");
    
    // 把字符串都连接在一起
    String reduce = list.stream().reduce("",String::concat);
    System.out.println(reduce);
    
    // 求最小值
    double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
    System.out.println(minValue);
    
    // 求和,有起始值
    int sumValue = Stream.of(1, 2, 3, 4).reduce(10, Integer::sum);
    System.out.println(sumValue);
    
    // 求和,无起始值
    sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
    System.out.println(sumValue);

    下面我们建一个实体类,进一步学习

    class Student {
            private int id;
            private String name;
            private int age;
            private String gender;
        //getter \ setter 构造器 省略
    }

    Collectors.groupingBy : 把 Stream 元素进行归组
    Collectors.partitioningBy 其实是一种特殊的 groupingBy

    List<String> list = Arrays.asList("a", "a", "b", "c", "d", "g", "a", "z", "c");
    //统计每个字母出现次数
    Map<String, Long> collect = list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    System.out.println(collect);
    
    System.out.println("**********************************************");
    
    //初始化测试数据
    List<Student> studentList = new ArrayList<Student>() {
        {
            add(new Student(1, "小明", 12, "男"));
            add(new Student(2, "小花", 18, "女"));
            add(new Student(3, "小白", 13, "女"));
            add(new Student(4, "小黑", 14, "男"));
        }
    };
    // 按照年龄进行分组
    Map<Boolean, List<Student>> baby = studentList
            .stream()
            .collect(Collectors.partitioningBy(s -> s.getAge() < 18));
    System.out.println("年龄小于18的人数: " + baby.get(true).size());
    System.out.println("年龄大于18的人数: " + baby.get(false).size());
    
    // 按照性别分组  返回集合对象
    Map<String, List<Student>> collect1 = studentList
            .stream()
            .collect(Collectors.groupingBy(Student::getGender));
    System.out.println(collect1);
    
    //按照性别分组  返回统计后的个数
    Map<String, Long> collect2 = studentList
            .stream()
            .collect(Collectors.groupingBy(Student::getGender, Collectors.counting()));
    System.out.println(collect2);

     

    ************************************进阶学习********************************************

    filter 、collect 、map 、limit 等等操作

    //初始化测试数据
    List<Student> studentList = new ArrayList<Student>() {
        {
            add(new Student(1, "小明", 12, "男"));
            add(new Student(2, "小花", 18, "女"));
            add(new Student(3, "小白", 13, "女"));
            add(new Student(4, "小黑", 14, "男"));
        }
    };
    
    //查出所有学生姓名
    studentList.forEach((s) -> System.out.println(s.getName()));
    
    System.out.println("**********************************************");
    
    //给所有的学生年龄加3岁
    Consumer<Student> studentConsumer = s -> s.setAge(s.getAge() + 3);
    studentList.forEach(studentConsumer);
    System.out.println(studentList);
    
    System.out.println("**********************************************");
    
    //使用过滤器filter ,查出小明的信息
    studentList.stream().filter((s) -> s.getName().equals("小明")).forEach((s) -> System.out.println(s));
    
    System.out.println("**********************************************");
    
    // 自定义一些 filter
    Predicate<Student> nameFilter = (s) -> s.getName().equals("小花");
    Predicate<Student> ageFliter = (s) -> s.getAge() > 10;
    studentList.stream().filter(nameFilter).filter(ageFliter).forEach(System.out::println);
    
    System.out.println("**********************************************");
    
    //limit 限制返回结果的个数
    studentList.stream().filter(ageFliter).limit(2).forEach(System.out::println);
    
    System.out.println("**********************************************");
    
    //排序sorted + 转换collect
    List<Student> collect = studentList
            .stream()
            .sorted((s1, s2) -> s1.getAge() - s2.getAge())
            .collect(Collectors.toList());
    System.out.println(collect);
    
    System.out.println("**********************************************");
    
    //获取最大 \ 最小 年龄
    Student studentMax = studentList
            .stream()
            .min((s1, s2) -> s1.getAge() - s2.getAge())
            //.max((s1, s2) -> s1.getAge() - s2.getAge())
            .get();
    System.out.println(studentMax);
    
    System.out.println("**********************************************");
    
    // map + collect 将结果集转成String 、 Set ...
    String studentNameStr = studentList
            .stream()
            .map(Student::getName)
            .collect(Collectors.joining(","));
    System.out.println(studentNameStr);
    
    Set<String> studentNameSet = studentList
            .stream()
            .map(Student::getName)
            .collect(Collectors.toSet());
    System.out.println(studentNameSet);
    
    System.out.println("**********************************************");
    
    //统计所有学生的年龄总和
    int sum = studentList
            .parallelStream()
            .mapToInt(s -> s.getAge())
            .sum();
    System.out.println(sum);
    参考文章: https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/
    展开全文
  • lamdba streamAPI

    2021-03-31 23:08:13
    lamdba streamAPI什么是streamstream的特性stream的运行机制Stream的创建(source)Stream的中间操作Stream的终止操作演示 什么是stream Stream是用来处理一组数组、集合的API 使用它的原因有两个: 代码简洁函数式...

    什么是stream

    Stream是用来处理一组数组集合的API

    使用它的原因有两个:

    • 代码简洁函数式变成写出的代码简洁且意图明确,使用stream接口让你从此告别for循环。
    • 多核友好,JAVA函数式编程使得编写并行程序从未如此简单,你需要的全部就是调用一下paralle()方法。

    stream的特性

    1. 不是数据结构,没有内部存储
    2. 不支持索引访问
    3. 延迟计算(在最终操作之前,中间操作代码不会实际执行)
    4. 支持并行
    5. 很容易生成数组或集合(List,Set)
    6. 支持过滤,查找,转换,汇总,聚合等操作

    stream的运行机制

    Stream分为 源source =>中间操作=> 终止操作

    流的源可以是一个数组、一个集合、一个生成器方法,一个I/O通道等等。

    一个流可以有零个和或者多个中间操作,每一个中间操作都会返回一个新的流,供下一个操作使用。一个流只会有一个终止操作

    Stream只有遇到终止操作,它的源才开始执行遍历操作

    Stream的创建(source)

    1、通过数组
    2、通过集合来
    3、通过Stream.generate方法来创建
    4、通过Stream.iterate方法来创建
    5、其他API创建

        /**
         * 通过数组方式
         */
        static void gen1(){
            String[] strs={"a","b","c","d"};
            Stream<String> stream = Stream.of(strs);
            //实例方法的引用
            stream.forEach(System.out::println);
        }
    
        /**
         * 通过集合的方式
         */
        static void gen2(){
            List<String> list= Arrays.asList("a","b","c","d");
            Stream<String> stream = list.stream();
            stream.forEach(System.out::println);
        }
    
        /**
         * generate()方法生成流会有无限长度,因此需要limit(10)限制
         */
        static void gen3(){
            Stream<Integer> stream = Stream.generate(() -> 1);
            stream.limit(10).forEach(System.out::println);
        }
    
        /**
         * iterate 迭代器的方式,同样需要限制长度,不然会无限增长
         */
        static void gen4(){
            Stream<Integer> stream = Stream.iterate(1, integer -> integer+1);
            stream.limit(10).forEach(System.out::println);
        }
    
        /**
         * 其他生成方式 IntStream也是流
         */
        static void gen5(){
            String str="asfghg";
            IntStream chars = str.chars();
            chars.forEach(System.out::println);
        }
    
    

    Stream的中间操作

    过滤 filter
    去重 distinct
    排序 sorted
    截取 limit、skip
    转换 map/flatMap
    其他 peek

        public static void main(String[] args) {
    
            List<Integer> Intlist=Arrays.asList(1,2,3,4,5,6,8);
            List<String> Stringlist = Arrays.asList("c#", "java", "python", "scala");
    
            /**
             * 如果返回对象是一个stream对象,就以为着是一个中间操作
             */
            //获取到集合中的偶数值
            Intlist.stream().filter(integer -> integer%2==0).forEach(System.out::println);
    
            //获取到集合中偶数的个数
            long count = Intlist.stream().filter(integer -> integer % 2 == 0).count();
    
            //获取到集合中偶数的和 (sum方法是 IntStream 的方法,因此需要mapToInt方法把Stream对象转换为IntStream对象)
            int sum = Intlist.stream().filter(integer -> integer % 2 == 0).mapToInt(x -> x).sum();
    
            //获取最大值
            Optional<Integer> max = Intlist.stream().max((a, b) -> a - b);
            Integer integer = max.get();
            System.out.println(integer);
    
            //获取最小值
            Integer integer1 = Intlist.stream().min((a, b) -> a - b).get();
            System.out.println(integer1);
    
            //获取符合条件元素的第一个元素
            Optional<Integer> first = Intlist.stream().filter(x -> x % 2 == 0).findFirst();
            System.out.println(first.get());
    
            //通过排序的方式取到最大值和最小值
            /**
             * sorted()方法不传递参数为自然排序,传递参数表示自定义比较器
             */
            Optional<Integer> minOptional = Intlist.stream().sorted().findFirst();
            Integer min = minOptional.get();
            System.out.println(min);
    
            Optional<Integer> maxOptional = Intlist.stream().sorted().sorted((a, b) -> b - a).findFirst();
            Integer maxx = maxOptional.get();
            System.out.println(maxx);
    
            //字符串排序并打印
            Stringlist.stream().sorted().forEach(System.out::println);
            //字符串按照长度排序
            Stringlist.stream().sorted((s1, s2) -> s1.length()-s2.length()).forEach(System.out::println);
    
            //使用收集器的方式把过滤后的元素转换成list
            List<Integer> collect = Intlist.stream().filter(a -> a % 2 == 0).collect(Collectors.toList());
    
    		//去重操作
            Arrays.asList(2,2,3,3,6,7).stream().distinct().forEach(System.out::println);
            Arrays.asList(2,2,3,3,6,7).stream().collect(Collectors.toSet()).forEach(System.out::println);
    
    
            //打印20-30的数字
            Stream.iterate(1,i->i+1).skip(20).limit(10).forEach(System.out::println);
    
    
            //把字符串转数字并计算和
            String str="11,22,33,44,55";
            System.out.println(Stream.of(str.split(",")).mapToInt(value -> Integer.parseInt(value)).sum());
            //方法引用的方式
            System.out.println(Stream.of(str.split(",")).mapToInt(Integer::parseInt).sum());
    
    
            //使用stream流 自定义一组对象
            Stringlist.stream().map(string -> new Persion(string)).forEach(System.out::println);
            Stringlist.stream().map(Persion::new).forEach(System.out::println);
            Stringlist.stream().map(string -> Persion.build(string)).forEach(System.out::println);
            Stringlist.stream().map(Persion::build).forEach(System.out::println);
    
            //把字符串转数字并计算和 并 打印
            int sum1 = Stream.of(str.split(",")).peek(System.out::println).mapToInt(Integer::parseInt).sum();
            System.out.println(sum1);
        }
    

    Stream的终止操作

    循环: forEach
    计算: min、max、count、 average
    匹配: anyMatch、 allMatch、 noneMatch、 findFirst、 findAny
    汇聚: reduce
    收集器 :toArray collect

    扩展:lamdba表达式四大接口

    • Consumer:消费型接口,内有抽象方法—void accept(T t)
    • Supplier:生产型接口(供给型),内有抽象方法—T get();
    • Function<T, R>:函数型接口,内有抽象方法—R apply(T t)
    • Predicate:断言型接口,内有抽象方法—boolean test(T t)
    展开全文
  • 需求描述:用mybatisPlus框架原生方法直接查到List<实体>,想要转换成List<展示层> 就这样的需求 方案1 function在方法里实现 ... import org.spring...import java.util.stream.Collectors; /** *.

    需求描述:用mybatisPlus框架原生方法直接查到List<实体>,想要转换成List<展示层> 就这样的需求

    方案1 function在方法里实现
    import com.baomidou.mybatisplus.core.metadata.IPage;
    import org.springframework.beans.BeanUtils;
    
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * 类 名: MybatisUtils
     * 描 述:
     * 作 者: binglong180
     * 创 建: 2020-07-20 15:26
     * 邮 箱: binglong172@163.com
     */
    
    public class MybatisUtils<T> {
    
      public <R>IPage convert(IPage<T> iPage,R y) {
        List collect =
          iPage.getRecords().stream().map(x -> {
            BeanUtils.copyProperties(x,y);
            return y;
          }).collect(Collectors.toList());
        return  iPage.setRecords(collect);
      }
    
    
    }
    
    方案2 直接传入Function
    展开全文
  • 基于JDK 1.8  1、循环: // 以前的循环方式 for (String player : players) { ...nums.stream().filter(num -> num != null).count();   转载于:https://www.cnblogs.com/liangblog/p/10330447.html

    基于JDK 1.8 

    1、循环:

    // 以前的循环方式  
    for (String player : players) {  
         System.out.print(player + "; ");  
    }  
      
    // 使用 lambda 表达式以及函数操作(functional operation)  
    players.forEach((player) -> System.out.print(player + "; "));  
       
    // 在 Java 8 中使用双冒号操作符(double colon operator)  
    players.forEach(System.out::println);  

    2、匿名内部类:

    // 使用匿名内部类
    btn.setOnAction(new EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
    System.out.println("Hello World!");
    }
    });

    // 或者使用 lambda expression
    btn.setOnAction(event -> System.out.println("Hello World!"));

    3、比较函数排序:

    //  使用 lambda expression 排序

    Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));

    Arrays.sort(players, sortByName);

    //  也可以采用如下形式:

    Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));

     4、结合Stream:

    //Lists是Guava中的一个工具类
    List<Integer> nums = Lists.newArrayList(1,null,3,4,null,6);
    nums.stream().filter(num -> num != null).count();

     

    转载于:https://www.cnblogs.com/liangblog/p/10330447.html

    展开全文
  • Lamdba optional-stream

    2019-12-15 22:13:00
    但是要说明的是stream流他操作串行操作(stream也就是并行实现parallelstream),所以执行的时候一会发现有的时候我们需要把stream流进行合并操作会很麻烦,下面的 flatMap起到了很大作用 list . stream ( ) . ...
  • 集合流,stream的运用和lamdba的涉及本文旨在探究lamdba表达式的使用以及jdk1.8中流的使用,且格式完全参照[csdn的markdown格式提示][6]在搞懂lambda之前,我们需要搞清楚什么叫做函数式接口 所谓函数式接口,就是...
  • Lamdba表达式(2) - Stream

    2019-10-01 17:35:06
    有了Lamdba表达式 , Java就具有了进行函数式编程的条件 但是作为彻底的面向对象语言 , 并不支持函数的独立存在 所以JDK1.8添加了Stream以及一些相关的接口 Stream的特点可以概括如下 Stream是元素的序列 , 看起来...
  • 随着学习的深入,jdk8的改变强大远超出我的理解。由lamdba表达式引起的再一次思考,先贴出来这一块的代码 List&lt;CartDTO&gt; cartDTOList = orderDTO.getOrderDetailList().stream().map((e) -&gt; ...
  • Java8新特性之四:Stream API例如Stream的操作步骤举个简单的例子:Stream中间操作--筛选与切片 与parallelStream并行流limit举例skip举例distinct举例Stream中间操作--映射map举例总结终止操作--查找与匹配allMatch...
  • 去重(基本类型数据的去重) 求和:count() 直接返回流的结果值 排序:sorted()(支持正序、逆序、Compare字段比较自定义字段比较 // 获取所有用户名卫hanmeimei的用户数据 List<A> firstA= AList.stream() ...
  • 随着学习的深入,jdk8的改变强大远超出我的理解。 由lamdba表达式引起的再一次思考,先贴出来这一块的代码 List&lt;CartDTO&gt; cartDTOList = orderDTO.getOrderDetailList().stream().map((e) -&...
  • Lamdba

    2017-09-15 10:38:14
    // 生成一个包含原Stream的所有元素的新Stream,同时会提供一个消费函数(Consumer实例),新Stream每个元素被消费的时候都会执行给定的消费函数 peoples.stream().peek(k-> { if(k.getAge()>1){ System.out....
  • 1.3 方法引用构造器 12 1.2.1 方法引用 12 1.2.2 构造器 12 1.4 Stream语法 13 1.3.1 入门案例 13 1.3.2 怎么得到Stream 15 1.3.3 转换Stream 16 1.3.4 汇聚Stream 19 2 Optional类 20 2.1 创建Optional容器 21 ...
  • Lamdba表达式

    万次阅读 2021-07-15 10:15:04
    lambda表达式使用心得lamdba简介Lambda语法Lambda重要特性Lambda 简例Lambda 常用例子 lamdba简介 Lambda作为函数式编程中的基础部分,在...它提供了更为简单的语法写作方式,允许你通过表达式来代替函数式接口。在一
  • Lamdba表达式 Lambda简介 Lambda 表达式是 JDK8 的一个新特性,可以取代大部分的匿名内部类,写出更优雅的 Java 代码,尤其在集合的遍历其他集合操作中,可以极大地优化代码结构。 JDK 也提供了大量的内置函数式...
  • Stream排序Map集合

    千次阅读 2019-03-11 19:45:13
    前置知识: Lamdba表达式 StreamApi map根据value倒序排序 map.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).forEach(System.out::println); map根据key倒序排序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,146
精华内容 458
关键字:

lamdba和stream