Lambda表达式实例

package com.kyexpress.json.lambda;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import com.kyexpress.json.model.User;

public class LambdaTest {

// 返回所有list对象的某一个属性值集合
public static void lambdaTest1() {
	List<User> list = new ArrayList<User>();
	User user = null;
	for (int i = 0; i < 10; i++) {
		user = new User();
		user.setId(i + "");
		user.setUserName("test" + i);
		list.add(user);
	}
	List<String> ids = list.stream().map(vo -> vo.getId()).collect(Collectors.toList());
	ids.forEach(id -> {
		System.out.println(id);
	});
}

// list去重
public static void lambdaDistLits() {
	List<String> list = new ArrayList<String>();
	list.add("a");
	list.add("b");
	list.add("c");
	list.add("d");
	list.add("a");
	list = list.stream().distinct().collect(Collectors.toList());
	System.out.println(list.toString());

}

// List里面的对象元素，以某个属性来分组，例如，以id分组，将id相同的放在一起：
public static void getMapByList() {
	List<User> list = new ArrayList<User>();
	User user = new User();
	user.setId("key");
	user.setUserName("admin1");
	User user2 = new User();
	user2.setId("key");
	user2.setUserName("admin2");
	User user3 = new User();
	user3.setId("key1");
	user3.setUserName("admin3");
	User user4 = new User();
	user4.setId("key1");
	user4.setUserName("admin4");
	list.add(user);
	list.add(user2);
	list.add(user3);
	list.add(user4);
	Map<String, List<User>> map = list.stream().collect(Collectors.groupingBy(User::getId));
	System.out.println(map.toString());
}

public static void main(String[] args) {
	getMapByList();
}

}

总结：
利用java8新特性，可以用简洁高效的代码来实现一些数据处理。

定义1个Apple对象：

public class Apple {
private Integer id;
private String name;
private BigDecimal money;
private Integer num;
public Apple(Integer id, String name, BigDecimal money, Integer num) {
this.id = id;
this.name = name;
this.money = money;
this.num = num;
}
}
添加一些测试数据：
List appleList = new ArrayList<>();//存放apple对象集合

Apple apple1 = new Apple(1,“苹果1”,new BigDecimal(“3.25”),10);
Apple apple12 = new Apple(1,“苹果2”,new BigDecimal(“1.35”),20);
Apple apple2 = new Apple(2,“香蕉”,new BigDecimal(“2.89”),30);
Apple apple3 = new Apple(3,“荔枝”,new BigDecimal(“9.99”),40);

appleList.add(apple1);
appleList.add(apple12);
appleList.add(apple2);
appleList.add(apple3);

1、分组
List里面的对象元素，以某个属性来分组，例如，以id分组，将id相同的放在一起：

//List 以ID分组 Map<Integer,List>
Map<Integer, List> groupBy = appleList.stream().collect(Collectors.groupingBy(Apple::getId));

System.err.println(“groupBy:”+groupBy);
{1=[Apple{id=1, name=‘苹果1’, money=3.25, num=10}, Apple{id=1, name=‘苹果2’, money=1.35, num=20}], 2=[Apple{id=2, name=‘香蕉’, money=2.89, num=30}], 3=[Apple{id=3, name=‘荔枝’, money=9.99, num=40}]}

2、List转Map
id为key，apple对象为value，可以这么做：

/**

• List -> Map
• 需要注意的是：
• toMap 如果集合对象有重复的key，会报错Duplicate key …
• apple1,apple12的id都为1。
• 可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
  */
  Map<Integer, Apple> appleMap = appleList.stream().collect(Collectors.toMap(Apple::getId, a -> a,(k1,k2)->k1));
  打印appleMap
  {1=Apple{id=1, name=‘苹果1’, money=3.25, num=10}, 2=Apple{id=2, name=‘香蕉’, money=2.89, num=30}, 3=Apple{id=3, name=‘荔枝’, money=9.99, num=40}}

3、过滤Filter
从集合中过滤出来符合条件的元素：

//过滤出符合条件的数据
List filterList = appleList.stream().filter(a -> a.getName().equals(“香蕉”)).collect(Collectors.toList());

System.err.println(“filterList:”+filterList);
[Apple{id=2, name=‘香蕉’, money=2.89, num=30}]

4.求和
将集合中的数据按照某个属性求和:

//计算 总金额
BigDecimal totalMoney = appleList.stream().map(Apple::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
System.err.println(“totalMoney:”+totalMoney); //totalMoney:17.48

5.查找流中最大 最小值
Collectors.maxBy 和 Collectors.minBy 来计算流中的最大或最小值。

Optional maxDish = Dish.menu.stream().
collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories)));
maxDish.ifPresent(System.out::println);

Optional minDish = Dish.menu.stream().
collect(Collectors.minBy(Comparator.comparing(Dish::getCalories)));
minDish.ifPresent(System.out::println);

6.去重
import static java.util.Comparator.comparingLong;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;

// 根据id去重
List unique = appleList.stream().collect(
collectingAndThen(
toCollection(() -> new TreeSet<>(comparingLong(Apple::getId))), ArrayList::new)
);

下表展示 Collectors 类的静态工厂方法。

工厂方法 返回类型 作用
toList List 把流中所有项目收集到一个 List
toSet Set 把流中所有项目收集到一个 Set，删除重复项
toCollection Collection 把流中所有项目收集到给定的供应源创建的集合menuStream.collect(toCollection(), ArrayList::new)
counting Long 计算流中元素的个数
sumInt Integer 对流中项目的一个整数属性求和
averagingInt Double 计算流中项目 Integer 属性的平均值
summarizingInt IntSummaryStatistics 收集关于流中项目 Integer 属性的统计值，例如最大、最小、 总和与平均值
joining String 连接对流中每个项目调用 toString 方法所生成的字符串collect(joining(", "))
maxBy Optional 一个包裹了流中按照给定比较器选出的最大元素的 Optional， 或如果流为空则为 Optional.empty()
minBy Optional 一个包裹了流中按照给定比较器选出的最小元素的 Optional， 或如果流为空则为 Optional.empty()
reducing 归约操作产生的类型 从一个作为累加器的初始值开始，利用 BinaryOperator 与流 中的元素逐个结合，从而将流归约为单个值累加int totalCalories = menuStream.collect(reducing(0, Dish::getCalories, Integer::sum));
collectingAndThen 转换函数返回的类型 包裹另一个收集器，对其结果应用转换函数int howManyDishes = menuStream.collect(collectingAndThen(toList(), List::size))
groupingBy Map<K, List> 根据项目的一个属性的值对流中的项目作问组，并将属性值作 为结果 Map 的键
partitioningBy Map<Boolean,List> 根据对流中每个项目应用谓词的结果来对项目进行分区