java8中的Lambda表达式

java8中的Lambda表达式

概念：

• 在Java 8中，引入了Lambda表达式，这是一种更简洁和方便地表示匿名函数的方式。Lambda表达式主要用于函数式编程，它可以用来作为方法参数传递，或者在集合操作中进行函数式编程。Lambda表达式通常与Java的函数式接口（Functional Interface）一起使用，函数式接口是只包含一个抽象方法的接口。Lambda表达式可以实现这个唯一的抽象方法。

Lambda表达式的基本语法：

(parameter1, parameter2, ...) -> expression

Lambda表达式由以下几部分组成：

• 参数列表：这是方法参数的列表，可以包含零个或多个参数。
• 箭头符号 ->：箭头符号将参数列表与Lambda主体分隔开。
• Lambda主体：这是Lambda表达式的实际实现，可以是一个表达式或一个代码块。

Lambda表达式用例：

1. 无参数的Lambda表达式：

   () -> System.out.println("Hello, World!");
   

2. 带参数的Lambda表达式：

   (x, y) -> x + y
   

3. 带有多行代码块的Lambda表达式：

   (x, y) -> {
       int sum = x + y;
       System.out.println("Sum is: " + sum);
       return sum;
   }
   

Lambda中的演示案例

代码实例：

ArrayList<String> nameStrings = new ArrayList<>();
nameStrings.add("张三");
nameStrings.add("李四");
nameStrings.add("王五");
nameStrings.add("赵六");
// Lambda表达式通常与Java的函数式接口（Functional Interface）一起使用，函数式接口是只包含一个抽象方法的接口。
// Lambda表达式可以实现这个唯一的抽象方法。
nameStrings.forEach(name -> System.out.println("hello:  " + name ));

// 在 Java 8 中使用双冒号操作符(double colon operator)  
nameStrings.forEach(System.out::println);

1. 使用lambda进行排序

   // 生成字符串数组
   String[] players = {
       "Rafael Nadal", "Novak Djokovic",
       "Stanislas Wawrinka", "David Ferrer",
       "Roger Federer", "Andy Murray",
       "Tomas Berdych", "Juan Martin Del Potro",
       "Richard Gasquet", "John Isner"
   };
   // 平时的使用方式，去根据Name去做比较
   Arrays.sort(players, new Comparator<String>() {
       @Override
       public int compare(String o1, String o2) {
           return o1.compareTo(o2);
       }
   }
              );
   System.out.println("平时的写法:   " + Arrays.toString(players));
   
   
   // 使用lambda expression 排序players
   Arrays.sort(players, String::compareTo);
   System.out.println("使用Lambda表达式：" +Arrays.toString(players) );
   

2. 使用匿名内部类根据 surname 排序 players

• 平时写法

  Arrays.sort(
      players, new Comparator<String>() 
      {
          @Override
          public int compare(String o1, String o2) {
              return (o1.substring(o1.indexOf(" ")).compareTo(o2.substring(o2.indexOf(" ") )));}
  	}
  	);
  System.out.println("平时排序：" + Arrays.toString(players));
  

• 使用lambda表达式

  Arrays.sort(players, Comparator.comparing( (String s) -> s.substring(s.indexOf(" "))) );
  

3. 对名字的长度排序（使用匿名内部类根据 name lenght 排序 players）

   • 平时写法

     Arrays.sort(players, new Comparator<String>() {
         @Override
         public int compare(String o1, String o2) {
             return (o1.length() - o2.length());
         }
     });
     

   • 使用Lambda表达式

     Arrays.sort(players, Comparator.comparing(String::length));
     

Lambda和Stream流的结合使用

1. ​ 添加数据

   List<Person> javaProgrammers = new ArrayList<Person>() {
   {
   add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
   add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));
   add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));
   add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
   add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));
   add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));
   add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));
   add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));
   add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));
   add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));
   }
   };
   
   List<Person> phpProgrammers = new ArrayList<Person>() {
   {
   add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));
   add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));
   add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));
   add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));
   add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));
   add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));
   add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));
   add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));
   add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));
   add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));
   }
   };
   

2. 遍历所有程序员的名字

   System.out.println("所有程序员的姓名:");
   javaProgrammers.forEach( (javap) -> System.out.printf("%s %s; ", javap.getFirstName(), javap.getLastName()) );
   System.out.println("\n");
   phpProgrammers.forEach((php) -> System.out.printf("%s %s; ", php.getFirstName(), php.getLastName()));
   

3. 给salary全体增加5%

   //        增加程序员的工资5%:
   Consumer<Person> giveRaise = person -> person.setSalary( person.getSalary() / 100 * 5 +person.getSalary());
   javaProgrammers.forEach(giveRaise);
   System.out.println("\n");
   System.out.println(javaProgrammers);
   

4. 过滤处月薪超过1400的成员

   javaProgrammers.stream()
   .filter((person)-> person.getSalary() > 1400)
   .forEach(person -> System.out.printf("%s %s;    ", person.getFirstName(), person.getLastName()));
   

5. 获取年纪大于24的人数

   // 统计年龄大于24的人数
   long count = javaProgrammers.stream().filter(person -> person.getAge() > 24).count();
   System.out.println(count);
   

6. 可以自定义过滤器实现多重过滤

   //        自定义多个过滤器
   Predicate<Person> ageFilter = (person -> person.getAge() >25 );
   Predicate<Person> salaryFilter =(person -> person.getSalary()> 1400);
   Predicate<Person> genderFilter = (person -> person.getGender().equals("female"));
   System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:");
   javaProgrammers.stream()
   	.filter(ageFilter)
   	.filter(salaryFilter)
   	.filter(genderFilter)
   	.forEach(person -> System.out.printf("%s %s;    ", person.getFirstName(), person.getLastName()));
   

7. 使用limit进行限制结果集的个数

   • System.out.println("最前面的3个 Java programmers:");
     javaProgrammers.stream()
     	.limit(3)
     	.forEach(person -> System.out.printf("%s %s;    ", person.getLastName(), person.getLastName()));
     

   • System.out.println("根据 name 排序,并显示前5个 Java programmers:");
     javaProgrammers.stream()
     	.sorted(Comparator.comparing(Person::getFirstName))
     	.limit(5)
     	.collect(Collectors.toList())
     	.forEach((person -> System.out.printf("%s %s;   ", person.getFirstName(), person.getLastName())));
     

8. 根据 salary 排序 Java programmers

   System.out.println("\n根据 salary 排序 Java programmers:");
   javaProgrammers.stream()
   	.sorted(Comparator.comparing(Person::getSalary))
   	.collect(Collectors.toList())
   	.forEach((person -> System.out.printf("%s %s;   ", person.getFirstName(), person.getLastName())));
   

9. 如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法:

   Person person = javaProgrammers.stream().min(Comparator.comparing(Person::getSalary)).get();
   System.out.printf("person min:  " + person.getSalary());
   

   Person person1 = phpProgrammers.stream().max(Comparator.comparing(Person::getSalary)).get();
   System.out.printf("\nphpProgrammers salary max:   " + person1.getSalary());
   

10. 将 PHP programmers 的 first name 拼接成字符串:

    String personCollection = phpProgrammers.stream()
    	.map(Person::getFirstName)
    	.collect(joining(" ; "));
    System.out.printf("\n将 PHP programmers 的 first name 拼接成字符串:     " + personCollection);
    

11. Streams 还可以是并行的(parallel)。

```java
/*
* stream()：
		stream() 是顺序流，它会按照集合中元素的顺序来处理数据。每个操作都是在前一个操作完成后才会执行，因此操作是串行的。
		stream() 更适合于需要按照元素的顺序执行操作的情况，或者在数据量较小的情况下。
parallelStream()：
		parallelStream() 是并行流，它会将数据分成多个块，然后并行处理这些块。这意味着多个操作可以同时执行，提高了处理大数		 据集的效率。
		parallelStream() 更适合于需要处理大量数据或者可以并行执行的操作，比如对大型集合的过滤、映射或归约等操作。
*/

int sum = javaProgrammers.parallelStream().mapToInt(Person::getSalary).sum();
System.out.println("总计：" + sum);
```