NumericStream && Stream綜合練習

一、NumericStream　　　　

我們可以將一個Stream轉化爲對應的數字Stream，如mapToInt、mapToLong轉化爲IntStream、LongStream等(NumericStream又可以通過boxed、mapToObj方法轉化回去)，這樣做的好處是可以節省比較多的內存開銷，數據量大的話是比較明顯的，因爲int 4個字節的數字比Integer類型的小很多。所以能用NumericStream類型的就用。

 1 package com.cy.java8;
 2 
 3 import java.util.Arrays;
 4 import java.util.stream.IntStream;
 5 import java.util.stream.Stream;
 6 
 7 public class NumericStream {
 8 
 9     public static void main(String[] args) {
10         Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
11 
12         //把大於3的和打印出來
13         Integer result = stream.filter(i -> i.intValue() > 3).reduce(0, Integer::sum);
14         System.out.println(result);
15 
16         //可以將Stream<Integer>轉化爲IntStream，再求和
17         stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
18         int result2 = stream.mapToInt(Integer::intValue).filter(i -> i > 3).sum();
19         System.out.println(result2);
20 
21         //將IntStream轉化爲Stream<Integer>
22         stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
23         IntStream intStream = stream.mapToInt(Integer::intValue);
24         Stream<Integer> boxed = intStream.boxed();
25 
26         //計算1..100數裏面，有哪些數能和9，滿足勾股定理，然後將這些數以[a, b, c]的形式打印出來
27         int a = 9;
28         IntStream.rangeClosed(1, 100).filter(b -> Math.sqrt(b * b + a * a) % 1 == 0)
29                 .boxed()
30                 .map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)})
31                 .forEach(r -> System.out.println("a=" + r[0] + ", b=" + r[1] + ", c=" + r[2]));
32 
33         //或者這麼寫
34         IntStream.rangeClosed(1, 100).filter(b -> Math.sqrt(b * b + a * a) % 1 == 0)
35                 .mapToObj(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)})
36                 .forEach(r -> System.out.println("a=" + r[0] + ", b=" + r[1] + ", c=" + r[2]));
37     }
38 
39 }

打印結果：

9
9
a=9, b=12, c=15
a=9, b=40, c=41
a=9, b=12, c=15
a=9, b=40, c=41

 

二、Stream綜合練習　　　　　　　　

需求：
1.獲取2011年所有的交易，根據value排序。
2.哪個是交易員工作的唯一城市？
3.找到所有來自劍橋的交易員，根據名字排序
4.返回一個根據ASCII排序的所有交易員的名字的string
5.有來自米蘭的交易員嗎？
...

代碼：

Transaction：

 1 package com.cy.java8;
 2 
 3 import lombok.AllArgsConstructor;
 4 import lombok.Data;
 5 
 6 /**
 7  * 交易數據
 8  */
 9 @AllArgsConstructor
10 @Data
11 public class Transaction {
12     private final Trader trader;
13     private final int year;
14     private final int value;
15 }

Trader：

 1 package com.cy.java8;
 2 
 3 import lombok.AllArgsConstructor;
 4 import lombok.Data;
 5 
 6 /**
 7  * 交易員
 8  */
 9 @AllArgsConstructor
10 @Data
11 public class Trader {
12     private final String name;
13     private final String city;
14 }

 1 package com.cy.java8;
 2 
 3 import java.util.Arrays;
 4 import java.util.Comparator;
 5 import java.util.List;
 6 import java.util.Optional;
 7 import java.util.stream.Collectors;
 8 
 9 public class StreamInAction {
10 
11     public static void main(String[] args) {
12         Trader raoul = new Trader("Raoul", "Cambridge");
13         Trader mario = new Trader("Mario", "Milan");
14         Trader alan = new Trader("Alan", "Cambridge");
15         Trader brian = new Trader("Brian", "Cambridge");
16 
17         List<Transaction> transactions = Arrays.asList(
18                 new Transaction(brian, 2011, 300),
19                 new Transaction(raoul, 2012, 1000),
20                 new Transaction(raoul, 2011, 400),
21                 new Transaction(mario, 2012, 710),
22                 new Transaction(mario, 2012, 700),
23                 new Transaction(alan, 2012, 950)
24         );
25 
26         //獲取2011年的所有交易，並且按value排序
27         List<Transaction> result = transactions.stream().
28                 filter(t -> t.getYear() == 2011)
29                 .sorted(Comparator.comparingInt(Transaction::getValue))
30                 .collect(Collectors.toList());
31         System.out.println(result);     //[Transaction(trader=Trader(name=Brian, city=Cambridge), year=2011, value=300), Transaction(trader=Trader(name=Raoul, city=Cambridge), year=2011, value=400)]
32 
33 
34         //交易員工作的城市有哪些
35         List<String> result1 = transactions.stream().map(t -> t.getTrader().getCity()).distinct().collect(Collectors.toList());
36         System.out.println(result1);    //[Cambridge, Milan]
37 
38         //找到所有來自劍橋的交易員，按名字排序
39         List<Trader> result2 = transactions.stream().map(Transaction::getTrader)
40                                             .filter(t -> t.getCity().equals("Cambridge"))
41                                             .distinct()
42                                             .sorted(Comparator.comparing(Trader::getName))
43                                             .collect(Collectors.toList());
44         System.out.println(result2);    //[Trader(name=Alan, city=Cambridge), Trader(name=Brian, city=Cambridge), Trader(name=Raoul, city=Cambridge)]
45 
46         //返回一個字符串，包括所有交易員的名字，按ascii排序
47         String result3 = transactions.stream().map(t -> t.getTrader().getName())
48                                             .distinct()
49                                             .sorted()
50                                             .reduce("", (name1, name2) -> name1 + name2);
51         System.out.println(result3);    //AlanBrianMarioRaoul
52 
53         //有來自米蘭的交易員嗎
54         boolean result4 = transactions.stream().anyMatch(t -> t.getTrader().getCity().equals("Milan"));
55         System.out.println(result4);    //true
56 
57         //打印所有的交易value總和來自於來自於生活在劍橋的交易員
58         Integer result5 = transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge"))
59                                             .map(Transaction::getValue)
60                                             .reduce(0, (t1, t2) -> t1 + t2);
61         System.out.println(result5);    //2650
62 
63         //最高的交易的value
64         Optional<Transaction> optional = transactions.stream().max(Comparator.comparingInt(Transaction::getValue));
65         System.out.println(optional.get().getValue());      //1000
66         System.out.println(transactions.stream().map(Transaction::getValue).reduce((i,j) -> i>j?i:j).get());    //1000
67 
68         //最小的交易的value
69         System.out.println(transactions.stream().map(Transaction::getValue).reduce(Integer::min).get());    //300
70     }
71 }

 

 

 

 

 

---