java8 新特性lambda表达式

本篇文章主要是介绍一下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很强大，还有很多没有概括的例子，希望给大家有所帮助，文章原创，整理不容易，转载请注明出处。