NumericStream && Stream综合练习

一、NumericStream　　　　

我们可以将一个Stream转化为对应的数字Stream，如mapToInt、mapToLong转化为IntStream、LongStream等(NumericStream又可以通过boxed、mapToObj方法转化回去)，这样做的好处是可以节省比较多的内存开销，数据量大的话是比较明显的，因为int 4个字节的数字比Integer类型的小很多。所以能用NumericStream类型的就用。

 package com.cy.java8;

 import java.util.Arrays;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;

 public class NumericStream {

     public static void main(String[] args) {
         Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});

         //把大于3的和打印出来
         Integer result = stream.filter(i -> i.intValue() > 3).reduce(0, Integer::sum);
         System.out.println(result);

         //可以将Stream<Integer>转化为IntStream，再求和
         stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
         int result2 = stream.mapToInt(Integer::intValue).filter(i -> i > 3).sum();
         System.out.println(result2);

         //将IntStream转化为Stream<Integer>
         stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
         IntStream intStream = stream.mapToInt(Integer::intValue);
         Stream<Integer> boxed = intStream.boxed();

         //计算1..100数里面，有哪些数能和9，满足勾股定理，然后将这些数以[a, b, c]的形式打印出来
         int a = 9;
         IntStream.rangeClosed(1, 100).filter(b -> Math.sqrt(b * b + a * a) % 1 == 0)
                 .boxed()
                 .map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)})
                 .forEach(r -> System.out.println("a=" + r[0] + ", b=" + r[1] + ", c=" + r[2]));

         //或者这么写
         IntStream.rangeClosed(1, 100).filter(b -> Math.sqrt(b * b + a * a) % 1 == 0)
                 .mapToObj(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)})
                 .forEach(r -> System.out.println("a=" + r[0] + ", b=" + r[1] + ", c=" + r[2]));
     }

 }

打印结果：

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：

 package com.cy.java8;

 import lombok.AllArgsConstructor;
 import lombok.Data;

 /**
  * 交易数据
  */
 @AllArgsConstructor
 @Data
 public class Transaction {
     private final Trader trader;
     private final int year;
     private final int value;
 }

Trader：

 package com.cy.java8;

 import lombok.AllArgsConstructor;
 import lombok.Data;

 /**
  * 交易员
  */
 @AllArgsConstructor
 @Data
 public class Trader {
     private final String name;
     private final String city;
 }

 package com.cy.java8;

 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;

 public class StreamInAction {

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

         //获取2011年的所有交易，并且按value排序
         List<Transaction> result = transactions.stream().
                 filter(t -> t.getYear() == 2011)
                 .sorted(Comparator.comparingInt(Transaction::getValue))
                 .collect(Collectors.toList());
         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)]

         //交易员工作的城市有哪些
         List<String> result1 = transactions.stream().map(t -> t.getTrader().getCity()).distinct().collect(Collectors.toList());
         System.out.println(result1);    //[Cambridge, Milan]

         //找到所有来自剑桥的交易员，按名字排序
         List<Trader> result2 = transactions.stream().map(Transaction::getTrader)
                                             .filter(t -> t.getCity().equals("Cambridge"))
                                             .distinct()
                                             .sorted(Comparator.comparing(Trader::getName))
                                             .collect(Collectors.toList());
         System.out.println(result2);    //[Trader(name=Alan, city=Cambridge), Trader(name=Brian, city=Cambridge), Trader(name=Raoul, city=Cambridge)]

         //返回一个字符串，包括所有交易员的名字，按ascii排序
         String result3 = transactions.stream().map(t -> t.getTrader().getName())
                                             .distinct()
                                             .sorted()
                                             .reduce("", (name1, name2) -> name1 + name2);
         System.out.println(result3);    //AlanBrianMarioRaoul

         //有来自米兰的交易员吗
         boolean result4 = transactions.stream().anyMatch(t -> t.getTrader().getCity().equals("Milan"));
         System.out.println(result4);    //true

         //打印所有的交易value总和来自于来自于生活在剑桥的交易员
         Integer result5 = transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge"))
                                             .map(Transaction::getValue)
                                             .reduce(0, (t1, t2) -> t1 + t2);
         System.out.println(result5);    //2650

         //最高的交易的value
         Optional<Transaction> optional = transactions.stream().max(Comparator.comparingInt(Transaction::getValue));
         System.out.println(optional.get().getValue());      //
         System.out.println(transactions.stream().map(Transaction::getValue).reduce((i,j) -> i>j?i:j).get());    //1000

         //最小的交易的value
         System.out.println(transactions.stream().map(Transaction::getValue).reduce(Integer::min).get());    //
     }
 }

---