天天看點

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