Stream基本练习题--附答案

Stream基本练习题–附答案

交易员对象

package com.wrr;

/**
 *
 */
public class Trader {
    /**
     * 名字
     */
    private String name;
    /**
     * 城市
     */
    private String city;

    public Trader() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getCity() {
        return city;
    }

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

    @Override
    public String toString() {
        return "Trader{" +
                "name='" + name + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

交易对象

package com.wrr;

public class Transaction {
    private Trader trader;
    private Integer year;
    private Integer mount;

    public Transaction() {
    }

    public Transaction(Trader trader, Integer year, Integer mount) {
        this.trader = trader;
        this.year = year;
        this.mount = mount;
    }

    public Trader getTrader() {
        return trader;
    }

    public void setTrader(Trader trader) {
        this.trader = trader;
    }

    public Integer getYear() {
        return year;
    }

    public void setYear(Integer year) {
        this.year = year;
    }

    public Integer getMount() {
        return mount;
    }

    public void setMount(Integer mount) {
        this.mount = mount;
    }

    @Override
    public String toString() {
        return "Transaction{" +
                "trader=" + trader +
                ", year=" + year +
                ", mount=" + mount +
                '}';
    }
}

测试类

package com.wrr;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class TraderTest {
    public static void main(String[] args) {
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "NewYork");
        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)
        );

        //找出2011年发生的所有交易，并按交易额排序
        System.out.println("找出2011年发生的所有交易，并按交易额排序-----");
        transactions.stream()
                //过滤出2011年的交易
                .filter(transaction -> transaction.getYear() == 2011)
                //按交易额升序
                .sorted(Comparator.comparing(Transaction::getMount))
                //打印结果
                .forEach(System.out::println);

        //
        //交易员在哪些不同的城市工作过
        System.out.println("交易员在哪些不同的城市工作过------");
        transactions.stream()
                //获取所有的城市字符串
                .map(transaction -> transaction.getTrader().getCity())
                //去重
                .distinct()
                //打印结果
                .forEach(System.out::println);

        //
        //查找所有来自剑桥的交易员，并按姓名排序
        System.out.println("查找所有来自剑桥的交易员，并按姓名排序----");
        transactions.stream()
                //过滤出所有的剑桥交易
                .filter(transaction -> "Cambridge".equals(transaction.getTrader().getCity()))
                //获取交易中的交易员对象
                .map(Transaction::getTrader)
                //去重
                .distinct()
                //按照姓名升序
                .sorted(Comparator.comparing(Trader::getName))
                //打印结果
                .forEach(System.out::println);
        //
        //返回所有交易员的姓名字符串，并按字母顺序排序
        System.out.println("返回所有交易员的姓名字符串，并按字母顺序排序------");
        transactions.stream()
                //获取交易中的所有交易员姓名
                .map(transaction -> transaction.getTrader().getName())
                //姓名去重
                .distinct()
                //升序排序
                .sorted()
                //打印结果
                .forEach(System.out::println);
        //
        //有没有交易员在米兰工作的？

        boolean match = transactions.stream()
                //匹配到任意一个都为true
                .anyMatch(transaction -> "Milan".equals(transaction.getTrader().getCity()));

        System.out.println("有没有交易员在米兰工作的  " + match);
        //
        //打印生活在剑桥的交易员的所有交易额
        int sum = transactions.stream()
                //过滤出生活在剑桥的交易员的所有交易
                .filter(transaction -> "Cambridge".equals(transaction.getTrader().getCity()))
                //获取交易额
                .mapToInt(Transaction::getMount)
                //求和
                .sum();
        System.out.println("生活在剑桥的交易员的所有交易额  " + sum);
        //
        //所有交易中，最高的交易额是多少

        Integer mount = transactions.stream()
                //获取最大的金额交易
                .max(Comparator.comparingInt(Transaction::getMount))
                //获取对象
                .get()
                //获取金额
                .getMount();
        System.out.println("所有交易中，最高的交易额是 " + mount);
        //
        //找到交易额最小的交易

        Transaction transaction = transactions.stream()
                //获取交易额最小的交易
                .min(Comparator.comparing(Transaction::getMount))
                //获取对象
                .get();
        System.out.println("交易额最小的交易  " + transaction);
    }
}

答案

找出2011年发生的所有交易，并按交易额排序-----
Transaction{trader=Trader{name='Brian', city='Cambridge'}, year=2011, mount=300}
Transaction{trader=Trader{name='Raoul', city='Cambridge'}, year=2011, mount=400}


交易员在哪些不同的城市工作过------
Cambridge
Milan
NewYork


查找所有来自剑桥的交易员，并按姓名排序----
Trader{name='Brian', city='Cambridge'}
Trader{name='Raoul', city='Cambridge'}


返回所有交易员的姓名字符串，并按字母顺序排序------
Alan
Brian
Mario
Raoul


有没有交易员在米兰工作的  true


生活在剑桥的交易员的所有交易额  1700


所有交易中，最高的交易额是 1000


交易额最小的交易  Transaction{trader=Trader{name='Brian', city='Cambridge'}, year=2011, mount=300}