實體類

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表達式的場景。

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的java lambda例子_Java lambda 表达式常用示例的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。