• Stream API的练习题


    Stream API的练习题

    题目:

    1. 找出2011年发生的所有交易,并按交易额排序(从高到低)。
    2. 交易员都在哪些不同的城市工作过?
    3. 查找所有来自Cambridge的交易员,并按姓名排序。
    4. 返回所有交易员的姓名字符串,按字母顺序排序。
    5. 有没有交易员在Milan工作
    6. 打印生活在Cambridge的交易员的所有交易额。
    7. 所有的交易额中,最高的交易额是多少?
    8. 所有的交易额中,找到交易额最小的交易

    一、代码结构:

    com
    └── example
        └── one
            ├── MainApp.java
            ├── Trader.java
            └── Transaction.java
    

    二、案例所需的数据和实体类:

    • com.example.one包路径下,创建Trader.java实体类。
    package com.example.one;
    
    @Data
    public class Trader {
        private String name;
        private String city;
    
    
        public Trader() {
        }
        public Trader(String name, String city) {
            this.name = name;
            this.city = city;
        }
    }
    
    • com.example.one包路径下,创建Transaction.java实体类。
    package com.example.one;
    
    @Data
    public class Transaction {
        private Trader trader;
        private Integer year;
        private Integer value;
    
    
        public Transaction() {
        }
        public Transaction(Trader trader, Integer year, Integer value) {
            this.trader = trader;
            this.year = year;
            this.value = value;
        }
    }
    
    • com.example.one包路径下,创建MainApp.java测试类。
    package com.example.one;
    
    public class MainApp {
        private Trader raoul = new Trader("Raoul", "Cambridge");private Trader raoul = new Trader("Raoul", "Cambridge");private Trader raoul = new Trader("Raoul", "Cambridge");private Trader raoul = new Trader("Raoul", "Cambridge");
        private Trader mario = new Trader("Mario", "Milan");
        private Trader alan = new Trader("Alan", "Cambridge");
        private Trader brian = new Trader("Brian", "Cambridge");
    
        private List<Transaction> transactionList = 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)
        );
    	
        //TODO ... 待添加的方法...
    }
    

    三、使用Stream API提供的方法,解决问题:

    题目一:
    • 找出2011年发生的所有交易,并按交易额排序(从高到低)。
    /**
     * [
     *     Transaction(trader=Trader(name=Raoul, city=Cambridge), year=2011, value=400), 
     *     Transaction(trader=Trader(name=Brian, city=Cambridge), year=2011, value=300)
     * ]
     */
    @Test
    void test_01 () {
        List<Transaction> list = transactionList.stream()
                .filter(item -> item.getYear().equals(2011))
                .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue()))
                .collect(Collectors.toList());
        System.out.println(list);
    }
    
    题目二:
    • 交易员都在哪些不同的城市工作过?
    /**
     * [Cambridge, Milan]
     */
    @Test
    void test_01 () {
        List<String> list = transactionList.stream()
                .map(Transaction::getTrader).map(Trader::getCity)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(list);
    }
    
    题目三:
    • 查找所有来自Cambridge的交易员,并按姓名排序。
    /**
     * [
     *     Trader(name=Alan, city=Cambridge), 
     *     Trader(name=Brian, city=Cambridge), 
     *     Trader(name=Mario, city=Milan), 
     *     Trader(name=Raoul, city=Cambridge)
     * ]
     */
    @Test
    void test_01 () {
        List<Trader> list = transactionList.stream()
                .map(Transaction::getTrader)
                .distinct()
                .sorted((e1, e2) -> e1.getName().compareTo(e2.getName()))
                .collect(Collectors.toList());
        System.out.println(list);
    }
    
    题目四:
    • 返回所有交易员的姓名字符串,按字母顺序排序。
    实现方式一:
    /**
     * [Alan, Brian, Mario, Raoul]
     */
    @Test
    void test_01 () {
        List<String> list = transactionList.stream()
                .map(Transaction::getTrader).map(Trader::getName)
                .distinct()
                .sorted(String::compareTo)
                .collect(Collectors.toList());
        System.out.println(list);
    }
    
    实现方式二:
    /**
     * AlanBrianMarioRaoul
     */
    @Test
    void test_01 () {
        String concatStr = transactionList.stream()
                .map(Transaction::getTrader).map(Trader::getName)
                .distinct()
                .sorted(String::compareTo)
                .reduce("", String::concat);
        System.out.println(concatStr);
    }
    
    实现方式三:
    /**
     * ABMRaaaaiillnnoorru
     */
    @Test
    void test_01() {
        String concatStr = transactionList.stream()
                .map(Transaction::getTrader).map(Trader::getName)
                .distinct()
                .flatMap(this::filterCharacter)
                .sorted(String::compareTo)
                .reduce("", String::concat);
        System.out.println(concatStr);
    }
    
    /**
     * 将字符串拆分,一个字符为一个字符串的流。
     */
    private Stream<String> filterCharacter(String str) {
        List<String> list = new ArrayList<>();
        for (char ch : str.toCharArray()) {
            list.add(String.valueOf(ch));
        }
        return list.stream();
    }
    
    题目五:
    • 有没有交易员在Milan工作。
    /**
     * [Trader(name=Mario, city=Milan)]
     */
    @Test
    void test_01() {
        List<Trader> list = transactionList.stream()
                .map(Transaction::getTrader)
                .distinct()
                .filter(item -> item.getCity().equals("Milan"))
                .collect(Collectors.toList());
        System.out.println(list);
    }
    
    题目六:
    • 打印生活在Cambridge的交易员的所有交易额。
    实现方式一:
    /**
     * 2650
     */
    @Test
    void test_01() {
        Integer sum = transactionList.stream()
                .filter(item -> item.getTrader().getCity().equals("Cambridge"))
                .collect(Collectors.summingInt(Transaction::getValue));
        System.out.println(sum);
    }
    
    实现方式二:
    /**
     * 2650
     */
    @Test
    void test_01() {
        Integer sum = transactionList.stream()
                .filter(item -> item.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                .reduce(0, Integer::sum);
        System.out.println(sum);
    }
    
    题目七:
    • 所有的交易额中,最高的交易额是多少?
    实现方式一:
    /**
     * Optional[1000]
     */
    @Test
    void test_01() {
        Optional<Integer> max = transactionList.stream()
                .map(Transaction::getValue)
                .collect(Collectors.maxBy(Integer::compareTo));
        System.out.println(max);
    }
    
    实现方式二:
    /**
     * Optional[1000]
     */
    @Test
    void test_01() {
        Optional<Integer> max = transactionList.stream()
                .map(Transaction::getValue)
                .max(Integer::compareTo);
        System.out.println(max);
    }
    
    题目八:
    • 所有的交易额中,找到交易额最小的交易
    实现方式一:
    /**
     * Optional[Transaction(trader=Trader(name=Brian, city=Cambridge), year=2011, value=300)]
     */
    @Test
    void test_01() {
        Optional<Transaction> min = transactionList.stream()
                .min((e1, e2) -> e1.getValue().compareTo(e2.getValue()));
        System.out.println(min);
    }
    
    实现方式二:
    /**
     * Optional[Transaction(trader=Trader(name=Brian, city=Cambridge), year=2011, value=300)]
     */
    @Test
    void test_01() {
        Optional<Transaction> min = transactionList.stream()
                .collect(Collectors.minBy((e1, e2) -> e1.getValue().compareTo(e2.getValue())));
        System.out.println(min);
    }
    
  • 相关阅读:
    Chaos网络库(一) 开篇介绍
    对Oracle中的表进行分区
    java socket编程
    SQL优化
    冒泡排序、选择排序和插入
    集合有趣的地方
    java中String s = new String("abc")创建了几个对象
    集合排序
    接口与抽象类的区别
    软件测试流程
  • 原文地址:https://www.cnblogs.com/greamrod/p/14057852.html
Copyright © 2020-2023  润新知