java 8 流的使用示例

public  class Trader{
   
   private String name;
   private String city;

   public Trader(String n, String c){
      this.name = n;
      this.city = c;
   }

   public String getName(){
      return this.name;
   }

   public String getCity(){
      return this.city;
   }

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

   public String toString(){
      return "Trader:"+this.name + " in " + this.city;
   }
}

 

public class Transaction{

   private Trader trader;
   private int year;
   private int value;

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

   public Trader getTrader(){ 
      return this.trader;
   }

   public int getYear(){
      return this.year;
   }

   public int getValue(){
      return this.value;
   }
   
   public String toString(){
       return "{" + this.trader + ", " +
              "year: "+this.year+", " +
              "value:" + this.value +"}";
   }
}

 public static void main(String ...args){
       Trader raoul = new Trader("Raoul", "Cambridge");
       Trader mario = new Trader("Mario","Milan");
       Trader alan = new Trader("Alan","Cambridge");
       Trader brian = new Trader("Brian","Cambridge");

   List<Transaction> 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)
       );


       // Query 1: Find all transactions from year 2011 and sort them by value (small to high).
       List<Transaction> tr2011 = transactions.stream()
                                              .filter(transaction -> transaction.getYear() == 2011)
                                              .sorted(comparing(Transaction::getValue))
                                              .collect(toList());
       System.out.println(tr2011);

       // Query 2: What are all the unique cities where the traders work?
       List<String> cities =
           transactions.stream()
                       .map(transaction -> transaction.getTrader().getCity())
                       .distinct()
                       .collect(toList());
       System.out.println(cities);

去重还可以使用set集合达成

如下：

Set<String> collect = transactions.stream()
        .map(transaction -> transaction.getTrader().getCity())
        .collect(toSet());
System.out.println(collect);

       // Query 3: Find all traders from Cambridge and sort them by name.

       List<Trader> traders =
           transactions.stream()
                       .map(Transaction::getTrader)
                       .filter(trader -> trader.getCity().equals("Cambridge"))
                       .distinct()
                       .sorted(comparing(Trader::getName))
                       .collect(toList());
       System.out.println(traders);




       // Query 4: Return a string of all traders’ names sorted alphabetically.

       String traderStr =
           transactions.stream()
                       .map(transaction -> transaction.getTrader().getName())
                       .distinct()
                       .sorted()
                       .reduce("", (n1, n2) -> n1 + n2);
       System.out.println(traderStr);
有个更高效地解决方案：

String collect1 = transactions.stream().
        map(transaction -> transaction.getTrader().getName())
        .distinct()
        .sorted()
        .collect(Collectors.joining());

joining（）底层使用StringBuilder

 

 

       // Query 5: Are there any trader based in Milan?

       boolean milanBased =
           transactions.stream()
                       .anyMatch(transaction -> transaction.getTrader()
                                                           .getCity()
                                                           .equals("Milan")
                                );
       System.out.println(milanBased);

       System.out.println(">>>>>>>>>>>");
transactions.stream().filter(transaction -> transaction.getTrader().getCity().equals("Cambridge")).map(Transaction::getValue).forEach(System.out::println);
       System.out.println(">>>>>>>>>>>");

       Optional<Transaction> max = transactions.stream().max(comparing(Transaction::getValue)),;
       System.out.println("max："+max);


       // Query 6: Update all transactions so that the traders from Milan are set to Cambridge.
               transactions.stream()
                       .map(Transaction::getTrader)
                       .filter(trader -> trader.getCity().equals("Milan"))
                       .forEach(trader -> trader.setCity("Cambridge"));
       System.out.println(transactions);


       // Query 7: What's the highest value in all the transactions?
       int highestValue =
           transactions.stream()
                       .map(Transaction::getValue)
                       .reduce(0, Integer::max);
       System.out.println(highestValue);

找出最小交易额可以使用如下方法

Optional<Transaction> min = transactions.stream().min(comparing(Transaction::getValue));

   }

// Stream.iterate
Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);//生成前十个正偶数 iterate是无限流所以得用limit选取元素个数

按顺序一次生成一系列值时使用，纯粹不变：不修改现有状态

// random stream of doubles with Stream.generate
Stream.generate(Math::random)
      .limit(10)
      .forEach(System.out::println);//接受自己实现的 Supplier  即 T get()方法;不是依次对每个新生成的值应用函数