devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java8新特性（Lamda、Stream、Option）_lamda 为空返回默认值

作者：weixin_40725706 | 2024-08-20 08:48:27

赞

踩

lamda 为空返回默认值

目录

Lamda

Stream

 ​编辑

Optional 

案例一：将一段字符串中的一部分进行排序

在Java8中，接口中的抽象方法默认被 public，abstract修饰符修饰，在Java8之前不允许普通方法存在接口中，在java8之后接口中可以存在普通方法，但是必须被static或者default修饰。

Lamda

好处：简化匿名内部类的调用

规范：使用lamda表达式需要依赖函数式接口

  • 一个接口只有一个抽象方法
  • 可以使用被static或者default修饰的方法
  • 接口被@FunctionalInterface修饰

例子

如果lamda表达式只有一个返回值可以不写大括号和return语句

  1.  List<Integer> list = Arrays.asList(1, 3, 2, 9, 7);
  2.  list.forEach(item-> System.out.println("我是"+item));
  3.  Collections.sort(list,(o1,o2)->{return o2-o1;});
  4.  System.out.println(list);

Stream

 

  1. +--------------------+       +------+   +------+   +---+   +-------+
  2. | stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
  3. +--------------------+       +------+   +------+   +---+   +-------+

  1.         //获取集合中大于2、并且经过排序、平方去重的有序集合
  2.         List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
  3.         List<Integer> collect = numbers.stream()
  4.                 .filter(item -> item > 2)
  5.                 .sorted((o1, o2) ->{return o2.compareTo(o1);})
  6.                 .map(i -> i * i)
  7.                 .distinct()
  8.                 .collect(Collectors.toList());
  9.         System.out.println(collect);
  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.IntSummaryStatistics;
  4. import java.util.List;
  5. import java.util.Random;
  6. import java.util.stream.Collectors;
  7. import java.util.Map;
  8.  
  9. public class Java8Tester {
  10.    public static void main(String args[]){
  11.  
  12.       System.out.println("使用 Java 8: ");
  13.       System.out.println("列表: " +strings);
  14.         
  15.       count = strings.stream().filter(string->string.isEmpty()).count();
  16.       System.out.println("空字符串数量为: " + count);
  17.         
  18.       count = strings.stream().filter(string -> string.length() == 3).count();
  19.       System.out.println("字符串长度为 3 的数量为: " + count);
  20.         
  21.       filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
  22.       System.out.println("筛选后的列表: " + filtered);
  23.         
  24.       mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
  25.       System.out.println("合并字符串: " + mergedString);
  26.         
  27.       squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
  28.       System.out.println("Squares List: " + squaresList);
  29.       System.out.println("列表: " +integers);
  30.         
  31.       IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
  32.         
  33.       System.out.println("列表中最大的数 : " + stats.getMax());
  34.       System.out.println("列表中最小的数 : " + stats.getMin());
  35.       System.out.println("所有数之和 : " + stats.getSum());
  36.       System.out.println("平均数 : " + stats.getAverage());
  37.       System.out.println("随机数: ");
  38.         
  39.       random.ints().limit(10).sorted().forEach(System.out::println);
  40.         
  41.       // 并行处理
  42.       count = strings.parallelStream().filter(string -> string.isEmpty()).count();
  43.       System.out.println("空字符串的数量为: " + count);
  44.    }
  45.    
  46. }

  1. 使用 Java 8: 
  2. 列表: [abc, , bc, efg, abcd, , jkl]
  3. 空字符串数量为: 2
  4. 字符串长度为 3 的数量为: 3
  5. 筛选后的列表: [abc, bc, efg, abcd, jkl]
  6. 合并字符串: abc, bc, efg, abcd, jkl
  7. Squares List: [9, 4, 49, 25]
  8. 列表: [1, 2, 13, 4, 15, 6, 17, 8, 19]
  9. 列表中最大的数 : 19
  10. 列表中最小的数 : 1
  11. 所有数之和 : 85
  12. 平均数 : 9.444444444444445
  13. 随机数: 
  14. -1743813696
  15. -1301974944
  16. -1299484995
  17. -779981186
  18. 136544902
  19. 555792023
  20. 1243315896
  21. 1264920849
  22. 1472077135
  23. 1706423674
  24. 空字符串的数量为: 2

Optional 

  1. import java.util.Optional;
  2.  
  3. public class Java8Tester {
  4.    public static void main(String args[]){
  5.    
  6.       Java8Tester java8Tester = new Java8Tester();
  7.       Integer value1 = null;
  8.       Integer value2 = new Integer(10);
  9.         
  10.       // Optional.ofNullable - 允许传递为 null 参数
  11.       Optional<Integer> a = Optional.ofNullable(value1);
  12.         
  13.       // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
  14.       Optional<Integer> b = Optional.of(value2);
  15.       System.out.println(java8Tester.sum(a,b));
  16.    }
  17.     
  18.    public Integer sum(Optional<Integer> a, Optional<Integer> b){
  19.     
  20.       // Optional.isPresent - 判断值是否存在
  21.         
  22.       System.out.println("第一个参数值存在: " + a.isPresent());
  23.       System.out.println("第二个参数值存在: " + b.isPresent());
  24.         
  25.       // Optional.orElse - 如果值存在，返回它，否则返回默认值
  26.       Integer value1 = a.orElse(new Integer(0));
  27.         
  28.       //Optional.get - 获取值，值需要存在
  29.       Integer value2 = b.get();
  30.       return value1 + value2;
  31.    }
  32. }

运行结果：

$ javac Java8Tester.java 
$ java Java8Tester
第一个参数值存在: false
第二个参数值存在: true
10

案例一：将一段字符串中的一部分进行排序

  1.  public static void main(String[] args) {
  2.         String str = "2-5-4-3-8-9";
  3.         Integer[] integers = Arrays.stream(str.split("-"))
  4.                 .map(Integer::parseInt)
  5.                 .sorted()
  6.                 .toArray(Integer[]::new);
  7.         String s = Arrays.toString(integers).replaceAll("，", "-");
  8.         String substring = s.substring(1, s.length() - 1);
  9.         System.out.println(substring);
  10.     }

案例二：查询list集合中性别时女的数据，如果为空要输出默认值

  1. public static void main(String[] args) {
  2.             List<UserEntity> userEntityList = new ArrayList<>();
  3.             UserEntity userEntityDefault = new UserEntity();
  4.             userEntityList.add(new UserEntity("1", "111", "male"));
  5.             userEntityList.add(new UserEntity("2", "222", "female"));
  6.             userEntityList.add(new UserEntity("3", "333", "male"));
  7.             userEntityList.add(new UserEntity("4", "444", "female"));
  8.             UserEntity userEntity1 = userEntityList.stream().filter(s-> Objects.equals(s.getO3(), "male")).findFirst().orElse(userEntityDefault);
  9.             System.out.println(userEntity1);
  10.     }

案例三

  1. public  class Trader{
  2.  
  3.     private String name;
  4.     private String city;
  5.  
  6.     public Trader(String n, String c){
  7.         this.name = n;
  8.         this.city = c;
  9.     }
  10.  
  11.     public String getName(){
  12.         return this.name;
  13.     }
  14.  
  15.     public String getCity(){
  16.         return this.city;
  17.     }
  18.  
  19.     public void setCity(String newCity){
  20.         this.city = newCity;
  21.     }
  22.  
  23.     public String toString(){
  24.         return "pojo1.Trader:"+this.name + " in " + this.city;
  25.     }
  26. }
  1. public class Transaction{
  2.  
  3.     private Trader trader;
  4.     private int year;
  5.     private int value;
  6.  
  7.     public Transaction(Trader trader, int year, int value)
  8.     {
  9.         this.trader = trader;
  10.         this.year = year;
  11.         this.value = value;
  12.     }
  13.  
  14.     public Trader getTrader(){
  15.         return this.trader;
  16.     }
  17.  
  18.     public int getYear(){
  19.         return this.year;
  20.     }
  21.  
  22.     public int getValue(){
  23.         return this.value;
  24.     }
  25.  
  26.     public String toString(){
  27.         return "{" + this.trader + ", " +
  28.                 "year: "+this.year+", " +
  29.                 "value:" + this.value +"}";
  30.     }
  31. }

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Trader raoul = new Trader("Raoul", "Cambridge");
  4.         Trader mario = new Trader("Mario","Milan");
  5.         Trader alan = new Trader("Alan","Cambridge");
  6.         Trader brian = new Trader("Brian","Cambridge");
  7.  
  8.         Transaction transaction2 = new Transaction(brian, 2011, 300);
  9.  
  10.         List<Transaction> transactions = Arrays.asList(
  11.                 new Transaction(brian, 2011, 300),
  12.                 new Transaction(raoul, 2012, 1000),
  13.                 new Transaction(raoul, 2011, 400),
  14.                 new Transaction(mario, 2012, 710),
  15.                 new Transaction(mario, 2012, 700),
  16.                 new Transaction(alan, 2012, 950)
  17.         );
  18.         //找出2011年发生的所有交易，并按交易额排序
  19.         List<Transaction> collect = transactions.stream().filter(transaction -> transaction.getYear() == 2011).sorted((o1,o2)->o1.getYear()-o2.getYear()).collect(Collectors.toList());
  20.         System.out.println(collect);
  21.         //交易员在哪些不同的城市工作过
  22.         List<String> collect1 = transactions.stream().map(transaction -> transaction.getTrader().getCity()).distinct().collect(Collectors.toList());
  23.         System.out.println(collect1);
  24.         //查找所有来自剑桥的交易员，并按姓名进行排序并且通过字符串连接返回
  25.         String cambridge = transactions.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge")).map(o1 -> o1.getTrader().getName()).distinct().sorted((o1, o2) -> o1.compareTo(o2)).collect(Collectors.joining(", "));
  26.         System.out.println(cambridge);
  27.         //有没有交易员在米兰工作
  28.         /**
  29.          * anyMatch表示，判断的条件里，任意一个元素成功，返回true
  30.          *
  31.          * allMatch表示，判断条件里的元素，所有的都是，返回true
  32.          *
  33.          * noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true
  34.          */
  35.         Boolean milanTrader = transactions.stream().anyMatch(transaction ->transaction.getTrader().getCity().equals("milan"));
  36.         System.out.println(milanTrader);
  37.         //打印生活在剑桥的交易员的所有交易额
  38.         transactions.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge")).forEach(o1-> System.out.println(o1.getValue()));
  39.  
  40.         //所有交易中，最高的交易额是多少
  41.         Optional<Integer> maxValue = transactions.stream()
  42.                 .map(Transaction::getValue)
  43.                 .distinct()
  44.                 .reduce(Integer::max);
  45.         System.out.println(maxValue);
  46.  
  47.         //最小交易额
  48.         Integer integer = transactions.stream()
  49.  
  50.                 .map(o1 -> o1.getValue())
  51.  
  52.                 .distinct()
  53.  
  54.                 .reduce(Integer::min).get();
  55. //        Optional<Integer> minValue = (Optional<Integer>) integer
  56.  
  57.         System.out.println(integer);
  58.  
  59.  
  60.         //将一段字符串中的一部分进行排序
  61.         String str = "2-5-4-3-8-9";
  62.         String collect2 = Arrays.stream(str.split("-")).sorted((o1, o2) -> o1.compareTo(o2)).collect(Collectors.joining(","));
  63.  
  64.         //
  65.         Transaction transaction3 = transactions.stream().filter(transaction -> transaction.getYear() == 2000).findFirst().orElse(transaction2);
  66.         System.out.println(transaction3);
  67.  
  68.  
  69.     }
  70. }
  1. [{pojo1.Trader:Brian in Cambridge, year: 2011, value:300}, {pojo1.Trader:Raoul in Cambridge, year: 2011, value:400}]
  2. [Cambridge, Milan]
  3. Alan, Brian, Raoul
  4. false
  5. 300
  6. 1000
  7. 400
  8. 950
  9. Optional[1000]
  10. 300
  11. {pojo1.Trader:Brian in Cambridge, year: 2011, value:300}

flatMap（）

  1. package cn.eva.test.demo2;
  2.  
  3. import java.util.List;
  4.  
  5. class Course {
  6.     String name;
  7.  
  8.     Course(String name) {
  9.         this.name = name;
  10.     }
  11.  
  12.     String getName() {
  13.         return name;
  14.     }
  15. }
  16.  
  17. class Student {
  18.     String name;
  19.     List<Course> courses;
  20.  
  21.     Student(String name, List<Course> courses) {
  22.         this.name = name;
  23.         this.courses = courses;
  24.     }
  25.  
  26.     List<Course> getCourses() {
  27.         return courses;
  28.     }
  29.     String getName() {
  30.         return name;
  31.     }
  32. }
  33.  
  34. class Class {
  35.     String name;
  36.     List<Student> students;
  37.  
  38.     Class(String name, List<Student> students) {
  39.         this.name = name;
  40.         this.students = students;
  41.     }
  42.  
  43.     List<Student> getStudents() {
  44.         return students;
  45.     }
  46. }
  47.  
  1.  public static void main(String[] args) {
  2.         List<Class> classes = Arrays.asList(
  3.                 new Class("Class A", Arrays.asList(
  4.                         new Student("Alice", Arrays.asList(new Course("Math"), new Course("Science"))),
  5.                         new Student("Bob", Arrays.asList(new Course("Math"), new Course("English")))
  6.                 )),
  7.                 new Class("Class B", Arrays.asList(
  8.                         new Student("Charlie", Arrays.asList(new Course("Science"), new Course("History"))),
  9.                         new Student("David", Arrays.asList(new Course("Math"), new Course("History")))
  10.                 ))
  11.         );
  12.  
  13.  
  14.         //获取所有班级的
  15.         List<String> studentNames = classes.stream()
  16.                 .flatMap(cls -> cls.getStudents().stream()) // 将每个班级的学生展开成单独的流
  17.                 .map(Student::getName)
  18.                 .collect(Collectors.toList()); // 收集到一个列表中
  19.         //获取所有课程信息
  20.         List<String> courseNames = classes.stream()
  21.                 .flatMap(cls -> cls.getStudents().stream()) // 将每个班级的学生展开成单独的流
  22.                 .flatMap(student -> student.getCourses().stream()) // 将每个学生的课程展开成单独的流
  23.                 .map(Course::getName) // 获取每门课程的名称
  24.                 .collect(Collectors.toList()); // 收集到一个列表中
  25.  
  26.         studentNames.forEach(System.out::println);
  27.         System.out.println("==============================================");
  28.         courseNames.forEach(System.out::println);
  29.     }

输出：

Alice
Bob
Charlie
David
==============================================
Math
Science
Math
English
Science
History
Math
History

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/1006236
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号