Java Lambda 多级分组

Java Lambda 多级分组

public class Menu {
	
	/**
	 * 菜品名称
	 */
	private String name;
	/**
	 * 菜品单价
	 */
	private Double price;
	/**
	 * 菜品斤数
	 */
	private Double kilo;
	/**
	 * 菜品类型：蔬菜、水果、肉类
	 */
	private String type;
	
	public Menu() {
		
	}

	public Menu(String name, Double price, Double kilo, String type) {
		super();
		this.name = name;
		this.price = price;
		this.kilo = kilo;
		this.type = type;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Double getPrice() {
		return price;
	}

	public void setPrice(Double price) {
		this.price = price;
	}

	public Double getKilo() {
		return kilo;
	}

	public void setKilo(Double kilo) {
		this.kilo = kilo;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}
	
	
}

Menu pork    = new Menu("猪肉", 9.9, 10.0, "肉类");
Menu beef    = new Menu("牛肉", 38.8, 5.0, "肉类");
Menu chicken = new Menu("鸡肉", 6.5, 30.0, "肉类");
Menu tomato  = new Menu("土豆", 3.5, 30.0, "蔬菜");
Menu potato  = new Menu("西红柿", 7.5, 20.0, "蔬菜");
Menu apple   = new Menu("苹果", 3.5, 20.0, "水果");
Menu orange  = new Menu("橙子", 4.0, 20.0, "水果");
List menuList = Arrays.asList(pork, beef, chicken, tomato, potato, apple, orange);

public enum Type {
	EXPENSIVE, CHEAP
}

多级分组，可以使用一个由双参数版本的Collectors.groupingBy工厂方法创建的收集器，它除了普通的分类函数之外，还可以接受collector类型的第二个参数。那么要进行二级分组的话，可以把一个内层groupingBy传递给外层groupingBy，并定义一个为流中项目分类的二级标准。

Map>> map = menuList.stream().collect(Collectors.groupingBy(menu -> {
	if (menu.getPrice() >= 10.0) {
		return Type.EXPENSIVE;
	} else {
		return Type.CHEAP;
	}
}, Collectors.groupingBy(Menu::getType)));
map.forEach((key, value) -> {
	System.out.println(key.toString());
	value.forEach((k, v) -> {
		System.out.println("--->" + k);
		v.forEach(m -> System.out.println("--------->" + m.getName() + " " + m.getPrice()));
	});
});

EXPENSIVE
--->肉类
--------->牛肉 38.8
CHEAP
--->蔬菜
--------->土豆 3.5
--------->西红柿 7.5
--->肉类
--------->猪肉 9.9
--------->鸡肉 6.5
--->水果
--------->苹果 3.5
--------->橙子 4.0

//统计每种菜单各有多少菜品数量
Map map = menuList.stream().collect(Collectors.groupingBy(Menu::getType, Collectors.counting()));
map.forEach((k, v) -> {
	System.out.println(k + " " + v);
});

蔬菜 2
肉类 3
水果 2

Map> map = menuList.stream().collect(Collectors.groupingBy(Menu::getType));

等价于

Map> map = menuList.stream().collect(Collectors.groupingBy(Menu::getType, Collectors.toList()));

//获取每种菜单最贵的菜品名称价格
Map> map = menuList.stream().collect(Collectors.groupingBy(Menu::getType, Collectors.maxBy(Comparator.comparing(Menu::getPrice))));
map.forEach((key, value) -> {
	System.out.println(key + " " + value.get().getName() + " " + value.get().getPrice());
});

蔬菜 西红柿 7.5
肉类 牛肉 38.8
水果 橙子 4.0

//统计每种菜单类型总价格
Map map = menuList.stream().collect(Collectors.groupingBy(Menu::getType, Collectors.summingDouble(m -> ((Menu) m).getPrice() * ((Menu) m).getKilo())));
map.forEach((key, value) -> {
	System.out.println(key + " " + value);
});

蔬菜 255.0
肉类 488.0
水果 150.0

Collectors.mapping()这个方法接受两个参数：一个函数对流中的元素做变换，另一个则将变换的结果对象收集起来。

//统计每种菜单各有多少菜品
Map> map = menuList.stream().collect(Collectors.groupingBy(Menu::getType, Collectors.mapping(Menu::getName, Collectors.toList())));
map.forEach((key, value) -> {
	System.out.println(key);
	value.forEach(v -> System.out.println("----->" + v));
});

蔬菜
----->土豆
----->西红柿
肉类
----->猪肉
----->牛肉
----->鸡肉
水果
----->苹果
----->橙子

//根据菜品类型分组之后，再根据菜品价格贵贱分组，获取菜品信息
Map>> map = menuList.stream().collect(Collectors.groupingBy(Menu::getType, Collectors.groupingBy(menu -> {
	if (((Menu) menu).getPrice() >= 10.0) {
		return Type.EXPENSIVE;
	} else {
		return Type.CHEAP;
	}
})));

map.forEach((key, value) -> {
	System.out.println(key);
	value.forEach((k, v) -> {
		System.out.println("------>" + k);
		v.forEach(x -> System.out.println("----------->" + x.getName()));
	});
});

蔬菜
------>CHEAP
----------->土豆
----------->西红柿
肉类
------>CHEAP
----------->猪肉
----------->鸡肉
------>EXPENSIVE
----------->牛肉
水果
------>CHEAP
----------->苹果
----------->橙子