基于Java8的Lambda表达式（1）

本篇基于Java8演示工作中接触的Lambda表达式用法。
描述一个代码场景，先展示之前的一般写法，然后再用Lambda表达式写一遍。

0.1 Java8下载

JDK8下载
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

0.2 代码场景1

有一组双十一来自各个渠道的销售量数据集合，
现在为了在报表上显示，需要把数据按销售量从高到底显示。

package com.lambda;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class TestLambda {

        public static void main(String[] args) {
            List salesList = new ArrayList<>();
            salesList.add(new Sales("天猫", 1000));
            salesList.add(new Sales("京东", 8000));
            salesList.add(new Sales("亚马逊", 200));
            salesList.add(new Sales("大润发", 600));
            salesList.add(new Sales("欧尚", 800));

            //想达到的目的：获取销量从高到低的渠道名称集合:
            //1.京东     8000
            // 2.天猫    1000
            // 3.欧尚    800
            // 4.大润发  600
            // 5.亚马逊  200

            //1. 传统方法
            Collections.sort(salesList, saleCountComparator);
            for(Sales s : salesList) {
                System.out.println(s.getChannelName()+" "+s.getSaleCount());
            }

            //2. lambda方法(获取排序后的对象集合)
            List list2 = salesList.stream()
                    .sorted((o1,o2) -> {
                        return o2.getSaleCount() - o1.getSaleCount();
                    })
                    .collect(Collectors.toList());

            for(Sales s : list2) {
                System.out.println(s.getChannelName()+" "+s.getSaleCount());
            }

            //3. lambda方法(获取排序后的渠道名称集合)
            List list3 = salesList.stream()
                    .sorted((o1,o2) -> {
                        return o2.getSaleCount() - o1.getSaleCount();
                    })
                   //map:一对一转换   输入一个对象(Sales) 转换为 一个对应的渠道名称(String)
                    .map(Sales::getChannelName)    
                    .collect(Collectors.toList());

            for(String s : list3) {
                System.out.println(s);
            }
        }

        public static Comparator saleCountComparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
               //o2在前，降序排列
                return ((Sales)o2).getSaleCount() - ((Sales)o1).getSaleCount(); 
            }
        };
    }

class Sales {
    private String channelName;
    private Integer saleCount;

    public Sales(String channelName, Integer saleCount) {
        this.channelName = channelName;
        this.saleCount = saleCount;
    }

    public String getChannelName() {
        return channelName;
    }

    public void setChannelName(String channelName) {
        this.channelName = channelName;
    }

    public Integer getSaleCount() {
        return saleCount;
    }

    public void setSaleCount(Integer saleCount) {
        this.saleCount = saleCount;
    }
}

0.3 代码说明

以上代码的关键是lambda写法的stream、sorted、map

• stream
  它和以往文件等输入输出流的stream完全两个概念，
  它能够对集合对象进行各种串行或并发聚集操作，
  响应了现在多核处理器的需求。
• sorted
  sorted函数需要传入一个实现Comparator函数式接口的对象，
  该接口的抽象方法compare接收两个参数并返回一个整型值，
  作用就是排序，因为做了精简，所以代码上比传统的精简很多：

.sorted((o1,o2) ->  o2.getSaleCount() - o1.getSaleCount())

以上是精简的写法，但是我个人习惯加上{}，可读性可能会好些：

.sorted((o1,o2)  -> {
                        return o2.getSaleCount() - o1.getSaleCount();
                    })

• map
  map函数需要传入一个实现Function函数式接口的对象，
  该接口的抽象方法apply接收一个参数并返回一个值，
  可以理解为映射关系，上面的代码就是将每一个Sales对象映射为一个channelName的String对象

.map(Sales::getChannelName)

（注意语法，中间是2个冒号，类似C++的方法调用）

---

写本文仅仅是为了演示Lambda表达式的常用写法，至于可读性、可维护性、性能高低等方面，大家根据实际情况去判断吧。

由于作者水平有限，难免出现纰漏，如有问题请帮忙指正，谢谢！

下一篇 基于Java8的Lambda表达式（2）