JDK1.8之Stream综合练习二

Dear 丶 2023-01-11 13:10 133阅读 0赞

> 学海无源苦作舟，一入IT深似海。努力，加油，奋斗。希望这个综合练习对大家有帮助！

Lambda和Stream的综合练习二：

三个实体类：足球运动员、交易员、交易。

package com.demo.stream.traderStream;
    //足球运动员
    public class Cust {
        private  int number;//编号
        private  String name;//姓名
        private int age;//年龄
        private long salary;//薪资
    
        @Override
        public String toString() {
            return "Cust{" +
                    "number=" + number +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", salary=" + salary +
                    '}';
        }
    
        public Cust() {
        }
    
        public Cust(int number, String name, int age, long salary) {
            this.number = number;
            this.name = name;
            this.age = age;
            this.salary = salary;
        }
    
        public int getNumber() {
            return number;
        }
    
        public void setNumber(int number) {
            this.number = number;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public long getSalary() {
            return salary;
        }
    
        public void setSalary(long salary) {
            this.salary = salary;
        }
    }

package com.demo.stream.traderStream;
    //交易员
    public class Trader {
        private String name;
        private String city;
        @Override
        public String toString() {
            return "Trader{" +
                    "name='" + name + '\'' +
                    ", 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;
        }
    
        public Trader(String name, String city) {
            this.name = name;
            this.city = city;
        }
    
        //无参
        public Trader() {
        }
    
    }

package com.demo.stream.traderStream;
    //交易
    public class Transaction {
        //交易员
        private Trader trader;
        //交易日期
        private int year;
        //交易金额
        private int value;
    
        @Override
        public String toString() {
            return "Transaction{" +
                    "trader=" + trader +
                    ", year=" + year +
                    ", value=" + 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;
        }
    }

综合测试类：

package com.demo.stream.traderStream;
    import org.junit.Before;
    import org.junit.Test;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.Optional;
    import java.util.stream.Collectors;
    /*
     * Stream API练习
     */
    public class StreamText {
        //初始交易为空
        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)
            );
        }
        List<Cust> custs = Arrays.asList(
                new Cust(101,"梅西",30,33000000L),
                new Cust(102,"伊布",35,23000000L),
                new Cust(103,"哈维",34,20000000L),
                new Cust(104,"伊列斯塔",33,18000000L),
                new Cust(105,"小罗",37,15000000L),
                new Cust(106,"内马尔",27,32000000L),
                new Cust(106,"内马尔",27,32000000L),
                new Cust(106,"姆巴佩",23,30500000L)
        );
        @Test
        public void test0() {
            /*
             * 给定一个数字列表，返回每个数字平反的列表
             */
            List<Integer> l1 = Arrays.asList(1,2,3,4).stream().map(x->x*x).collect(Collectors.toList());
            System.out.println(l1);
            System.out.println("=========分隔线=============");
            /*
             * 用Map和Reduce计算流中有多少个Cust对象
             * 当然你可以有很多种方法都可以统计列表中对象的个数，只是为了更进一步了解Stream API的用法，才要求这样做
             */
            Integer ic1 = custs.stream().map(Cust::getAge).reduce(0, (x,y)->x+1);
            System.out.println("ic1:"+ic1);
            Integer ic2 = custs.stream().map(e -> 1).reduce(0, Integer::sum);
            System.out.println("ic2:"+ic2);
        }
    
        //1. 找出2011年发生的所有交易， 并按交易额排序（从低到高）
        @Test
        public void test1() {
            transactions.stream().filter(x->x.getYear()==2011).sorted((x,y)->{
                if(x.getValue()>y.getValue()) {
                    return 1;
                }else if(x.getValue()<y.getValue()) {
                    return -1;
                }else {
                    return 0;
                }
    
            }).forEach(System.out::println);
        }
        //2. 交易员都在哪些不同的城市工作过？
        @Test
        public void test2() {
            //实际上就是找出所有交易员工作的城市并排重
            //方式1
            transactions.stream().map(Transaction::getTrader).map(Trader::getCity).distinct().forEach(System.out::println);
            //方式2
            transactions.stream().map(x->x.getTrader().getCity()).distinct().forEach(System.out::println);
        }
    
    
        //3. 查找所有来自剑桥的交易员，并按姓名排序
        @Test
        public void test3() {
            transactions.stream().filter(x->x.getTrader().getCity().equals("Cambridge")).sorted((x,y)->{
                return x.getTrader().getName().compareTo(y.getTrader().getName());
            }).forEach(System.out::println);
        }
    
        //4. 返回所有交易员的姓名字符串，按字母顺序排序
        @Test
        public void test4() {
            //方式1
            String s = transactions.stream().map(x->x.getTrader().getName()).distinct().sorted().collect(Collectors.joining(","));
            System.out.println(s);
            //方式2
            String s1 = transactions.stream().map(x->x.getTrader().getName()).distinct().sorted().reduce("", (x,y)->x+","+y).replaceFirst(",", "");
            System.out.println(s1);
        }
    
        //5. 有没有交易员是在米兰工作的？
        @Test
        public void test5() {
            Boolean b = transactions.stream().anyMatch(x->x.getTrader().getCity().equals("Milan"));
            System.out.println(b);
        }
    
    
        //6. 打印生活在剑桥的交易员的所有交易额
        @Test
        public void test6() {
            //方式1
            Map<Object, List<Transaction>> mt = transactions.stream().filter(x->x.getTrader().getCity().equals("Cambridge"))
                    .collect(Collectors.groupingBy(x->x.getTrader().getName()));
            //System.out.println(mt);
            for(Object obj:mt.keySet()) {
                Integer i = mt.get(obj.toString()).stream().collect(Collectors.summingInt(x->x.getValue()));
                System.out.println(obj+":"+i);
            }
    
            //方式2
            Map<Object,Integer> mt1 = transactions.stream().filter(x->x.getTrader().getCity().equals("Cambridge"))
                    .collect(Collectors.groupingBy(x->x.getTrader().getName(), Collectors.summingInt(x->x.getValue())));
            System.out.println(mt1);
    
            //很明显流提供的支持确实很强大，第二种方式要简单好多好多
        }
    
    
        //7. 所有交易中，最高的交易额是多少
        @Test
        public void test7() {
            Optional<Integer> i = transactions.stream().map(Transaction::getValue).collect(Collectors.maxBy(Integer::compare));
            System.out.println(i.get());
        }
    
        //8. 找到交易额最小的交易
        @Test
        public void test8() {
            Optional<Transaction> op = transactions.stream().min((x,y)->Integer.compare(x.getValue(), y.getValue()));
            System.out.println(op.get());
        }
    
    }

以上9个测试类输出结果如下：

Test0:

\[1, 4, 9, 16\]  
=========分隔线=============  
ic1:8  
ic2:8

Test1:

Transaction\{trader=Trader\{name='Brian', city='Cambridge'\}, year=2011, value=300\}  
Transaction\{trader=Trader\{name='Raoul', city='Cambridge'\}, year=2011, value=400\}

Test2:

Cambridge  
Milan  
Cambridge  
Milan

Test3:

Transaction\{trader=Trader\{name='Alan', city='Cambridge'\}, year=2012, value=950\}  
Transaction\{trader=Trader\{name='Brian', city='Cambridge'\}, year=2011, value=300\}  
Transaction\{trader=Trader\{name='Raoul', city='Cambridge'\}, year=2012, value=1000\}  
Transaction\{trader=Trader\{name='Raoul', city='Cambridge'\}, year=2011, value=400\}

Test4:

Alan,Brian,Mario,Raoul  
Alan,Brian,Mario,Raoul

Test5:

true

Test6:

Brian:300  
Raoul:1400  
Alan:950  
\{Brian=300, Raoul=1400, Alan=950\}

Test7:

1000

Test8:

Transaction\{trader=Trader\{name='Brian', city='Cambridge'\}, year=2011, value=300\}