/*
 调用 Collections.sort()方法，通过定制排序比较两个 Employee(先按年龄比，年龄相同按姓名比),使用 Lambda 表达式作为参数传递。
 */

    public static void main(String[] args) {
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> collect = employees.stream().sorted((e1, e2) -> {
            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue != 0) {
                return ageValue;
            } else {
                return e1.getName().compareTo(e2.getName());
            }
        }).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

/*
① 声 明 函 数 式 接 口 ， 接 口 中 声 明 抽 象 方 法 ： public String getValue(String str);
② 声明类 LambdaTest，类中编写方法使用接口作为参数，将一个字符串转换成大写，并作为方法的返回值。
③ 再将一个字符串的第 2 个到第 4 个索引位置进行截取子串。
 */

    @Test
    public void test2() {
        String string = strHandler("abcdef", str -> str.toUpperCase(Locale.ROOT));
        System.out.println(string);
        String subStr = strHandler("世界那么大，我想去看看", str -> str.substring(2, 5));
        System.out.println(subStr);
    }
    //需求：用于处理字符串
    public String strHandler(String str, MyFunction mf) {
        return mf.getValue(str);
    }

package com.jerry.java;
/**
 * @author jerry_jy
 * @create 2022-10-15 9:29
 */
@FunctionalInterface
public interface MyFunction {
    public String getValue(String str);
}

/*
①声明一个带两个泛型的函数式接口，泛型类型为<T,R> : T 为参数，R 为返回值。
②接口中声明对应抽象方法
③在 LambdaTest 类中声明方法，使用接口作为参数，计算两个 long型参数的和。
④再计算两个 long 型参数的乘积
 */

    @Test
    public void test3() {
        op(100L, 200L, (x1, x2) -> x1 + x2);
        op(300L, 400L, (x1, x2) -> x1 * x2);
    }
    public void op(Long l1, Long l2, MyFunction1<Long, Long> mf) {
        System.out.println(mf.getValue(l1, l2));
    }

package com.jerry.java;
/**
 * @author jerry_jy
 * @create 2022-10-15 9:35
 */
@FunctionalInterface
public interface MyFunction1<T,R> {
    R getValue(T t1,T t2);
}

/*
给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？
例如，给定【1，2，3，4，5】， 应该返回【1，4，9，16，25】。
 */

    @Test
    public void test1() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.stream().map((x)->x*x).forEach(System.out::println);
    }

/*
 怎样用 map 和 reduce 方法数一数流中有多少个 Employee 呢？
 */

    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();
        //方式一：
        System.out.println(employees.stream().count());
        //方式二：
        Optional<Integer> integer = employees.stream().map(employee -> 1).reduce(Integer::sum);
        System.out.println(integer.get());
    }

package com.jerry.java;
import org.junit.Before;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
/**
 * @author jerry_jy
 * @create 2022-10-15 9:55
 */
public class TestTransaction {
    List<Transaction> transactions = null;
    @Before
    public void before() {
        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)
        );
    }
    //1. 找出2011年发生的所有交易， 并按交易额排序（从低到高）
    @Test
    public void test1(){
        transactions.stream().filter(t -> t.getYear()==2011)
                .sorted((t1,t2)->Integer.compare(t1.getValue(), t2.getValue()))
                .forEach(System.out::println);
    }
    //2. 交易员都在哪些不同的城市工作过？
    @Test
    public void test2(){
        transactions.stream().map(transaction -> transaction.getTrader().getCity()).distinct().forEach(System.out::println);
    }
    //3. 查找所有来自剑桥的交易员，并按姓名排序
    @Test
    public void test3(){
        transactions.stream()
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getTrader)
                .sorted((t1,t2)->t1.getName().compareTo(t2.getName()))
                .distinct()
                .forEach(System.out::println);
    }
    //4. 返回所有交易员的姓名字符串，按字母顺序排序
    @Test
    public void test4(){
        transactions.stream()
                .map(transaction -> transaction.getTrader().getName())
                .sorted()
                .forEach(System.out::println);
    }
    //5. 有没有交易员是在米兰工作的？
    @Test
    public void test5(){
        transactions.stream()
                .filter(transaction -> transaction.getTrader().getCity().equals("Milan"))
                .forEach(System.out::println);
    }
    //6. 打印生活在剑桥的交易员的所有交易额
    @Test
    public void test6(){
        System.out.println(transactions.stream()
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                .reduce(Integer::sum).get());
    }
    //7. 所有交易中，最高的交易额是多少
    @Test
    public void test7(){
        System.out.println(transactions.stream()
                .map(Transaction::getValue)
                .max(Integer::compareTo).get());
    }
    //8. 找到交易额最小的交易
    @Test
    public void test8( ){
        System.out.println(transactions.stream()
                .map(Transaction::getValue)
                .min(Integer::compareTo).get());
    }
}