package airycode_java8.nice7;

import airycode_java8.nice1.Employee;

import org.junit.Test;

import java.util.Arrays;

import java.util.List;

import java.util.Optional;

import java.util.stream.Collectors;

/**

 * Created by admin on 2019/1/3.

 */

public class TestStramAPI {

    /***

     * 1.给定一个数字列表，如何返回一个由每一个数字的平方构成的列表,给定【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<Integer> collect = list.stream().map((x) -> x * x).collect(Collectors.toList());

        collect.forEach(System.out::println);

    }

    /***

     * 2.用map和reduce方法数数流中有多少个emplloyee

     *

     */

    //准备数据

    static List<Employee> employeeList = Arrays.asList(

            new Employee("张三",18,9999.99, Employee.Status.FREE),

            new Employee("李四",38,5555.55,Employee.Status.BUSY),

            new Employee("王五",50,6666.66,Employee.Status.VOCATION),

            new Employee("赵六",16,3333.33,Employee.Status.FREE),

            new Employee("田七",8,7777.77,Employee.Status.BUSY)

    );

    @Test

    public void test2(){

        Optional<Integer> sum = employeeList.stream().map((e) -> 1).reduce(Integer::sum);

        System.out.println(sum.get());

    }

}

　　交易员和交易练习：

package airycode_java8.nice7;

/**

 * 交易员对象

 * Created by admin on 2019/1/3.

 */

public class Trader {

    private String name;

    private String city;

    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 + '\'' +

                '}';

    }

}

package airycode_java8.nice7;

/**

 * 交易对象

 * Created by admin on 2019/1/3.

 */

public class Transaction {

    private Trader trader;

    private int year;

    private int value;

    private String currency;

    public Transaction(Trader trader,int year,int value,String currency){

        this.trader = trader;

        this.year = year;

        this.value = value;

        this.currency = currency;

    }

    public Trader getTrader(){

        return trader;

    }

    public int getYear(){

        return year;

    }

    public int getValue(){

        return value;

    }

    public String getCurrency(){

        return currency;

    }

    @Override

    public String toString(){

        return "i am transaction : my trader is : "

                + trader.getName()

                + " ; my year is : "

                + year

                + " ; my value is : "

                + value

                + " ; my currency is : "

                + currency;

    }

}

package airycode_java8.nice7;

import org.junit.Before;

import org.junit.Test;

import java.util.*;

import java.util.function.Function;

import java.util.stream.Collectors;

import static java.util.Comparator.comparingInt;

import static java.util.stream.Collectors.*;

/**

 * Created by admin on 2019/1/3.

 */

public class TraderExercise {

    List<Trader> traders = new LinkedList<>();

    List<Transaction> transactions = new LinkedList<>();

    @Before

    public void init(){

        Trader t1 = new Trader("trader1","剑桥");

        Trader t2 = new Trader("trader2","米兰");

        Trader t3 = new Trader("trader3","剑桥");

        Trader t4 = new Trader("trader4","剑桥");

        traders.addAll(Arrays.asList(t1,t2,t3,t4));

        Transaction tran1 = new Transaction(t4,2011,300,"$");

        Transaction tran2 = new Transaction(t1,2012,1000,"$");

        Transaction tran3 = new Transaction(t1,2011,400,"￥");

        Transaction tran4 = new Transaction(t2,2012,710,"￥");

        Transaction tran5 = new Transaction(t2,2012,700,"$");

        Transaction tran6 = new Transaction(t3,2012,950,"￥");

        transactions.addAll(Arrays.asList(tran1,tran2,tran3,tran4,tran5,tran6));

    }

    /***

     * 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(){

        traders.stream()

                .map(Trader::getCity)

                .distinct()

                .forEach(System.out::println);

    }

    /***

     *3.查找所有来自剑桥的交易员，并按姓名排序

     */

    @Test

    public void test3(){

//        traders.stream()

//                .filter((t)->"剑桥".equals(t.getCity()))

//                .sorted((e1,e2)->e1.getName().compareTo(e2.getName()))

//                .forEach(System.out::println);

        traders.stream()

                .filter((t)->"剑桥".equals(t.getCity()))

                .sorted(Comparator.comparing(Trader::getName))

                .forEach(System.out::println);

    }

    /***

     *4.查询所有交易员的姓名字符串，并按字母排序

     */

    @Test

    public void test4(){

        traders.stream()

                .filter((t)->"剑桥".equals(t.getCity()))

                .sorted(Comparator.comparing(Trader::getName))

                .forEach(System.out::println);

    }

    /***

     *5.有没有交易员在米兰

     */

    @Test

    public void test5(){

        boolean any = traders.stream()

                .filter((t) -> "米兰".equals(t.getCity()))

                .findAny()

                .isPresent();

        System.out.println(any);

    }

    /***

     * 6.打印在剑桥生活的交易员的所有交易金额

     */

    @Test

    public void test6(){

        Integer sum = transactions.stream()

                .filter(tran -> "剑桥".equals(tran.getTrader().getCity()))

                .map(Transaction::getValue)

                .reduce(0, (val1, val2) -> val1 + val2);

        System.out.println(sum);

    }

    /***

     * 7.所有交易中，最高的交易额是多少

     */

    @Test

    public void test7(){

        transactions.stream()

                .sorted(Comparator.comparing(Transaction::getValue).reversed())

                .findFirst()

                .ifPresent(System.out::println);

        transactions.stream()

                .map(Transaction::getValue)

                .reduce(Integer::max)

                .ifPresent(System.out::println);

    }

    /***

     * 8.找到交易额中最小的金额

     */

    @Test

    public void test8(){

        transactions.stream()

                .map(Transaction::getValue)

                .reduce(Integer::min)

                .ifPresent(System.out::println);

        transactions.stream()

                .min(Comparator.comparing(Transaction::getValue))

                .ifPresent(System.out::println);

        transactions.stream()

                .min(Comparator.comparing((Transaction t1) -> t1.getValue()))

                .ifPresent(System.out :: println);

    }

    /***

     * 9.统计每个交易员的记录

     */

    @Test

    public void test9(){

        transactions.stream()

                .collect(groupingBy(Transaction::getTrader))

                .entrySet().stream()

                .forEach(System.out::println);

    }

    /***

     * 10.找到单笔交易最高的交易员

     */

    @Test

    public void test10(){

        transactions.stream()

                .max(Comparator.comparing(Transaction::getValue))

                .ifPresent(tran->{

                    System.out.println(tran.getTrader());

                });

    }

    /***

     * 11.统计交易总额最高的交易员(排序)

     */

    @Test

    public void test11(){

        transactions.stream().collect(groupingBy(Transaction::getTrader))

                .entrySet().stream().map(t->{

            Map<String,Object> result = new HashMap<>();

            int sum = t.getValue().stream().mapToInt(Transaction :: getValue).sum();

            result.put("sum",sum);

            result.put("trader",t.getKey());

            return result;

        }).sorted(comparingInt((Map m) -> (int)m.get("sum")).reversed()).findFirst().ifPresent(System.out::println);

    }

    /***

     * 12.使用方法引用对transaction排序

     */

    @Test

    public void test12(){

        transactions.stream().sorted(Comparator.comparing(Transaction::getValue)).forEach(System.out::println);

        System.out.println("--------------------------------------------------------------------------------");

        //声明接口的实现方式

        Function<Transaction,Integer> function = Transaction :: getValue;

        Transaction[] transactionsArray = new Transaction[transactions.size()];

        Arrays.sort(transactions.toArray(transactionsArray),Comparator.comparing(function));

        Arrays.asList(transactionsArray).stream().forEach(System.out :: println);

    }

    /***

     * 13.根据trader(对象)将transaction分组

     */

    @Test

    public void test13(){

        transactions.stream()

                .collect(groupingBy(Transaction :: getTrader))

                .entrySet().stream()

                .forEach(System.out :: println);

    }

    //【14.根据货币（字符串）类型分组

    @Test

    public void exercise14(){

        transactions.stream()

                .collect(groupingBy(Transaction :: getCurrency))

                .entrySet().stream()

                .forEach(System.out :: println);

    }

    //【15.获取交易总金额

    @Test

    public void exercise15(){

        int sum1 = transactions.stream().mapToInt(Transaction::getValue).sum();

        System.out.println("通过map转换求和sum1 = " + sum1);

        int sum2 = transactions.stream().collect(Collectors.summingInt(Transaction::getValue));

        System.out.println("通过collect汇总求和sum2 = " + sum2);

        //规约操作都需要使用map将对象映射为返回值的类型

        int sum3 = transactions.stream().map(Transaction::getValue).reduce(0,(t1,t2) -> t1 + t2);

        System.out.println("通过reduce规约求和sum3 = " + sum3);

    }

    //【16.二级分类，先按照交易员分类，然后交易金额大于800归为high，低于800归为low

    @Test

    public void exercise16(){

        transactions.stream()

                .collect(groupingBy(Transaction :: getTrader,groupingBy(t -> {

                    if(t.getValue()< 800 ){

                        return "low";

                    }else {

                        return "heigh";

                    }

                })))

                .entrySet().stream()

                .forEach(System.out :: println);

    }

    //【17.获取每个交易员，交易最大的一笔

    @Test

    public void exercise17(){

        transactions.stream()

                .collect(groupingBy(Transaction::getTrader,maxBy(Comparator.comparingInt(Transaction::getValue))))

                .entrySet().stream()

                .distinct()

                .sorted(Comparator.comparing((Map.Entry m) -> {

                    Trader t = (Trader) m.getKey();

                    return t.getName();

                }))

                .forEach(System.out :: println);

    }

}

　　

最新文章

  1. nginx 配置php
  2. cocoapods pod install 安装报错 is not used in any concrete target
  3. 使用Burpsuite破解Webshell密码
  4. CodeForces 7C Line
  5. EF——一个实体对应两张表，两个实体对应一张表 06 （转）
  6. php目录分隔符DIRECTORY_SEPARATOR
  7. NuGet管理
  8. 多模块分布式系统的简单服务访问 - OSGI原形（.NET）
  9. 自定义控件之--组合控件（titlebar）
  10. Unity3D动态读取外部MP3文件给AudioSource
  11. [LeetCode] Add Bold Tag in String 字符串中增添加粗标签
  12. OC中重写set和get方法、懒加载
  13. mysql 开发进阶篇系列 50 表的数据导入(load data infile，mysqlimport )
  14. Jquery实现检测用户输入用户名和密码不能为空
  15. python实现监控windows服务控制开关服务
  16. perl代码调试
  17. Leetcode——300. 最长上升子序列
  18. php中点击链接直接下载图片
  19. 高rong效chang的可持久化treap
  20. 随机生成验证码及python中的事务

热门文章

  1. 深入 Vue 生命周期
  2. Hive中的order by、sort by、distribute by、cluster by解释及测试
  3. django--admin组件
  4. win7远程ubuntu桌面以及Ubuntu14.04安装搜狗输入法 Ubuntu远程登录windows系统
  5. metasploit的安装
  6. 如何卸载docker
  7. react img 被自动转成base64,无法根据当前路径来动态改变值的解决办法
  8. 有关java反射机制 小结
  9. 浪潮IOT知识点
  10. （转）Marathon健康检查