JDK8-StreamAPI(六)

篩選切片

package cn.wcj.jdk8.lambda.test;



import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;
/*
 * 一、Stream API 的操作步驟：
 * 
 *  建立 Stream
 * 
 *  中間操作
 * 
 *  終止操作(終端操作)
 */
public class StreamTest01 {

    @Test
    public void test1() {
        // Collection 提供了兩個方法  stream() 與 parallelStream()
        List<String> list=new ArrayList<>()   ;
        Stream<String> stream=list.stream()   ;   //順序流
        Stream<String> parallelStream = list.parallelStream();   //并行流

        // 通過 Arrays 中的 stream() 擷取一個數組流
        Integer[] nums=new Integer[]    ;
        Stream<Integer> stream2 = Arrays.stream(nums)   ;


        // 通過 Stream 類中靜态方法 of()
        Stream<Integer> stream3 = Stream.of(,,,,,)  ;

        //建立無限流
        Stream<Integer> stream4 = Stream.iterate(, (x)->x+).limit();
        stream4.forEach(System.out::println) ;

        Stream<Double> stream5 = Stream.generate(Math::random).limit() ;
        stream5.forEach(System.out::println)  ;


    }

    List<Emp> emps=new ArrayList<Emp>(
            Arrays.asList(
               new Emp("3333", "張三", , ),          
               new Emp("4444", "李四", , ),          
               new Emp("5555", "王五", , ),          
               new Emp("6666", "趙六", , ),          
               new Emp("7777", "田七", , ),  
               new Emp("7777", "田七", , ),  
               new Emp("7777", "田七", , ),  
               new Emp("7777", "田七", , ),  
               new Emp("7777", "田七", , ),  
               new Emp("7777", "田七", , )
            )
        );


    /*
      篩選與切片
        filter——接收 Lambda ， 從流中排除某些元素。
        limit——截斷流，使其元素不超過給定數量。
        skip(n) —— 跳過元素，傳回一個扔掉了前 n 個元素的流。若流中元素不足 n 個，則傳回一個空流。與 limit(n) 互補
        distinct——篩選，通過流所生成元素的 hashCode() 和 equals() 去除重複元素
     */
    //内部疊代：疊代操作 Stream API 内部完成
    @Test
    public void test2(){
        //所有的中間操作不會做任何的處理
        Stream<Emp> stream = emps.stream()
                                 .filter((e)->{
                                                System.out.println("中間操作") ;
                                                return e.getAge()>  ;
                                              })  ;
        //隻有當做終止操作時，所有的中間操作會一次性的全部執行，稱為“惰性求值”
        stream.forEach(System.out::println)  ;    
    }

    //外部疊代
    @Test
    public void test3(){
        Iterator<Emp> iterator = emps.iterator();
        while(iterator.hasNext())
            System.out.println(iterator.next())  ;
    }



    @Test
    public void test4(){
        emps.stream()
            .filter((e)->{
                System.out.println("短路") ; //類似&& ||
                return e.getSalary()>   ;
            })
            .limit()
            .forEach(System.out::println)  ;
    }

    @Test
    public void test5(){
        emps.stream()
            .filter((e)->{
                System.out.println("短路")  ;
                return e.getSalary()>   ;
            })
            .skip()  
            .forEach(System.out::println);
    }

    @Test
    public void test6(){
        emps.stream()
            .distinct()
            .forEach(System.out::println) ;
    }



}

           

映射、排序

package cn.wcj.jdk8.lambda.test;

import java.util.ArrayList;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

import org.junit.Test;

import cn.wcj.jdk8.lambda.test.Emp.Status;
/**
 * 
* <p>Title:StreamTest02 </p>
* <p>Description: StreamAPI</p>
* <p>Company:Software College </p> 
* @author SuccessKey(WangCJ)
* @date 年月日 下午::
 */
public class StreamTest02 {

    List<Emp> emps=new ArrayList<Emp>(
            Arrays.asList(
               new Emp("3333", "張三", , ,Status.BUSY),          
               new Emp("4444", "李四", , ,Status.FREE),          
               new Emp("5555", "王五", , ,Status.VOCATION),          
               new Emp("6666", "趙六", , ,Status.BUSY),          
               new Emp("7777", "田七", , ,Status.FREE),  
               new Emp("7777", "田八", , ,Status.FREE),  
               new Emp("7777", "田九", , ,Status.BUSY)
            )
        );

    // 中間操作
    /*
        映射
        map——接收 Lambda ， 将元素轉換成其他形式或提取資訊。接收一個函數作為參數，該函數會被應用到每個元素上，并将其映射成一個新的元素。
        flatMap——接收一個函數作為參數，将流中的每個值都換成另一個流，然後把所有流連接配接成一個流
     */

    public static Stream<Character>  filterCharacter(String str){
           char[] charArray = str.toCharArray();
           List<Character> list=new ArrayList<>()   ;
           for (Character chr : charArray) {
               list.add(chr)   ;
           }
           return list.stream()   ;
    }

    @Test
    public void test1() {
           emps.stream()
               .map(Emp::getEname)
               .forEach(System.out::println) ;
            System.out.println("-----------------------") ;      
            List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
            strList.stream()
                   .map(String::toUpperCase)
                   .forEach(System.out::println) ;
            System.out.println("-----------------------") ;      
            Stream<Stream<Character>>  stream=strList.stream()
                                     .map(StreamTest02::filterCharacter);
            stream.forEach((sm)->{
                sm.forEach(System.out::println);
            });
            System.out.println("-----------------------") ; 
            strList.stream()
                   .flatMap(StreamTest02::filterCharacter)
                   .forEach(System.out::println);

    }

    @Test
    public void test2(){
         List<String> strList = new ArrayList<>();
         strList.add("aaa")  ;
         strList.add("bbb")  ;
         strList.add("ccc")  ;
         strList.add("ddd")  ;
         strList.add("eee")  ;
         List strList2 = new ArrayList<>();
         strList2.add("fff")  ;
         strList2.addAll(strList)  ;
        // strList2.add(strList)   ;
         System.out.println(strList2);
    }

    /*
    sorted()——自然排序
    sorted(Comparator com)——定制排序
   */
   @Test
   public void test4(){
       emps.stream()
           .map(Emp::getEname)
           .sorted()
           .forEach(System.out::println) ;
       System.out.println("--------------------") ;
       emps.stream()
           .sorted((e1,e2)->{
               if(e1.getAge()==e2.getAge())
                   return e1.getEname().compareTo(e2.getEname());
               else
                   return Integer.compare(e1.getAge(), e2.getAge())   ;
           })
           .forEach(System.out::println)  ;
   }

    /*
    allMatch——檢查是否比對所有元素
    anyMatch——檢查是否至少比對一個元素
    noneMatch——檢查是否沒有比對的元素
    findFirst——傳回第一個元素
    findAny——傳回目前流中的任意元素
    count——傳回流中元素的總個數
    max——傳回流中最大值
    min——傳回流中最小值
  */
   @Test
   public void test5(){
       boolean allMatch = emps.stream()
                       .allMatch((e)->e.getStatus().equals(Status.FREE));
       System.out.println(allMatch);
       boolean anyMatch = emps.stream()
            .anyMatch((e)->e.getStatus().equals(Status.FREE)) ;
       System.out.println(anyMatch)  ;
       boolean noneMatch = emps.stream()
                               .noneMatch((e)->e.getStatus().equals(Status.FREE)) ;    
       System.out.println(noneMatch)  ;
   }

   @Test
   public void test6(){
       Optional<Emp> first = emps.stream()
           .sorted((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()))
           .findFirst();
       System.out.println(first.get()) ;
       System.out.println("---------------------");
       Optional<Emp> findAny = emps.parallelStream()
           .filter((e)->e.getStatus().equals(Status.FREE))
           .findAny();
       System.out.println(findAny.get());
   }

   @Test
   public void test7(){
         long count = emps.stream()
              .filter((e)->e.getStatus().equals(Status.FREE))
              .count();
         System.out.println(count);
         Optional<Double> max = emps.stream()
             .map(Emp::getSalary)
             .max(Double::compare)     ;
         System.out.println(max.get()) ;
         Optional<Emp> min = emps.stream()
             .min((e1,e2)->Double.compare(e1.getSalary(), e2.getSalary()));
         System.out.println(min.get());


   }   


}

           

規約收集

package cn.wcj.jdk8.lambda.test;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.DoubleSummaryStatistics;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.junit.Test;

import cn.wcj.jdk8.lambda.test.Emp.Status;
/**
 * 
* <p>Title:StreamTest </p>
* <p>Description: Stream歸約與收集</p>
* <p>Company:Software College </p> 
* @author SuccessKey(WangCJ)
* @date 年月日 下午::
 */
public class StreamTest {

    List<Emp> emps=new ArrayList<Emp>(
            Arrays.asList(
               new Emp("3333", "張三", , ,Status.BUSY),          
               new Emp("4444", "李四", , ,Status.FREE),          
               new Emp("5555", "王五", , ,Status.VOCATION),          
               new Emp("6666", "趙六", , ,Status.BUSY),          
               new Emp("7777", "田七", , ,Status.FREE),  
               new Emp("7777", "田七", , ,Status.FREE),  
               new Emp("7777", "田七", , ,Status.BUSY)
            )
        );

    @Test
    public void test1() {
        List<Integer> list=Arrays.asList(,,,,,,,,,)  ;
        Integer sum = list.stream()
                          .reduce(,(x,y)->x+y)   ;
        System.out.println(sum);
        System.out.println("-------------------") ;
        Optional<Double> sum2 = emps.stream()
                                    .map(Emp::getSalary)
                                    .reduce(Double::sum)  ;
        System.out.println(sum2.get())  ;
    }


    //統計“六”出現次數
    @Test
    public void test2(){
        Optional<Integer> reduce = emps.stream()
            .map(Emp::getEname)
            .flatMap(StreamTest02::filterCharacter)
            .map((chr)->{
                if(chr.equals('六'))
                      return    ;
                else
                      return    ;
            })
            .reduce(Integer::sum) ;
        System.out.println(reduce.get())  ;
    }

    //collect——将流轉換為其他形式。接收一個 Collector接口的實作，用于給Stream中元素做彙總的方法
    @Test
    public void test3(){
          List<String> list = emps.stream()
                                  .map(Emp::getEname)
                                  .collect(Collectors.toList())  ;
          list.stream()
              .forEach(System.out::println);
          System.out.println("----------------------------------") ;
          Set<String> set = emps.stream()
              .map(Emp::getEname)
              .collect(Collectors.toSet())   ;
          set.stream()
             .forEach(System.out::println)    ;
          System.out.println("----------------------------------") ;
          HashSet<String> hashSet = emps.stream()
              .map(Emp::getEname)
              .collect(Collectors.toCollection(HashSet::new))   ;
          hashSet.stream()
                 .forEach(System.out::println);
    }

    @Test
    public void test4(){
          Optional<Double> collect = emps.stream()
                      .map(Emp::getSalary)
                      .collect(Collectors.maxBy(Double::compare))  ;
          System.out.println(collect.get())  ;
          System.out.println("---------------------------")  ;
          Optional<Emp> collect2 = emps.stream()
              .collect(Collectors.minBy((e1,e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
          System.out.println(collect2.get());
          System.out.println("---------------------------")  ;
          Double sum = emps.stream()
              .collect(Collectors.summingDouble(Emp::getSalary))  ;
          System.out.println(sum)     ;
          System.out.println("---------------------------")   ;
          Double avg = emps.stream()
              .collect(Collectors.averagingDouble(Emp::getSalary))  ;
          System.out.println(avg)     ;
          System.out.println("---------------------------")  ;
          Long count = emps.stream()
              .collect(Collectors.counting())   ;
          System.out.println(count)  ;
          DoubleSummaryStatistics summaryStatistics = emps.stream()
              .collect(Collectors.summarizingDouble(Emp::getSalary))  ;
          System.out.println(summaryStatistics.getMax())  ;
    }


    //分組
    @Test
    public void test5(){
        Map<Status, List<Emp>> collect = emps.stream()
            .collect(Collectors.groupingBy(Emp::getStatus));
        System.out.println(collect)  ;
    }

    @Test
    public void test6(){
        Map<Status, Map<String, List<Emp>>> map = emps.stream()
            .collect(Collectors.groupingBy(Emp::getStatus, Collectors.groupingBy((e)->{
                 if(e.getAge()>)
                     return "老年"  ;
                 else if(e.getAge()>)
                     return "中年"   ;
                 else
                     return "成年"  ;
            })))   ;
        System.out.println(map);

    }

    //分區
    @Test
    public void test7(){
        Map<Boolean, List<Emp>> collect = emps.stream()
            .collect(Collectors.partitioningBy((e)->e.getSalary() >= ));
        System.out.println(collect);
    }

    @Test
    public void test8(){
        String string = emps.stream()
            .map(Emp::getEname)
            .collect(Collectors.joining(","));
        System.out.println(string);
        String string2 = emps.stream()
             .map(Emp::getEmpno)
             .collect(Collectors.joining(",", "工号:(", ")"))  ;
        System.out.println(string2);
    }

    @Test
    public void test9(){
        Optional<Double> collect = emps.stream()
            .map(Emp::getSalary)
            .collect(Collectors.reducing(Double::sum))   ;
        System.out.println(collect.get())  ;
    }










}

           

StreamAPI練習

package cn.wcj.jdk8.lambda.exam  ;

import static org.junit.Assert.*;

import org.junit.Test;

public class Trader {

    private String name;
    private String city;

    public Trader() {
    }

    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 cn.wcj.jdk8.lambda.exam;
public class Transaction {

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

    public Transaction() {
    }

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

    public Trader getTrader() {
        return trader;
    }

    public void setTrader(Trader trader) {
        this.trader = trader;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Transaction [trader=" + trader + ", year=" + year + ", value="
                + value + "]";
    }

}
           

package cn.wcj.jdk8.lambda.exam;



import java.util.ArrayList;
import java.util.Arrays;
import java.util.DoubleSummaryStatistics;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.junit.Before;
import org.junit.Test;

public class StreamTest {

    List<Transaction> transactions = null;

    @Before
    public void before(){
        //交易員
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");

        //交易
        transactions = Arrays.asList(
                new Transaction(brian, , ),
                new Transaction(raoul, , ),
                new Transaction(raoul, , ),
                new Transaction(mario, , ),
                new Transaction(mario, , ),
                new Transaction(alan, , )
        );
    }


    // 找出年發生的所有交易， 并按交易額排序（從低到高）
    @Test
    public void test1() {
        transactions.stream()
                     .filter((t)->t.getYear()==)
                     .sorted((x,y)->Integer.compare(x.getValue(), y.getValue()))
                     .forEach(System.out::println);
    }


    //2. 交易員都在哪些不同的城市工作過？
    @Test
    public void test2(){
        transactions.stream()
                    .map(t->t.getTrader().getCity())
                    .distinct()
                    .forEach(System.out::println) ;
    }

    //3. 查找所有來自劍橋的交易員，并按姓名排序
    @Test
    public void test3(){
        transactions.stream()
                    .filter(t->"Cambridge".equals(t.getTrader().getCity()))
                    .sorted((t1,t2)->t1.getTrader().getName().compareTo(t2.getTrader().getName()))
                    .forEach(System.out::println);;
    }

    //4. 傳回所有交易員的姓名字元串，按字母順序排序
    @Test
    public void test4(){
         transactions.stream()
                     .map((t)->t.getTrader().getName())
                     .distinct()
                     .sorted()
                     .forEach(System.out::println)   ;
         System.out.println("--------------------")  ;
         String names = transactions.stream()
                     .map((t)->t.getTrader().getName())
                     .distinct()
                     .sorted()
                     .collect(Collectors.joining(",")) ;
         System.out.println(names)  ;
         System.out.println("--------------------")  ;
         String reduce = transactions.stream()
                     .map((t)->t.getTrader().getName())
                     .sorted()
                     .reduce("",String::concat)   ;
         System.out.println(reduce);
         System.out.println("--------------------")  ;
         transactions.stream()
                     .map((t)->t.getTrader().getName())
                     .distinct()
                     .flatMap(StreamTest::filterCharacter)
                     .sorted(String::compareToIgnoreCase)
                     .forEach(System.out::print)  ;
    }

    public static Stream<String> filterCharacter(String str){
           List<String> list=new ArrayList<>()  ;
           for (Character chr : str.toCharArray())
                              list.add(chr.toString())  ;
           return list.stream()   ;
    }

    //5. 有沒有交易員是在米蘭工作的？
    @Test
    public void test5(){
         boolean match = transactions.stream()
                     .anyMatch((t)->"Milan".equals(t.getTrader().getCity()));
         System.out.println(match?"有":"沒有");
    }

    //6. 列印生活在劍橋的交易員的所有交易額
    @Test
    public void test6(){
        transactions.stream()
                    .filter((t)->"Cambridge".equals(t.getTrader().getCity()))
                    .map(Transaction::getValue)
                    .forEach(System.out::println) ;
    }

    //7. 所有交易中，最高的交易額是多少
    @Test
    public void test7(){
        DoubleSummaryStatistics collect = transactions.stream()
                    .collect(Collectors.summarizingDouble(Transaction::getValue));
        System.out.println(collect.getMax());
    }

    //8. 找到交易額最小的交易
    @Test
    public void test8(){
        Optional<Integer> min = transactions.stream()
                    .map(Transaction::getValue)
                    .min((v1,v2) -> Integer.compare(v1, v2)) ;
        System.out.println(min.get());
    }



}