java Lambda表达式练习

关于JAVA8新特性，Lambda表达式的练习。

java8更新许久，但从来没有试验整理过。借公司空闲之际，练习一下Lambda表达式！

练习题目，均为网上寻找题目（原版地址找不到了）。

本文lambda学习主要参考博主葵花下的獾的文章，参考链接https://blog.csdn.net/qq_28410283/article/details/80634725（非常有用，lambda其他知识在文章下方均有链接）

基本用法：
        list.stream()
                .map(s -> s + 1)  //映射
                .flatMap(s -> Stream.of(s)) //和map差不多，但返回类型为Stream，类似list.add()和list.addAll()的区别
                .filter(s -> s < 1000)    //过滤
                .limit(5)   //限制
                .skip(1)    //跳过
                .distinct() //去重
                .sorted()   //自然排序
                .sorted(Integer::compareTo) //自定义排序
                .reduce()   //对需要的值进行加工，一般方法有（max,min等）参考链接https://blog.csdn.net/zhang89xiao/article/details/77164866

准备类（交易数据的分析），

package pojo1;

/**
*定义一个交易人员的类，添加必要属性（名字和城市）
*/

public  class Trader{

    private String name;
    private String city;

    public Trader(String n, String c){
        this.name = n;
        this.city = c;
    }

    public String getName(){
        return this.name;
    }

    public String getCity(){
        return this.city;
    }

    public void setCity(String newCity){
        this.city = newCity;
    }

    public String toString(){
        return "pojo1.Trader:"+this.name + " in " + this.city;
    }
}

package pojo1;

/**
*添加交易过程的类，添加属性（交易员，年限，交易额）
*
*/

public class Transaction{

    private Trader trader;
    private int year;
    private int value;

    public Transaction(Trader trader, int year, int value)
    {
        this.trader = trader;
        this.year = year;
        this.value = value;
    }

    public Trader getTrader(){
        return this.trader;
    }

    public int getYear(){
        return this.year;
    }

    public int getValue(){
        return this.value;
    }

    public String toString(){
        return "{" + this.trader + ", " +
                "year: "+this.year+", " +
                "value:" + this.value +"}";
    }
}

添加数据

        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario","Milan");
        Trader alan = new Trader("Alan","Cambridge");
        Trader brian = new Trader("Brian","Cambridge");

        List<Transaction> transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );

开始练习：

1.找出2011年发生的所有交易，并按交易额排序

思路：条件：年限为2011，需要排序。所有的集合用List存储。

List<Transaction> tr2001 = transaction.stream

                             .filter(transaction -> transaction.getYear() == 2011)    //筛选符合条件的

                             .sorted(comparing(Transaction::getValue))  //根据交易额排序

                             .collect(toList());        //集合

 

2.交易员在哪些不同的城市工作过

思路：结果为城市的集合

List<String> cityList = transaction.stream

                   .map(transaction -> transaction.getTrader().getCity())                  //取出所有的城市

                   .distinct()                            //去重

                   .collect(toList());                  //集合

 

3.查找所有来自剑桥的交易员，并按姓名进行排序！

思路：条件：城市为剑桥。结果：所有的交易员（集合）。进行排序。

List<Trader>  names = transactions.stream

                     .map(Transaction::Trader)                   //先取出所有的交易员

                     .filter(trader -> trader.getCity().equals("Cambridge"))       //条件：城市为剑桥

                     .distinct()           //去重

                     .sorted(comparing(Trader::getName))                 //根据名字排序

                    .collect(toList());                   //集合

 

4.返回所有交易员的姓名的字符串，并按字母顺序排序。

思路：结果：所有交易员的姓名（String），进行排序。

String traderNames = transaction.stream()

                              .map(transaction -> transaction.getTrader().getName())     //得到所有交易员的名字

                             .distinct()              //去重

                             .sorted()                //默认排序

                            .reduce("",(n1,n2) -> n1+n2+";");       //将字符串进行拼接（方法内一个参数为第一个默认字符串，不设置的话    //                     n1一般为第一个默认字符串。-> 后为操作）

 

5.有没有交易员在米兰工作的

思路：结果：Boolean。条件：城市为米兰的交易员

Boolean milanTrader = transaction.stream

                                .anyMatch(transaction ->trasaction.getTrader().getCity().equals("milan"))

/**Predicate的函数式接口，接口定义请看《JAVA8 Predicate接口》；

*anyMatch表示，判断的条件里，任意一个元素成功，返回true

*allMatch表示，判断条件里的元素，所有的都是，返回true

*noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true*/

 

6.打印生活在剑桥的交易员的所有交易额

思路：条件：生活在剑桥。结果：交易额

transaction.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))

                 .forEach(transaction -> System.out.println(transcation.getValue()));

 

7.所有交易中，最高的交易额是多少？

Optional<Integer> maxValue = transaction.stream

                             .map(Transaction::getValue)

                            .distinct()

                            .reduce(Interger::max);
注：可以用maxValue.isPresent()判断交易额是否存在。

 

8.找到交易额最小的交易

• 写法1（使用自带的min方法）

Optional<Integer> minValue = transaction.stream()

                            .map(Trasaction::getValue)

                            .distinct()

                            .reduce(Integer::min);

• 写法2（比较交易额，拿到最小的）

Optional<Integer> minValue = transaction.stream()

                            .map(Trasaction::getValue)

                            .distinct()

                            .reduce((t1,t2)->{

                             if(t1.intValue() > t2.intValue()) return t2.intValue();

                             else  return t1.intValue();

                            });

 

综上，八个方法练习。