lambada表达式常见应用，包含过滤，排序，类中属性值的取用等

lambada表达式常见应用整合

本文目标：
     1.了解什么是lambda表达式？
     2.lambada表达式相对于以往的编程带来了什么便利？
     3.使用lambada表示式可能会带来什么缺点？
      4.代码实例

     1.什么是lambada表达式？
     根据百度百科解释是：“Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。
     lambada表达式的结构：Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “ ->”，该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：左侧： 指定了 Lambda 表达式需要的方法参数列表←→右侧： 指定了 Lambda 体，即 Lambda 表达式要执行的功能。

     2.lambada表达式相对于以往的编程带来了什么便利？
     lambda表达式的便利之处就是：
       1）减少程序中for循环的使用，
       2）可以减少在项目中数据库的访问压力
       3）可以使代码看上去更加简洁
       4）随着反应式webflux的流行可能会成为未来编程主流

     3.使用lambada表示式可能会带来什么缺点？
      缺点就是 ：
        1）若不是并行计算，很多时候计算速度没有传统的for循环速度快，
        2）不容易调试
        3）代码对于没有学习过lambda表达式的同事不易看懂。

      4.代码实现

      这是我的pom文件：

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>26.0-jre</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2）由于未配置重要连接，这里忽略了yml文件和启动类。

3）创建一个实体类Person

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {

   private Integer id;
   private String name;
   private Integer age;
   private Integer sex;

	//有@Data注解忽略了get/set方法
}

4)在main方法中建立测试数据

public class PersonService {

    public static void main(String[] args) {
        List<Person> listP = Lists.newArrayList(
                new Person(1, "search", 10, 1),
                new Person(2, "jack", 5 ,0),
                new Person(3, "joo", 59, 0),
                new Person(4, "jack", 19,  0),
                new Person(5, "mark", 69, 1)
        );
	/**输出集合*/
    	listP.forEach(System.out::println);
		//	Person(id=1, name=search, age=10, sex=1)
			Person(id=2, name=jack, age=5, sex=0)
			Person(id=3, name=joo, age=59, sex=0)
			Person(id=4, name=jack, age=19, sex=0)
			Person(id=5, name=mark, age=69, sex=1)      	

     /**筛选年龄大于10的人员*/
        List<Person> pListGreater10 = listP.stream().filter(e -> e.getAge() > 10).collect(Collectors.toList());
        System.out.println("pListGreater10:" + pListGreater10);
		
		//pListGreater10:[Person(id=3, name=joo, age=59, sex=0), Person(id=4, //name=jack, age=19, sex=0), Person(id=5, name=mark, age=69, sex=1)]
	
	 /**取出前3个元素*/
        List<Person> personListBefore = listP.stream().limit(3).collect(Collectors.toList());
        System.out.println("personListBefore："+personListBefore);

		//personListBefore：[Person(id=1, name=search, age=10, sex=1), Person(id=2, name=jack, age=5, sex=0), Person(id=3, name=joo, age=59, sex=0)]


	 /**跳过前3个元素*/
        List<Person> personListSkip = listP.stream().skip(3).collect(Collectors.toList());
        System.out.println("personListSkip:"+personListSkip);

		//personListSkip:[Person(id=4, name=jack, age=19, sex=0), Person(id=5, name=mark, age=69, sex=1)]

	  /**取出某一属性的值的集合*/
        List<Integer> personListAge = listP.stream().map(Person::getAge).collect(Collectors.toList());

        List<Integer> personListAge1 = listP.stream().map(e->e.getAge()).collect(Collectors.toList());
        System.out.println("personListAge1:"+personListAge1);

		//personListAge1:[10, 5, 59, 19, 69],注上面显示的是2种方法

	 /**求出personist中年龄之和*/
    	Integer listPAge = listP.stream().map(Person::getAge).reduce(Integer::sum).orElse(0);
    	System.out.println("listPAllAge："+listPAge);
    	
		//listPAllAge：162

	 /**找出年龄最大的人*/
   		 Person personMaxAge = listP.stream().collect(Collectors.maxBy(Comparator.comparingInt(Person::getAge))).orElse(null);
  		 System.out.println("personMaxAge:"+personMaxAge);
		 
		 //personMaxAge:Person(id=5, name=mark, age=69, sex=1)
		
    /**计算平均年龄*/
    	Double averagePerson = listP.stream().collect(Collectors.averagingDouble(Person::getAge));
    	System.out.println("averagePerson:"+averagePerson);
    	
		//averagePerson:32.4

     /**以id作为key ，name 为value转为map集合*/
   		 Map<Integer,String> listPToMap = listP.stream().collect(Collectors.toMap(Person::getId,Person::getName));
    	 System.out.println("listPToMap:"+listPToMap);
		
		//listPToMap:{1=search, 2=jack, 3=joo, 4=jack, 5=mark}

	/**按照年龄大小排序*/
 		 List<Person> comparePerson = listP.stream().sorted(Comparator.comparingInt(e->e.getAge())).collect(Collectors.toList());
    	System.out.println("comparePerson"+comparePerson);
    	//comparePerson[Person(id=2, name=jack, age=5, sex=0), Person(id=1, name=search, age=10, sex=1), Person(id=4, name=jack, age=19, sex=0), Person(id=3, name=joo, age=59, sex=0), Person(id=5, name=mark, age=69, sex=1)]
}

上述对于list集合的lambda表达式可以应对大多数的集合操作。下面在来介绍几种简单的更加简单的应用:

    /**元素求和*/
    Integer sumNumber = asList(1,2,3,4).stream().reduce(0,Integer::sum);
    System.out.println("sumNumber:"+sumNumber);

	//sumNumber:10

	 /**集合元素个数*/
    Long count = asList(1,2,3,4).stream().count();
    System.out.println("count:"+count);
    
    //count:4

	/**集合中的元素是否都是1*/
    	Boolean flag = asList(1,2,3,4).stream().allMatch(e->e==1);
    	System.out.println("flag:"+flag);
		//flag:false

总结: 上述对于lambda表达式的总结只是我在工作中遇到的一些，比较少，希望能帮助到大家，最后愿大家工作顺利。