本篇文章主要是介绍一下lambda的用法,具体的原理请参考相关的文档。下面例子不涉及业务,纯属展现lambda的用法。
数据定义
下面是咱们本篇文章用到的订单实体。下面所有的举例都是基于该结构。
public class OrderInfo { //详情id private Integer id; //订单号 private String orderNo; //商品id private Integer goodsId; //商品名称 private String name; //商品单价 private BigDecimal price; //商品数量 private BigDecimal num; //商品总价 private BigDecimal totalPrice; }
用到的相关数据,下面的所有举例也是基于下面的5条数据。
/** * 获取订单详情列表 * @return */ public static List<OrderInfo> getOrderList() { /* 订单详情列表 三个订单: 订单1:N001两种商品 订单2:N002一种商品 订单1:N003两种商品 */ List<OrderInfo> orderInfoList = new ArrayList<>(); OrderInfo info = new OrderInfo(1,"N001", 1, "香蕉", new BigDecimal("2.3"), new BigDecimal(2)); orderInfoList.add(info); info = new OrderInfo(2,"N001", 2, "苹果", new BigDecimal("4.3"), new BigDecimal("3.5")); orderInfoList.add(info); info = new OrderInfo(3,"N002", 3, "橘子", new BigDecimal("3.3"), new BigDecimal(4)); orderInfoList.add(info); info = new OrderInfo(4,"N003", 1, "香蕉", new BigDecimal("2.3"), new BigDecimal("3.4")); orderInfoList.add(info); info = new OrderInfo(5,"N003", 3, "橘子", new BigDecimal("3.3"), new BigDecimal("3.5")); orderInfoList.add(info); return orderInfoList; }
打印map的方法:
/** * 打印map的方法 * @param map */ public static void printMap (Map map) { Iterator<Map.Entry<Object, Object>> iterator = map.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry<Object, Object> next = iterator.next(); Object key = next.getKey(); System.out.println("======key:"+ key); Object value = next.getValue(); System.out.println("====value:" + value); } }
打印list的方法
/** * 打印List信息 * @param list */ public static void printList(List list) { list.forEach(obj -> { System.out.println(obj); }); }
list类型转map的相关处理
1、list 转换为 key为id, value为orderInfo的map
/** * list 转换为 key为id, value为orderInfo的map 方法一 * @return */ public static Map<Integer, OrderInfo> mapById1(List<OrderInfo> orderList) { return orderList.stream().collect(Collectors.toMap(OrderInfo::getId, orderInfo -> orderInfo)); } /** * list 转换为 key为id, value为orderInfo的map 方法二 * @return */ public static Map<Integer, OrderInfo> mapById2(List<OrderInfo> orderList) { return orderList.stream().collect(Collectors.toMap(OrderInfo::getId, Function.identity())); }
运行上面的方法得到的结果:
======key:1
====value:OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}
======key:2
====value:OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
======key:3
====value:OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}
======key:4
====value:OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=null}
======key:5
====value:OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=null}
2、list 转换为 key为goodsId, value为orderInfo的map
有时我们遇到key对应的数据有可能是重复的,比如:
/** * key有重复值时 * list 转换为 key为goodsId, value为orderInfo的map * 当list中有重复的goodsId,这时候用上述两种方法就会报错 * 该方法是====报错方法===== * @return */ public static Map<Integer, OrderInfo> mapByGoodsId1(List<OrderInfo> orderList) { return orderList.stream().collect(Collectors.toMap(OrderInfo::getGoodsId, Function.identity())); }
但是在用这种方式转换数据是就会报错,报错如下
Exception in thread "main" java.lang.IllegalStateException: Duplicate key OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}
所以咱们得换一种处理方式:
/** * key有重复值时 * list 转换为 key为goodsId, value为orderInfo的map * 当list中有重复的goodsId,这时候用上述两种方法就会报错 * 咱们改进后的方法 (k1, k2) -> k2 当有多条数据重复时会用后者 (k1, k2) -> k1 当有多条数据重复时会用前者 * @return */ public static Map<Integer, OrderInfo> mapByGoodsIdDistinct(List<OrderInfo> orderList) { return orderList.stream() .collect(Collectors.toMap(OrderInfo::getGoodsId, Function.identity(), (k1, k2) -> k1)); }
当用(k1, k2) -> k1时打印的结果:
======key:1
====value:OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}
======key:2
====value:OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
======key:3
====value:OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}
当用(k1, k2) -> k2时打印的结果:
======key:1
====value:OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=null}
======key:2
====value:OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
======key:3
====value:OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=null}
3、list 转换为的特指的map
/** * list 转换为 key为goodsId, value为orderInfo的map * 当list中有重复的goodsId,这时候用上述两种方法就会报错 * 咱们改进后的方法 (k1, k2) -> k2 当有多条数据重复时会用后者 (k1, k2) -> k1 当有多条数据重复时会用前者 * 转换为特定类型的map * @return */ public static Map<Integer, OrderInfo> mapByGoodsIdForLinkedHashMap(List<OrderInfo> orderList) { LinkedHashMap<Integer, OrderInfo> map = orderList.stream() .collect(Collectors.toMap(OrderInfo::getGoodsId, Function.identity(), (k1, k2) -> k2, LinkedHashMap::new)); return map; }
4、list 转换为 key为id, value为商品名称的map
/** * list 转换为 key为id, value为商品名称的map * @return */ public static Map<Integer, String> mapByIdValueName(List<OrderInfo> orderList) { return orderList.stream().collect(Collectors.toMap(OrderInfo::getId, OrderInfo::getName)); }
打印结果:
======key:1
====value:香蕉
======key:2
====value:苹果
======key:3
====value:橘子
======key:4
====value:香蕉
======key:5
====value:橘子
5、list 转换为 key为orderNo, value为List<OrderInfo>
/** * list 转换为 key为orderNo, value为List<OrderInfo> * @return */ public static Map<String, List<OrderInfo>> mapByOrderNoValueOrderList(List<OrderInfo> orderList) { return orderList.stream().collect(Collectors.groupingBy(OrderInfo::getOrderNo)); }
打印结果:
======key:N002
====value:[OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}]
======key:N003
====value:[OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=null}, OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=null}]
======key:N001
====value:[OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}, OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}]
6、list 转换为 key为orderNo, value为商品id的List列表
/** * list 转换为 key为orderNo, value为商品id的List列表 * @return */ public static Map<String, List<Integer>> mapByOrderNoValueGoodsIdList(List<OrderInfo> orderList) { return orderList.stream().collect(Collectors.groupingBy(OrderInfo::getOrderNo, Collectors.mapping(OrderInfo :: getGoodsId, Collectors.toList()))); }
打印结果:
======key:N002
====value:[3]
======key:N003
====value:[1, 3]
======key:N001
====value:[1, 2]
7、计算每个订单的价格 key为订单号orderNo, value为订单对应的总价格
/** * 计算每个订单的价格 key为订单号orderNo, value为订单对应的总价格 * @param infoList * @return */ public static Map<String, Double> calculateEachOrderTotalPrice(List<OrderInfo> infoList) { Map<String, Double> orderPriceMap = infoList.stream() .collect(Collectors.groupingBy(OrderInfo::getOrderNo, Collectors.summingDouble(orderInfo -> orderInfo.getNum().multiply(orderInfo.getPrice()).doubleValue()))); return orderPriceMap; }
打印结果:
======key:N002
====value:13.2
======key:N003
====value:19.37
======key:N001
====value:19.65
对本list里本身的数据进行处理转为不同格式的list
1、计算每条数据的总价格并赋值
/** * 计算每条数据的总价格并赋值 * @param infoList * @return */ public static List<OrderInfo> calculateEachTotalPrice(List<OrderInfo> infoList) { return infoList.stream().map(orderInfo -> { orderInfo.setTotalPrice(orderInfo.getNum().multiply(orderInfo.getPrice())); return orderInfo; }).collect(Collectors.toList()); }
打印列表输出的结果:
OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=4.6}
OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=15.05}
OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=13.2}
OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=7.82}
OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=11.55}
2、获取商品的ids 获取订单信息列表里的商品id,不去重
/** * 获取商品的ids 获取订单信息列表里的商品id,不去重 * @param infoList * @return */ public static List<Integer> getGoodsIdList(List<OrderInfo> infoList) { return infoList.stream().map(OrderInfo::getGoodsId).collect(Collectors.toList()); }
打印列表输出结果:
1
2
3
1
3
3、获取商品的ids 获取订单信息列表里的商品id,去重
/** * 获取商品的ids 获取订单信息列表里的商品id,去重 * @param infoList * @return */ public static List<Integer> getGoodsIdDistinctList(List<OrderInfo> infoList) { return infoList.stream().map(OrderInfo::getGoodsId).distinct() .collect(Collectors.toList()); }
打印结果:
1
2
3
list获取其它形式的数据
1、获取列表总价
/** * 计算所有数据的总价格 double类型 * @param infoList * @return */ public static void calculateTotalPrice(List<OrderInfo> infoList) { Double totalPrice = infoList.stream().collect(Collectors.summingDouble(info -> info.getPrice().multiply(info.getNum()).doubleValue())); System.out.println(totalPrice); }
输出结果:
52.22
数据筛选
1、获取单价大于4元的订单详情列表
/** * 获取单价大于4元的订单详情列表 * @return */ public static List<OrderInfo> getOrderInfosGreaterThanPrice(List<OrderInfo> infoList) { return infoList.stream().filter(orderInfo -> orderInfo.getPrice().doubleValue() > 4).collect(Collectors.toList()); }
输出结果:
OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
2、获取单价大于3元且数量大于等于4的订单详情列表
/** * 获取单价大于3元且数量大于等于4的订单详情列表 * 方法一 * @return */ public static List<OrderInfo> getOrderInfosGreaterThanPriceAndNum1(List<OrderInfo> infoList) { return infoList.stream() .filter(orderInfo -> orderInfo.getPrice().doubleValue() > 3 && orderInfo.getNum().doubleValue() >= 4) .collect(Collectors.toList()); } /** * 获取单价大于3元且数量大于等于4的订单详情列表 * 方法二 * @return */ public static List<OrderInfo> getOrderInfosGreaterThanPriceAndNum2(List<OrderInfo> infoList) { Predicate<OrderInfo> p1 = info -> info.getNum().doubleValue() >= 4; Predicate<OrderInfo> p2 = info -> info.getPrice().doubleValue() > 3; return infoList.stream() .filter(p1.and(p2)) .collect(Collectors.toList()); }
输出结果:
OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}
条件排序
1、获取按价格从小到大排序的列表
/** * 获取按价格从小到大排序的列表 * @return */ public static List<OrderInfo> getOrderInfosSortByPriceAsc(List<OrderInfo> infoList) { return infoList.stream().sorted(Comparator.comparing(OrderInfo::getPrice)) .collect(Collectors.toList()); }
输出结果:
OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}
OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=null}
OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}
OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=null}
OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
2、获取按价格从大到小排序的列表
/** * 获取按价格从大到小排序的列表 * @return */ public static List<OrderInfo> getOrderInfosSortByPriceDesc(List<OrderInfo> infoList) { return infoList.stream().sorted(Comparator.comparing(OrderInfo::getPrice).reversed()) .collect(Collectors.toList()); }
输出结果:
OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}
OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=null}
OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}
OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=null}
3、获取按价格从小到大排序和数量从小到大的列表
/** * 获取按价格从小到大排序和数量从小到大的列表 * @return */ public static List<OrderInfo> getOrderInfosSortByPriceAscAndNumAsc(List<OrderInfo> infoList) { return infoList.stream().sorted(Comparator.comparing(OrderInfo::getPrice).thenComparing(OrderInfo ::getNum)) .collect(Collectors.toList()); }
输出结果:
OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}
OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=null}
OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=null}
OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}
OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
4、获取按价格从小到大排序和数量从大到小的列表
/** * 获取按价格从小到大排序和数量从大到小的列表 * @return */ public static List<OrderInfo> getOrderInfosSortByPriceAscAndNumDesc(List<OrderInfo> infoList) { Comparator<OrderInfo> c1 = Comparator.comparing(OrderInfo::getPrice); Comparator<OrderInfo> c2 = Comparator.comparing(OrderInfo::getNum).reversed(); return infoList.stream() .sorted(c1.thenComparing(c2)) .collect(Collectors.toList()); }
输出结果:
OrderInfo{id=4, orderNo='N003', goodsId=1, name='香蕉', price=2.3, num=3.4, totalPrice=null}
OrderInfo{id=1, orderNo='N001', goodsId=1, name='香蕉', price=2.3, num=2, totalPrice=null}
OrderInfo{id=3, orderNo='N002', goodsId=3, name='橘子', price=3.3, num=4, totalPrice=null}
OrderInfo{id=5, orderNo='N003', goodsId=3, name='橘子', price=3.3, num=3.5, totalPrice=null}
OrderInfo{id=2, orderNo='N001', goodsId=2, name='苹果', price=4.3, num=3.5, totalPrice=null}
上面是根据上面的5条数据总结出lambda表达式的相关用法,lambda很强大,还有很多没有概括的例子,希望给大家有所帮助,文章原创,整理不容易,转载请注明出处。