中间操作和终端操作

image.png

Demo TraderTest

package jdk8.demo.pack2;

import com.google.common.collect.Lists;
import org.apache.commons.collections.CollectionUtils;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class TraderTest {


    public static List<Transaction> initData() {
        List<Transaction> transactions = Lists.newArrayList();
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario","Milan");
        Trader alan = new Trader("Alan","Cambridge");
        Trader brian = new Trader("Brian","Cambridge");
        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)
        );
        return transactions;
    }


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

    // 测试用例1 - (1) 找出2011年发生的所有交易，并按交易额排序(从低到高)。
    public static void testcase_01() {
        List<Transaction> transactions = initData();
        transactions.stream().filter(c -> c.getYear() == 2011)
                .sorted(Comparator.comparing(Transaction::getValue)) // .reversed()
                .collect(Collectors.toList())
        .forEach(c -> System.out.println(c));
    }

    // 测试用例2 - (2) 交易员都在哪些不同的城市工作过?
    public static void testcase_02() {
        List<Transaction> transactions = initData();
        transactions.stream().map(c -> c.getTrader().getCity())
                .distinct().forEach(c -> System.out.println(c));
    }

    // 测试用例3 - (3) 查找所有来自于剑桥的交易员，并按姓名排序。
    public static void testcase_03() {
        List<Transaction> transactions = initData();
        transactions.stream()
                .map(Transaction::getTrader)
                .filter(c -> "Cambridge".equals(c.getCity()))
                .distinct()
                .sorted(Comparator.comparing(Trader::getName))
                .collect(Collectors.toList())
        .forEach(c -> {
            System.out.println(c);
        });

//        (Transaction c1, Transaction c2) -> {
//            return c1.getTrader().getName().compareTo(c2.getTrader().getName());
//        })
    }

    // 测试用例4 - (4) 返回所有交易员的姓名字符串，按字母顺序排序。
    public static void testcase_04() {
        List<Transaction> transactions = initData();
        transactions.stream()
                .map(Transaction::getTrader)
                .map(Trader::getName)
                .sorted()
                .distinct()
                .forEach(c -> System.out.println(c));
    }

    // 测试用例5 - (5) 有没有交易员是在米兰工作的?
    public static void testcase_05() {
        List<Transaction> transactions = initData();
        Boolean isMatch = transactions.stream().map(Transaction::getTrader)
                .anyMatch(c -> "Milan".equals(c.getCity()));
        System.out.println(String.format("isMatch: %s", isMatch));
    }

    // 测试用例6 - (6) 打印生活在剑桥的交易员的所有交易额。
    public static void testcase_06() {
        List<Transaction> transactions = initData();
        transactions.stream().filter(c -> "Cambridge".equals(c.getTrader().getCity()))
                .forEach(c -> System.out.println(c));
    }

    // 测试用例7 - (7) 所有交易中，最高的交易额是多少?
    public static void testcase_07() {
        List<Transaction> transactions = initData();
        Optional<Integer> optional = transactions.stream().map(Transaction::getValue)
                .reduce(Integer::max);

        if(optional.isPresent()) {
            System.out.println("maxTransaction: " + optional.get());
        }
    }

    // 测试用例7 - (8) 找到交易额最小的交易。
    public static void testcase_08() {
        List<Transaction> transactions = initData();
        Optional<Integer> optional = transactions.stream().map(Transaction::getValue)
                .reduce(Integer::min);
        if(optional.isPresent()) {
            System.out.println("minTransaction: " + optional.get());
        }


        Optional<Transaction> optionalMin = transactions.stream().min(Comparator.comparing(Transaction::getValue));
        if(optionalMin.isPresent()) {
            System.out.println("tran1: " + optionalMin.get());
        }

        Optional<Transaction> optionalReduce =  transactions.stream().
                reduce((c1, c2) -> c1.getValue() < c2.getValue() ? c1 : c2);
        if(optionalReduce.isPresent()) {
            System.out.println("optionalReduce: " + optionalReduce.get());
        }
    }

    public static void main(String[] args) {
        // 测试用例1
//        testcase_01();

        // 测试用例2
//        testcase_02();

        // 测试用例3
//        testcase_03();

        // 测试用例4
//        testcase_04();

        // 测试用例5
//        testcase_05();

        // 测试用例6
//        testcase_06();

        // 测试用例7
//        testcase_07();

        // 测试用例8
        testcase_08();
    }
}