java lambda例子_Java lambda 表达式常用示例

实体类

package com.lkb.java_lambda.dto;

import lombok.Data;

/**

* @program: java_lambda

* @description: dto

* @author: lkb

* @create: 2020-01-19 17:15

*/

@Data

public class Person implements Comparable{

public Person(){}

public Person(int id, String name, int age, String addr, int gender, double salary,String remark){

this.id = id;

this.age = age;

this.name = name;

this.addr = addr;

this.gender = gender;

this.salary = salary;

this.remark = remark;

}

public Person(Person person) {

this.id = person.id;

this.name = person.name;

this.age = person.age;

this.addr = person.addr;

this.gender = person.gender;

this.salary = person.salary;

this.remark = person.remark;

}

@Override

public int compareTo(Person o) {

if(this.salary > o.getSalary()){

return 1;

}else{

return -1;

}

}

private int id;

private String name;

private int age;

private String addr;

/**

* 0-女 1-男

*/

private int gender;

private double salary;

private String remark;

}

测试类

package com.lkb.java_lambda;

import cn.hutool.json.JSONUtil;

import com.lkb.java_lambda.dto.Person;

import java.awt.print.Book;

import java.util.*;

import java.util.function.Predicate;

import java.util.stream.Collectors;

/**

* @program: java_lambda

* @description: 测试类

* @author: lkb

* @create: 2020-01-19 17:18

*/

public class Test {

private static List personList = new LinkedList<>();

private static void init(){

Person person = new Person();

person.setId(1);

person.setName("Lisa");

person.setGender(0);

person.setAge(24);

person.setAddr("中国深圳");

person.setSalary(15000d);

personList.add(person);

person = new Person();

person.setId(2);

person.setName("Tom");

person.setGender(1);

person.setAge(27);

person.setAddr("中国深圳");

person.setSalary(18000d);

personList.add(person);

person = new Person();

person.setId(3);

person.setName("Benny");

person.setGender(1);

person.setAge(22);

person.setAddr("中国北京");

person.setSalary(22000d);

personList.add(person);

person = new Person();

person.setId(4);

person.setName("Jenny");

person.setGender(0);

person.setAge(29);

person.setAddr("中国上海");

person.setSalary(33000d);

personList.add(person);

person = new Person();

person.setId(5);

person.setName("David");

person.setGender(1);

person.setAge(37);

person.setAddr("中国北京");

person.setSalary(22000d);

personList.add(person);

}

public static void main(String[] args) {

init();

//List -> Map key是list中对象某一个段，value是整个对象

//(key1,key2)->key1 是为了避免重复key(重复key会抛出异常)

Map map = personList.stream().collect(Collectors.toMap(Person::getId, person -> person,(key1, key2)->key1));

System.out.println(JSONUtil.toJsonStr(map));

//List -> Map key是list中对象某一个段，value是某个字段

Map nameMap = personList.stream().collect(Collectors.toMap(Person::getId, person -> person.getName(),(key1, key2)->key1));

System.out.println(JSONUtil.toJsonStr(nameMap));

//list遍历

personList.stream().forEach(p-> System.out.println(p.getName()));

//根据某一条件过滤

List personList1 = personList.stream().filter(p->p.getSalary()<20000d).collect(Collectors.toList());

System.out.println(JSONUtil.toJsonStr(personList1));

//根据多个条件过滤

List personList2 = personList.stream().filter(p->p.getSalary()<20000d && p.getGender() == 1).collect(Collectors.toList());

System.out.println(JSONUtil.toJsonStr(personList2));

//根据多个条件过滤

Predicate predicate1 = p->p.getSalary()<20000d;

Predicate predicate2 = p-> p.getAddr().equals("中国深圳");

List personList3 = personList.stream().filter(predicate1.and(predicate2)).collect(Collectors.toList());

System.out.println(JSONUtil.toJsonStr(personList3));

//去除重复的数据

Person person = new Person();

person.setId(5);

person.setName("David");

person.setGender(1);

person.setAge(37);

person.setAddr("中国北京");

person.setSalary(22000d);

personList.add(person);

List personList4 = personList.stream().distinct().collect(Collectors.toList());

System.out.println(JSONUtil.toJsonStr(personList4));

//copy list

personList = personList4.stream().map(Person::new).collect(Collectors.toList());

System.out.println(JSONUtil.toJsonStr(personList));

//根据某一条件去重

List personList5 = personList.stream().collect(

Collectors.collectingAndThen(

Collectors.toCollection(

()->new TreeSet<>(Comparator.comparing(Person::getAddr))),ArrayList::new));

System.out.println(JSONUtil.toJsonStr(personList5));

//取list中某个字段组成新的list

List names = personList.stream().map(Person::getName).collect(Collectors.toList());

System.out.println(JSONUtil.toJsonStr(names));

//返回满足条件的数量

long num = personList.stream().filter(p->p.getAddr().equals("中国北京")).filter(p->p.getSalary() > 20000d).count();

System.out.println("num = " + num);

//按条件过滤，没有符合的返回给定值

Person per = personList.stream().filter(p->p.getSalary()>50000d).findAny().orElse(null);

if(Objects.isNull(per)){

System.out.println("没有找到符合条件的person");

}

//查找第一个符合条件的数据

Person per2 = personList.stream().filter((p->p.getSalary()>20000d)).findFirst().orElse(null);

if(Objects.nonNull(per2)){

System.out.println("第一个符合条件的人物是 " + JSONUtil.toJsonStr(per2));

}

//按照某个条件排序

//默认按照自然排序

List personList6 = personList.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());

System.out.println(JSONUtil.toJsonStr(personList6));

//自定义比较项目 然后进行排序

//Person 类实现 Comparable 接口 重写compareTo方法 1-升序 -1-降序

//这里我定义了按照salary升序排列

List personList7 = personList.stream().sorted().collect(Collectors.toList());;

System.out.println(JSONUtil.toJsonStr(personList7));

//遍历处理

personList.stream().forEach(p-> {

if(p.getAddr().equals("中国北京")){

p.setRemark("北京人");

}

});

System.out.println(JSONUtil.toJsonStr(personList));

}

}

最近看外国小哥的一个lambda视频觉得讲得很好，大家是可以看看，这个视频

个人总结一下：

Java 是面向对象，但有的时候面向过程、动作会更加轻量级一点，

所以Java lambda 就是将动作作为参数，再重量级的面向对象参杂一些面向过程的tools帮助我们更快捷地实现功能，更优雅地编程。

不知道上诉总结对不对，目前看来非常符合我在项目中使用lambda表达式的场景。