天天看點
傳回

Stream流的使用（java）

1.1 體驗Stream流

需求： 按照下面的要求完成集合的建立和周遊

  • 建立一個集合，存儲多個字元串元素
  • 把集合中所有以“張”開頭的元素存儲到一個新的集合
  • 把“張”開頭的集合中的長度為3的元素存儲到一個新的集合
  • 周遊上一步得到的集合

使用Stream流的方式完成過濾操作

  • list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));

     
import java.util.ArrayList;

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("張三");
        list.add("李四");
        list.add("王五");
        list.add("張五");
        list.add("張三三");

        //把所有“張”開頭的元素存儲到一個新的集合
        ArrayList<String> zhangList = new ArrayList<>();

        for (String s :
                list) {
            if (s.startsWith("張")){
                zhangList.add(s);
            }
        }
        System.out.println(zhangList);

        //把“張”開頭的集合中的長度為3的元素存儲到一個新的集合
        ArrayList<String> threeList = new ArrayList<>();

        for (String s :
                zhangList) {
            if (s.length()==3){
                threeList.add(s);
            }
        }
        System.out.println(threeList);
        
        //周遊集合
        for (String s :
                threeList) {
            System.out.println(s);
        }

        System.out.println("------------Stream流------------");

        //Stream流改進
        list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
    }
}

1.2 Stream流的生成方式

Stream流的使用

  • 生成流
    • 通過資料源（集合，數組等）生成流
    • list.stream()
  • 中間操作
    • 一個流後面可以跟随零個或多個中間操作，其目的主要是打開流，做出某種程度的資料過濾/映射，然後傳回一個新的流，交給下一個操作使用
    • filter()
  • 終結操作
    • 一個流隻能有一個終結操作，當這個操作執行後，流就被使用“光”了，無法再被操作。是以這必定是流的最後一個操作
    • forEach()

Stream流的常見生成方式

  • Collection體系的集合可以使用預設的方法stream()生成流
    • default Stream< E > stream()
  • Map體系的集合間接的生成流
  • 數組可以通過Stream接口的靜态方法of(T… values)生成流 
import java.util.*;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        //Collection體系的集合可以使用預設方法stream()生成流
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //Map體系的集合間接的生成流
        Map<String, Integer> map = new HashMap<>();
        //鍵對應的流
        Stream<String> keyStream = map.keySet().stream();
        //值對應的流
        Stream<Integer> valueStream = map.values().stream();
        //鍵值對對象對應的流
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //數組可以通過Stream接口的靜态方法of(T... values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
    }
}

1.3 Stream流常見的中間操作方法

  • Stream< T > filter(Predicate predicate)：用于對流中的資料進行過濾
    • Predicate接口中的方法：
      • boolean test(T t)：對給定的參數進行判斷，傳回一個布爾值
  • Stream< T > limit(long maxSize)：傳回此流中的元素組成的流，截取前指定參數個數的資料
  • Stream< T > skip(long n)：跳過指定參數個數的資料，傳回由該流的剩餘元素組成的流 
import java.util.*;

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("張三");
        list.add("李四");
        list.add("王五五");
        list.add("張五");
        list.add("張三三");

        //Stream< T > filter(Predicate predicate)：用于對流中的資料進行過濾
        //需求1：把list集合中以張開頭的元素在控制台輸出
        list.stream().filter(s -> s.startsWith("張")).forEach(System.out::println);
        System.out.println("---------------------------");

        //需求2：把list集合中長度為3的元素在控制台輸出
        list.stream().filter(s -> s.length()==3).forEach(System.out::println);
        System.out.println("---------------------------");

        //需求3：把list集合中以張開頭，長度為3的元素在控制台輸出
        list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length()==3).forEach(System.out::println);

        System.out.println("=============================================");

        //Stream< T > limit(long maxSize)：- 截取前指定參數個數的資料
        //Stream< T > skip(long n)：傳回由該流的剩餘元素組成的流
        //需求1：取前三個資料在控制台輸出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("---------------------------");

        //需求2：跳過三個元素，把剩下的元素在控制台輸出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("---------------------------");

        //需求3：跳過兩個元素，把剩下的元素中前兩個在控制台輸出
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}
  • static< T > Stream< T > concat(Stream a, Stream b)：合并a和b兩個流為一個流
  • Stream < T > distinct()：傳回由該流的不同元素（底層根據Object.equals(Object)）組成的流 
import java.util.*;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("張三");
        list.add("李四");
        list.add("王五五");
        list.add("張五");
        list.add("張三三");

        //需求1：取前四個資料組成流
        Stream<String> s1 = list.stream().limit(4);

        //需求2：跳過兩個資料組成一個流
        Stream<String> s2 = list.stream().skip(2);

        //需求3：合并需求1和需求2得到的流，并把結果在控制台輸出
//        Stream.concat(s1, s2).forEach(System.out::println);
        System.out.println("----------------------");

        //需求4：合并需求1和需求2得到的流，并把結果在控制台輸出，要求字元串元素不能重複
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
    }
}
  • Stream< T > sorted()：傳回由此流的元素組成的流，根據自然順序排序
  • Stream< T > sorted(Comparator comparator)：傳回由此流的元素組成的流，根據提供的Comparator進行排序 
import java.util.*;

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("張三");
        list.add("李四");
        list.add("王五五");
        list.add("張五");
        list.add("張三三");

        //需求1：按照字母順序把資料在控制台輸出
        list.stream().sorted().forEach(System.out::println);
        System.out.println("---------------------");

        //需求2：按照字元串長度把資料在控制台輸出
        list.stream().sorted((s1,s2)->{
            int num = s1.length()-s2.length();
            int num2 = num==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);
    }
}
  • < R > Stream< R > map(Function mapper)：傳回由給定函數應用于此流的元素的結果組成的流
    • Function接口中的方法 R apply(T t)
  • IntStream mapToInt(ToIntFunction mapper)：傳回一個IntStream其中包含将給定函數應用于此流的元素的結果
    • IntStream：表示原始int流
    • ToIntFunction接口中的方法 int applyAsInt(T value) 
import java.util.*;

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //需求：将集合中的字元串資料轉換為整數之後在控制台輸出
        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        System.out.println("---------------");
        list.stream().mapToInt(s->Integer.parseInt(s)).forEach(System.out::println);

        //int sum() 傳回此流中元素的總和
        int resut = list.stream().mapToInt(s -> Integer.parseInt(s)).sum();
        System.out.println(resut);
    }
}

1.4 Stream流的常見終結操作方法

Stream流的常見zhongjie操作方法

  • void forEach(Consumer action)：對此流的每個元素執行操作
    • Consumer接口中的方法 void accept(T t)：對給定的參數執行此操作
  • long count()：傳回此流中的元素數 
import java.util.*;

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("張三");
        list.add("李四");
        list.add("王五五");
        list.add("張五");
        list.add("張三三");

        //需求1：把集合中的元素在控制台輸出
        list.stream().forEach(System.out::println);

        //需求2：統計集合中有幾個以張開頭的元素，并把統計結果在控制台輸出
        long i = list.stream().filter(s -> s.startsWith("張")).count();
        System.out.println("以張開頭的元素有："+i+"個");
    }
}

1.5 Stream流的練習

現在有兩個ArrayList集合，分别存儲6名難以按原名稱和6名女演員名稱，要求完成如下操作

  • 男演員隻要名字為3個字的前三任
  • 女演員隻要姓張的，并且不要第一個
  • 把過濾後的男演員姓名和女演員姓名合并到一起
  • 把上一步操作後的元素作為構造方法的參數建立演員對象，周遊資料
    • 演員類Actor已經提供，李明友一個成員變量，一個帶參構造方法，以及成員變量對應的get/set方法 
import java.util.*;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        ArrayList<String> manList = new ArrayList<>();

        manList.add("周潤發");
        manList.add("成龍");
        manList.add("劉德華");
        manList.add("吳京");
        manList.add("周星馳");
        manList.add("李連傑");

        ArrayList<String> womanList = new ArrayList<>();

        womanList.add("林心如");
        womanList.add("張曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖賢");

        //男演員隻要名字三個字的前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);

        //女演員隻要姓林的，并且不要第一個
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        //把過濾後的男演員名和女演員名合并到一起
        Stream<String> stream = Stream.concat(manStream, womanStream);

        //把上一步操作後的元素作為構造方法的參數建立演員對象，周遊數組
//        stream.forEach(s -> {
//            Actor actor = new Actor(s);
//            System.out.println("符合條件的演員有"+actor.getName());
//        });
        stream.map(Actor::new).forEach(s -> System.out.println("符合條件的演員有" + s.getName()));
    }
}

1.6 Stream流的收集操作

對資料使用Stream流的方式操作完畢後，我想把流中的資料收集的集合中，該怎麼辦呢？

Stream流的收集方法

  • R collect(Collector collector)
  • 但是這個收集方法的參數是一個Collector接口

工具類Collectors提供了一個具體的收集方法

  • public static < T > Collector toList()：把元素收集到List集合中
  • public static < T > Collector toSet()：把元素收集到Set集合中
  • public static Collector toMap(Functioc keyMapper, Function valueMapper)：把元素收集到Map集合中 
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        //List集合
        List<String> manList = new ArrayList<>();
        manList.add("周潤發");
        manList.add("成龍");
        manList.add("劉德華");
        manList.add("吳京");
        manList.add("周星馳");
        manList.add("李連傑");

        //需求：得到名字為三個字的流，收集到List集合中并周遊
        manList.stream().filter(s -> s.length() == 3).collect(Collectors.toList()).forEach(System.out::println);

        //Set集合
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        set.add(50);
        set.add(60);

        //需求：得到年齡大于25的流，收集到Set集合中并周遊
        set.stream().filter(s -> s>25).collect(Collectors.toSet()).forEach(System.out::println);

        //字元串數組
        String[] strArray = {"周潤發,10", "成龍,20", "劉德華,30", "吳京,40", "周星馳,50", "李連傑,60"};

        //需求：得到字元串中資料大于20的流，收集到Map集合中并周遊
        Map<String, Integer> map = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 30).collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keySet = map.keySet();
        for (String s :
                keySet) {
            System.out.println(s+","+map.get(s));
        }
    }
}
精選 stream stream流 java lambda
上一篇: umi3+egg中台管理系統示範
下一篇: TP擷取記錄檔需要的值(ip、目前頁面、全部get、post值)

繼續閱讀