1_兩種獲取Stream流的方式
Demo01GetStream.java
package com.itheima.demo02.Stream;
import java.util.*;
import java.util.stream.Stream;
/*
java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（這並不是一個函數式接口。）
獲取一個流非常簡單，有以下幾種常用的方式：
- 所有的Collection集合都可以通過stream默認方法獲取流；
default Stream<E> stream()
- Stream接口的靜態方法of可以獲取數組對應的流。
static <T> Stream<T> of(T... values)
參數是一個可變參數,那么我們就可以傳遞一個數組
*/
public class Demo01GetStream {
public static void main(String[] args) {
//把集合轉換為Stream流
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
Map<String,String> map = new HashMap<>();
//獲取鍵,存儲到一個Set集合中
Set<String> keySet = map.keySet();
Stream<String> stream3 = keySet.stream();
//獲取值,存儲到一個Collection集合中
Collection<String> values = map.values();
Stream<String> stream4 = values.stream();
//獲取鍵值對(鍵與值的映射關系 entrySet)
Set<Map.Entry<String, String>> entries = map.entrySet();
Stream<Map.Entry<String, String>> stream5 = entries.stream();
//把數組轉換為Stream流
Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
//可變參數可以傳遞數組
Integer[] arr = {1,2,3,4,5};
Stream<Integer> stream7 = Stream.of(arr);
String[] arr2 = {"a","bb","ccc"};
Stream<String> stream8 = Stream.of(arr2);
}
}
========================================================================================
2_Stream流中的常用方法_forEach
Demo02Stream_forEach.java
package com.itheima.demo02.Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_forEach
void forEach(Consumer<? super T> action);
該方法接收一個Consumer接口函數，會將每一個流元素交給該函數進行處理。
Consumer接口是一個消費型的函數式接口,可以傳遞Lambda表達式,消費數據
簡單記:
forEach方法,用來遍歷流中的數據
是一個終結方法,遍歷之后就不能繼續調用Stream流中的其他方法
*/
public class Demo02Stream_forEach {
public static void main(String[] args) {
//獲取一個Stream流
Stream<String> stream = Stream.of("張三", "李四", "王五", "趙六", "田七");
//使用Stream流中的方法forEach對Stream流中的數據進行遍歷
/*stream.forEach((String name)->{
System.out.println(name);
});*/
stream.forEach(name->System.out.println(name));
}
}
==================================================================================================
3_Stream流中的常用方法_filter
Demo03Stream_filter.java
package com.itheima.demo02.Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_filter:用於對Stream流中的數據進行過濾
Stream<T> filter(Predicate<? super T> predicate);
filter方法的參數Predicate是一個函數式接口,所以可以傳遞Lambda表達式,對數據進行過濾
Predicate中的抽象方法:
boolean test(T t);
*/
public class Demo03Stream_filter {
public static void main(String[] args) {
//創建一個Stream流
Stream<String> stream = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
//對Stream流中的元素進行過濾,只要姓張的人
Stream<String> stream2 = stream.filter((String name)->{return name.startsWith("張");});
//遍歷stream2流
stream2.forEach(name-> System.out.println(name));
/*
Stream流屬於管道流,只能被消費(使用)一次
第一個Stream流調用完畢方法,數據就會流轉到下一個Stream上
而這時第一個Stream流已經使用完畢,就會關閉了
所以第一個Stream流就不能再調用方法了
IllegalStateException: stream has already been operated upon or closed
*/
//遍歷stream流
stream.forEach(name-> System.out.println(name));
}
}
==================================================================================================
4_Stream流的特點_只能使用一次
==============================================================================================
5_Stream流中的常用方法_map
Demo04Stream_map.java
package com.itheima.demo02.Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_map:用於類型轉換
如果需要將流中的元素映射到另一個流中，可以使用map方法.
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
該接口需要一個Function函數式接口參數，可以將當前流中的T類型數據轉換為另一種R類型的流。
Function中的抽象方法:
R apply(T t);
*/
public class Demo04Stream_map {
public static void main(String[] args) {
//獲取一個String類型的Stream流
Stream<String> stream = Stream.of("1", "2", "3", "4");
//使用map方法,把字符串類型的整數,轉換(映射)為Integer類型的整數
Stream<Integer> stream2 = stream.map((String s)->{
return Integer.parseInt(s);
});
//遍歷Stream2流
stream2.forEach(i-> System.out.println(i));
}
}
=======================================================================================
6_Stream流中的常用方法_count
Demo05Stream_count.java
package com.itheima.demo02.Stream;
import java.util.ArrayList;
import java.util.stream.Stream;
/*
Stream流中的常用方法_count:用於統計Stream流中元素的個數
long count();
count方法是一個終結方法,返回值是一個long類型的整數
所以不能再繼續調用Stream流中的其他方法了
*/
public class Demo05Stream_count {
public static void main(String[] args) {
//獲取一個Stream流
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
Stream<Integer> stream = list.stream();
long count = stream.count();
System.out.println(count);//7
}
}
==================================================================================
7_Stream流中的常用方法_limit
Demo06Stream_limit.java
package com.itheima.demo02.Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_limit:用於截取流中的元素
limit方法可以對流進行截取，只取用前n個。方法簽名：
Stream<T> limit(long maxSize);
參數是一個long型，如果集合當前長度大於參數則進行截取；否則不進行操作
limit方法是一個延遲方法,只是對流中的元素進行截取,返回的是一個新的流,所以可以繼續調用Stream流中的其他方法
*/
public class Demo06Stream_limit {
public static void main(String[] args) {
//獲取一個Stream流
String[] arr = {"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
Stream<String> stream = Stream.of(arr);
//使用limit對Stream流中的元素進行截取,只要前3個元素
Stream<String> stream2 = stream.limit(3);
//遍歷stream2流
stream2.forEach(name-> System.out.println(name));
}
}
============================================================================================
8_Stream流中的常用方法_skip
Demo07Stream_skip.java
package com.itheima.demo02.Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_skip:用於跳過元素
如果希望跳過前幾個元素，可以使用skip方法獲取一個截取之后的新流：
Stream<T> skip(long n);
如果流的當前長度大於n，則跳過前n個；否則將會得到一個長度為0的空流。
*/
public class Demo07Stream_skip {
public static void main(String[] args) {
//獲取一個Stream流
String[] arr = {"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
Stream<String> stream = Stream.of(arr);
//使用skip方法跳過前3個元素
Stream<String> stream2 = stream.skip(3);
//遍歷stream2流
stream2.forEach(name-> System.out.println(name));
}
}
==========================================================================================
9_Stream流中的常用方法_concat
Demo08Stream_concat.java
package com.itheima.demo02.Stream;
import java.util.stream.Stream;
/*
Stream流中的常用方法_concat:用於把流組合到一起
如果有兩個流，希望合並成為一個流，那么可以使用Stream接口的靜態方法concat
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
*/
public class Demo08Stream_concat {
public static void main(String[] args) {
//創建一個Stream流
Stream<String> stream1 = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
//獲取一個Stream流
String[] arr = {"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
Stream<String> stream2 = Stream.of(arr);
//把以上兩個流組合為一個流
Stream<String> concat = Stream.concat(stream1, stream2);
//遍歷concat流
concat.forEach(name-> System.out.println(name));
}
}
==========================================================================================================
10_練習：集合元素處理（傳統方式）
Person.java
package com.itheima.demo03.Stream;
public class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
------------------------------------------------------------------------------------------------------------------------
Demo01StreamTest.java
package com.itheima.demo03.Stream;
import java.util.ArrayList;
/*
練習:集合元素處理（傳統方式）
現在有兩個ArrayList集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以下若干操作步驟：
1. 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
2. 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
3. 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
4. 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
5. 將兩個隊伍合並為一個隊伍；存儲到一個新集合中。
6. 根據姓名創建Person對象；存儲到一個新集合中。
7. 打印整個隊伍的Person對象信息。
*/
public class Demo01StreamTest {
public static void main(String[] args) {
//第一支隊伍
ArrayList<String> one = new ArrayList<>();
one.add("迪麗熱巴");
one.add("宋遠橋");
one.add("蘇星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
//1. 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
ArrayList<String> one1 = new ArrayList<>();
for (String name : one) {
if(name.length()==3){
one1.add(name);
}
}
//2. 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
ArrayList<String> one2 = new ArrayList<>();
for (int i = 0; i <3 ; i++) {
one2.add(one1.get(i));//i = 0,1,2
}
//第二支隊伍
ArrayList<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("張無忌");
two.add("趙麗穎");
two.add("張三豐");
two.add("尼古拉斯趙四");
two.add("張天愛");
two.add("張二狗");
//3. 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
ArrayList<String> two1 = new ArrayList<>();
for (String name : two) {
if(name.startsWith("張")){
two1.add(name);
}
}
//4. 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
ArrayList<String> two2 = new ArrayList<>();
for (int i = 2; i <two1.size() ; i++) {
two2.add(two1.get(i)); //i 不包含0 1
}
//5. 將兩個隊伍合並為一個隊伍；存儲到一個新集合中。
ArrayList<String> all = new ArrayList<>();
all.addAll(one2);
all.addAll(two2);
//6. 根據姓名創建Person對象；存儲到一個新集合中。
ArrayList<Person> list = new ArrayList<>();
for (String name : all) {
list.add(new Person(name));
}
//7. 打印整個隊伍的Person對象信息。
for (Person person : list) {
System.out.println(person);
}
}
}
=================================================================
11_練習：集合元素處理（Stream方
Demo02StreamTest.java
package com.itheima.demo03.Stream;
import java.util.ArrayList;
import java.util.stream.Stream;
/*
練習：集合元素處理（Stream方式）
將上一題當中的傳統for循環寫法更換為Stream流式處理方式。
兩個集合的初始內容不變，Person類的定義也不變。
*/
public class Demo02StreamTest {
public static void main(String[] args) {
//第一支隊伍
ArrayList<String> one = new ArrayList<>();
one.add("迪麗熱巴");
one.add("宋遠橋");
one.add("蘇星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
//1. 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
//2. 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
Stream<String> oneStream = one.stream().filter(name -> name.length() == 3).limit(3);
//第二支隊伍
ArrayList<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("張無忌");
two.add("趙麗穎");
two.add("張三豐");
two.add("尼古拉斯趙四");
two.add("張天愛");
two.add("張二狗");
//3. 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
//4. 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
Stream<String> twoStream = two.stream().filter(name -> name.startsWith("張")).skip(2);
//5. 將兩個隊伍合並為一個隊伍；存儲到一個新集合中。
//6. 根據姓名創建Person對象；存儲到一個新集合中。
//7. 打印整個隊伍的Person對象信息。
Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach(p-> System.out.println(p));
}
}