java8 优雅编程实例@Lambda表达式和流的使用

1、前言:

使用java8的lambda表达式和流处理方式可以极大的简化java代码,编写出优雅的java代码。

 

2、基础

2.1、Lambda表达式

2.1.1、Lambda表达式理解为,简洁地表示可传递的匿名函数的一种方式。它没有名称,但它有参数列表、函数主体、返回类型,可能还有一个可以抛出的异常列表。

2.1.2、Lambda表达式有三个部分,参数列表、箭头、Lambda主体。

基本语法是:(parameters) -> expression

或(请注意语句的花括号) (parameters) -> { statements; }

2.2、流

2.2.1、流是Java API的新成员,它允许你以声明性方式处理数据集合(通过查询语句来表达,而不是临时编写一个实现)。就现在来说,你可以把它们看成遍历数据集的高级迭代器

 

2.2.2、流与集合

粗略地说,集合与流之间的差异就在于什么时候进行计算。

集合是一个内存中的数据结构,它包含数据结构中目前所有的值——集合中的每个元素都得先算出来才能添加到集合中。(你可以往集合里加东西或者删东西,但是不管什么时候,集合中的每个元素都是放在内存里的,元素都得先算出来才能成为集合的一部分。)

相比之下,流则是在概念上固定的数据结构(你不能添加或删除元素),其元素则是按需计算的。

2.2.2.1 流只能遍历一次。集合可以遍历多次。

2.2.2.2 流使用内部迭代。它帮你把迭代做了,还把得到的流值存在了某个地方,你只要给出一个函数说要干什么就可以。

集合需要用户做迭代,称为外部迭代。(foreach/iterator)

2.2.3、流操作

2.2.3.1、中间操作:

中间操作会返回另一个流,合并起来,在终端操作时一次性全部处理。

例如:filter、map、limit、distinct、

2.2.3.2、终端操作:

终端操作会从流的流水线生成结果(非流的值)。例如:count、forEach、collect

2.2.3.3、使用流

流的使用一般包括三件事:

一个数据源(如集合)来执行一个查询;

一个中间操作链,形成一条流的流水线;

一个终端操作,执行流水线,并能生成结果

 

3、代码实例

3.1、找出2011年发生的所有交易,并按交易额排序。

Java8以前写法:

  //定义临时变量

      List transactionTempList = new ArrayList();

         //先过滤出2011年份发生的交易,存入临时变量中

         for (Transaction transaction : transactionList) {

             if(transaction.getTradTime().equals("2011")){

                  transactionTempList.add(transaction);

             }

         }

         //按交易额排序,实现Comparator接口

         Collections.sort(transactionTempList, new Comparator() {

             @Override

             public int compare(Transaction o1, Transaction o2) {

                  return String.valueOf((o1.getTranMoney())).compareTo(String.valueOf((o2.getTranMoney())));

             }

         });

//打印数据

         for (Transaction transaction : transactionTempList) {

             System.out.println(transaction.toString());

       }

 

Java8写法16行代码变1行

      //使用stream处理数据。使用filter过滤2011年的交易记录。使用sorted排序。

//Transaction::getTranMoney写法可以简单理解为调用Transaction的getTranMoney方法。

      

       List tranList1 = transactionList.stream().filter(tran -> tran.getTradTime().equals("2011")).sorted(comparing(Transaction::getTranMoney)).collect(toList());

       //打印数据

       tranList1.stream().forEach(System.out::println);

 

3.2、交易员都在哪些不同的城市工作过。

Java7写法

  //定义变量存储城市

      List cityTempList = new ArrayList();

      for (Transaction transaction : transactionList) {

          String cityTemp = transaction.getTrader().getCity();

          if(!cityTempList.contains(cityTemp)){

              cityTempList.add(cityTemp);

          }

      }

      //遍历城市集合

      for (String string : cityTempList) {

          System.out.println(string);

      }

Java8优雅写法:

 

      //2、交易员都在哪些不同的城市工作过

      transactionList.stream().map(tran -> tran.getTrader()).map(trad -> trad.getCity()).distinct().forEach(System.out::println);

 

 

3.3、查找所有来自于成都的交易员,并按姓名排序。

 

Java7写法:

      List cityTempList = new ArrayList();

      for (Transaction transaction : transactionList) {

          String cityTemp = transaction.getTrader().getCity();

          if(cityTemp.equals("成都")){

              cityTempList.add(transaction);

          }

      }

      for (Transaction transaction : cityTempList) {

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

      }

 

Java8优雅写法:

List tranList3 = transactionList.stream().map(tran -> tran.getTrader()).filter(trad -> trad.getCity().equals("成都")).sorted(comparing(Trader::getName)).collect(toList());

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

 

3.4、返回所有交易员的姓名字符串,按字母顺序排序

List tranList4 = transactionList.stream().map(tran -> tran.getTrader()).map(trad -> trad.getName()).distinct().sorted().collect(toList());

3.5、有没有交易员是在成都工作的

写法1:

transactionList.stream().map(tran -> tran.getTrader().getCity().equals("成都")).findAny().ifPresent(System.out::println);;

 

写法2:

      System.out.println(transactionList.stream().anyMatch(transaction -> transaction.getTrader().getCity().equals("成都")));

 

3.6、打印生活在成都的交易员的所有交易额

System.out.println(transactionList.stream().filter(tranB -> tranB.getTrader().getCity().equals("成都")).map(Transaction::getTranMoney).reduce(Double::sum));

3.7、所有交易中,高的交易额是多少?

System.out.println(transactionList.stream().map(Transaction::getTranMoney).reduce(Double::max));

3.8、找到交易额小的交易 System.out.println(transactionList.stream().map(Transaction::getTranMoney).reduce(Double::min));

 

扩张:

交易员类Trader

public class Trader {

  private String name;

  private String city;

  /**

  含参构造函数

  */

  public Trader(String name, String city) {

      super();

      this.name = name;

      this.city = city;

  }

  /**

  重写tostring方法

  */

  @Override

  public String toString() {

      return "Trader [name=" + name + ", city=" + city + "]";

  }

  /**

  省略get、set方法

  */

}

 

交易类Transaction。

public class Transaction {

  private Trader trader;//交易员

  private String tradTime;//交易年份

  private double tranMoney;//交易金额

  public Transaction(Trader trader, String tradTime, double tranMoney) {

      super();

      this.trader = trader;

      this.tradTime = tradTime;

      this.tranMoney = tranMoney;

  }

  @Override

  public String toString() {

      return "Transaction [trader=" + trader + ", tradTime=" + tradTime + ", tranMoney=" + tranMoney + "]";

  }

}

 

 

初始化交易员类

      Trader t1 = new Trader("liubei", "成都");

      Trader t2 = new Trader("caocao", "洛阳");

      Trader t3 = new Trader("sunquan", "南京");

      Trader t4 = new Trader("guanyu", "成都");

      Trader t5 = new Trader("zhangfei", "成都");

      Trader t6 = new Trader("zhaoyun", "成都");

 

初始化交易类

      List transactionList = Arrays.asList(new Transaction(t1, "2011", 300),

              new Transaction(t2, "2013", 500),

              new Transaction(t3, "2014", 700),

              new Transaction(t4, "2011", 600),

              new Transaction(t5, "2012", 600),

              new Transaction(t6, "2011", 200));

你可能感兴趣的:(JAVA基础)