Lambda_Stream练习

JDK8 Lambda练习

package cn.cdqf.lambda;

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

public class Optional2 {
    public static void main(String[] args) {
        List<Employee> employees = initData();
        /**
         * 筛选出 2005 年入职的员工，并按薪资从低到高排序
         * 该公司的员工都分布与那些城市，并排序
         * 获取所有员工姓名，并按首字母排序
         * 查看是否有成都的员工
         * 获取所有成都的员工的薪资总和
         * 获取公司中薪资最高的薪资
         * 获取公司中薪资最低的员工信息
         * 统计所有地区的工资总和
         */
        Stream<Employee> sorted = employees.stream().filter(employee -> employee.getBeginDate().equals("2005")).
                sorted((e1, e2) -> Integer.compare(e2.getSalary() - e1.getSalary(), 0));
        // sorted.forEach(System.out::println);

        Stream<String> sorted1 = employees.stream().map(Employee::getCity).sorted();
        // sorted1.distinct().forEach(System.out::println);

        Stream<String> sorted2 = employees.stream().map(Employee::getName).sorted(Comparator.reverseOrder());
        // sorted2.forEach(System.out::println);

        boolean cd = employees.stream().anyMatch(employee -> employee.getCity().equals("成都"));
        // System.out.println(cd);

        int sum = employees.stream().filter(employee -> employee.getCity().equals("成都")).mapToInt(Employee::getSalary).sum();
        // System.out.println(sum);

        Optional<Employee> max = employees.stream().max(Comparator.comparingInt(Employee::getSalary));
        // max.ifPresent(employee -> System.out.println(employee.getSalary()));

        Optional<Employee> min = employees.stream().min(Comparator.comparingInt(Employee::getSalary));
        // min.ifPresent(employee -> System.out.println(employee.getSalary()));

        IntSummaryStatistics collect = employees.stream().collect(Collectors.summarizingInt(Employee::getSalary));
        System.out.println(collect.getSum());

    }

    private static List<Employee> initData() {
        Employee emma1 = new Employee("2005", "成都", "张瑞眼", 50000);
        Employee emma2 = new Employee("2006", "北京", "马云", 60000);
        Employee emma3 = new Employee("2007", "深圳", "马化腾", 30000);
        Employee emma4 = new Employee("2008", "香港", "王健林", 40000);
        Employee emma5 = new Employee("2005", "成都", "张小龙", 20000);
        return Arrays.asList(emma1, emma2, emma3, emma4, emma5);
    }
}

class Employee {
    //入职时间 ，城市，姓名，薪资
    private String beginDate;
    private String city;
    private String name;
    private int salary;

    public String getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(String beginDate) {
        this.beginDate = beginDate;
    }

    public String getCity() {
        return city;
    }

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

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

    public String getName() {
        return name;
    }

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

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public Employee(String beginDate, String city, String name, int salary) {
        this.beginDate = beginDate;
        this.city = city;
        this.name = name;
        this.salary = salary;
    }
}

package cn.cdqf.lambda;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Optional3 {

    public static void main(String[] args) {
        List<Transaction> init = init();

        // 1. 找出2011年发生的所有交易， 并按交易额排序（从低到高）
        Stream<Integer> sorted = init.stream().filter(t -> t.getYear() == 2011).map(Transaction::getValue).sorted();
        // sorted.forEach(System.out::println);

        // 2. 交易员都在哪些不同的城市工作过？
        // init.stream().map(Transaction::getTrader).map(Trader::getCity).distinct().forEach(System.out::println);

        //3. 查找所有来自剑桥的交易员，并按姓名排序
        Stream<String> cambridge = init.stream().map(Transaction::getTrader).
                filter(trader -> trader.getCity().equals("Cambridge")).map(Trader::getName).sorted();
        // cambridge.distinct().forEach(System.out::println);

        // 4. 返回所有交易员的姓名字符串，按字母顺序排序
        Stream<String> sorted1 = init.stream().map(Transaction::getTrader).map(Trader::getName).sorted();
        // sorted1.distinct().forEach(System.out::println);

        // 5. 有没有交易员是在米兰工作的？
        boolean milan = init.stream().map(Transaction::getTrader).
                map(Trader::getCity).anyMatch(Predicate.isEqual("Milan"));
        // System.out.println(milan);

        // 6. 打印生活在剑桥的交易员的所有交易额
        Stream<Integer> cambridge1 = init.stream().filter(transaction ->
                transaction.getTrader().getCity().equals("Cambridge")).map(Transaction::getValue);
        // cambridge1.forEach(System.out::println);

        // 7. 所有交易中，最高的交易额是多少
        Optional<Integer> max = init.stream().map(Transaction::getValue).max(Integer::compareTo);
        // max.ifPresent(System.out::println);

        // 8. 找到交易额最小的交易
        Optional<Integer> min = init.stream().map(Transaction::getValue).min(Integer::compareTo);
        min.ifPresent(System.out::println);


    }
    public static List<Transaction> init(){
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");

        return 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)
        );
    }
}


// 交易员
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 + "]";
    }

}

// 交易
class Transaction {

    //交易员
    private Trader trader;
    //交易日期
    private int year;
    //交易金额
    private int value;

    public Transaction() {
    }

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

    public Trader getTrader() {
        return trader;
    }

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

    public int getYear() {
        return year;
    }

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

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Transaction [trader=" + trader + ", year=" + year + ", value="
                + value + "]";
    }

}