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):對給定的參數進行判斷,傳回一個布爾值
- Predicate接口中的方法:
- 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));
}
}
}