Stream API
A squence ofelement supporting sequential and parallel affregate oprations Stream 是一組用來操作數組、集合的API
Stream 的特點
- 不是數據結構，沒有內部存儲
- 不支持索引訪問
- 延遲計算
- 支持并行
- 很容易生成數組或者集合（List,Set）
- 支持過濾，查找，轉換，匯總等操作
Stream 運行機制
Stream分為 源source,中間操作，終止操作
流的源可以是一個數組、一個集合、一個生成器方法、一個I/O通道等等
一個流可以有零個或者多個中間操作，每一個中間操作都會返回一個新的流，供下一個操作使用。一個 流只可以使用一次，一個流只會有一個終止操作
Stream只有遇到終止操作，它的源才開始執行遍歷操作
Stream常用API
流的創建
- 通過數組
- 通過集合
- 通過Stream.generate方法來創建
- 通過Stream.iterate方法來創建
- 其他API(比如文件，字符串)
中間操作
- 過濾 filter
- 去重 distinct
- 排序 sorted
- 截取 limit、skip
- 轉換 map/flatMap
- 其他 peek
終止操作
- 循環 forEach
- 計算 min、max、count
- 匹配 anyMatch、allMatch、noneMatch、findFirst、findAny
- 匯聚 reduce
- 收集器 toArray collect
流的創建
package lambda2;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
/**
* 流的創建
*
*/
public class CreateStream {
/**
* 通過數組
*/
static void gen1() {
Integer[] arr= {1,2,3,4};
Stream<Integer> stream=Stream.of(arr);
stream.forEach(System.out::println);
}
/**
* 通過集合
*/
static void gen2() {
String[] arr= {"a","b","1","2","3"};
List<String> list=Arrays.asList(arr) ;
Stream<String> stream=list.stream();
stream.forEach(System.out::println);
}
/**
* 通過Stream.generate方法來創建
*/
static void gen3() {
Stream<String> stream=Stream.generate(()-> "a");//無止境的流，因為流沒有終止
//stream.limit(10);截取流,取前10個
stream.limit(10).forEach(System.out::println);
}
/**
* 通過Stream.iterate方法來創建
*/
static void gen4() {
Stream<Integer> stream=Stream.iterate(1, x->x+1);//無止境的流，因為流沒有終止
//stream.limit(10);截取流,取前10個
stream.limit(10).forEach(System.out::println);
}
/**
* 通過其他方式(字符串)
*/
static void gen5() {
String str="jarWorker";
IntStream stream=str.chars();//轉換成intStream流
//void forEach(IntConsumer action);相當于conSumer：輸入
stream.forEach(x->System.out.println(x));
//stream.forEach(System.out::println);//方法的引用
}
/**
* 通過其他方式(讀取文件)
* @throws IOException
*/
static void gen6() throws IOException {
String path="f:/InstanceMethod.java";
File file=new File(path);
if(file.exists()) {
file.delete();
}
if(!file.exists()) {
boolean flag=file.createNewFile();
if(flag) {
FileOutputStream out=new FileOutputStream(file,true);
String content="package lambda1;\r\n" +
"import java.util.function.Supplier;\r\n" +
"/**\r\n" +
" * 實例方法引用\r\n" +
" * 如果函數式接口恰巧可以通過調用一個實例的實例方法來實現，就可以使用調動實例方法來引用\r\n" +
" */\r\n" +
"public class InstanceMethod {\r\n" +
" /**\r\n" +
" * 實例方法\r\n" +
" * \r\n" +
" * @return\r\n" +
" */\r\n" +
" private String insert() {\r\n" +
" return \"hello lambda\";\r\n" +
" }\r\n" +
" \r\n" +
"public static void main(String[] args) {\r\n" +
" Supplier<String> s = () -> {\r\n" +
" return new InstanceMethod().insert();\r\n" +
" };\r\n" +
" System.out.println(\"lambda表達式:\" + s.get());\r\n" +
" // 方法的引用\r\n" +
" Supplier<String> s1 = new InstanceMethod()::insert;\r\n" +
" System.out.println(\"方法的引用:\" + s1.get());\r\n" +
" \r\n" +
"}\r\n" +
"}";
//這里設置為了utf-8
out.write(content.getBytes("utf-8"));
}
}
//這里可能會涉及編碼的問題，盡量讓文件的編碼格式為utf-8
Stream<String> stream= Files.lines(Paths.get(path));
stream.forEach(System.out::println);
}
public static void main(String[] args) throws IOException{
gen1();
gen2();
gen3();
gen4();
gen5();
gen6();
}
}
中間操作
package lambda2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Stream;
/**
*
* 中間操作
*
*/
public class Middle {
/**
* 過濾:filter
*/
static void filterMiddle() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
Stream<Integer> stream = list.stream();
stream.filter((x) -> {
System.out.println("進入此方法");
return x % 2 == 1;
}).forEach(System.out::println);// 代碼沒有執行forEach前并不會打印出任何東西，包括“進入此方法”，因為并沒有終止流
//stream.forEach(System.out::println);因為一個 Stream 只可以使用一次
}
/**
* 去重:distinct
*/
static void distinctMiddle() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 5);
list.stream().distinct().forEach(System.out::println);
}
/**
* 排序:sort
*/
static void sortedMiddle() {
List<Integer> list = Arrays.asList(1, 2, 6, 4, 5, 5,3);
//以下做了去重和排序兩個中間操作，說明說一個Stream的中間操作可以是多個
list.stream().distinct().sorted().forEach(System.out::println);//正序
list.stream().distinct().sorted(Comparator.reverseOrder()).forEach(System.out::println);//倒序
}
/**
* 截取: limit、skip
*/
static void InterceptionMiddle() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
//跳過1,2
list.stream().skip(2).forEach(System.out::println);
//截取 1, 2
list.stream().limit(2).forEach(System.out::println);
list.stream().limit(2).skip(2).forEach(System.out::println);
}
/**
* 轉換: map/flatMap
*/
static void conversionMiddle() {
List<String> list = Arrays.asList("1","2","3");
list.stream().map(x->x).forEach(System.out::println);//還是字符串
//轉換成int類型
list.stream().mapToInt(x->Integer.valueOf(x)).forEach(System.out::println);//已經是int類型
Supplier<List<List<String>>> s=ArrayList::new;
List<List<String>> list1=s.get();
List<String> l1 = Arrays.asList("1","3");
List<String> l2 = Arrays.asList("2","4");
list1.add(l1);
list1.add(l2);
//flatMap 大致上的意思就是有很多層的嵌套
list1.stream().flatMap((x)->x.stream()).forEach(System.out::println);//還是字符串
list1.stream().flatMapToInt((x)->x.stream().mapToInt(v->Integer.valueOf(v))).forEach(System.out::println);//已經是int類型
}
/**
* 其他: peek
*/
static void otherMiddle() {
//peek和map的區別
//peek接收一個沒有返回值的λ表達式，可以做一些輸出，外部處理等。map接收一個有返回值的λ表達式，之后Stream的泛型類型將轉換為map參數λ表達式返回的類型
Supplier<List<List<String>>> s=ArrayList::new;
List<List<String>> list1=s.get();
List<String> l1 = Arrays.asList("1","3");
List<String> l2 = Arrays.asList("2","4");
list1.add(l1);
list1.add(l2);
//下面的兩個結果是一樣的，只遍歷了list1后沒有繼續往下遍歷
//peek方法接收一個Consumer的入參,沒有返回值,而map方法的入參為 Function，有返回值
list1.stream().peek((x)->x.stream()).forEach(System.out::println);
list1.stream().peek((x)->x.stream().mapToInt(Integer::valueOf)).forEach(System.out::println);
}
public static void main(String[] args) {
filterMiddle();
distinctMiddle();
sortedMiddle();
InterceptionMiddle() ;
conversionMiddle();
otherMiddle() ;
}
}
終止操作
package lambda2;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
*
* 終止操作
*
*/
public class Termination {
static List<Integer> number=Arrays.asList(1,2,3,4,5,6,7);
/**
* 循環
* foreach
*/
static void termination1() {
Stream<Integer> stream = number.stream();
stream.forEach(System.out::println);
}
/**
* 計算
* min
*/
static void termination2() {
Stream<Integer> stream = number.stream();
int min=stream.min((a,b)->a-b).get();
System.out.println(min);
}
/**
* 計算
* max
*/
static void termination3() {
Stream<Integer> stream = number.stream();
int max=stream.max((a,b)->a-b).get();
System.out.println(max);
}
/**
* 計算
* count
*/
static void termination4() {
Stream<Integer> stream = number.stream();
long count= stream.count();
System.out.println(count);
}
/**
* 匹配
* anyMatch
*/
static void termination5() {
Stream<Integer> stream = number.stream();
boolean flag =stream.anyMatch(x->x.equals(10));
System.out.println(flag);
}
/**
* 匹配
* allMatch
*/
static void termination6() {
Stream<Integer> stream = number.stream();
boolean flag =stream.allMatch(x->x==1||x==2||x==3||x==4||x==5||x==6||x==7);
System.out.println(flag);
}
/**
* 匹配
* noneMatch
*/
static void termination7() {
Stream<Integer> stream = number.stream();
boolean flag =stream.noneMatch(x->x==10);
System.out.println(flag);
}
/**
* 匹配
* findFirst
*/
static void termination8() {
Stream<Integer> stream = number.stream();
int first =stream.sorted(Comparator.reverseOrder()).parallel().findFirst().orElse(5);
System.out.println(first);
}
/**
* 匹配
* findAny
*
* findAny并不是隨機地選一個，如果是數據較少，串行地情況下，一般會返回第一個結果，如果是并行的情況，那就不能確保是第一個
*/
static void termination9() {
Stream<Integer> stream = number.stream();
Optional<Integer> op =stream.sorted(Comparator.reverseOrder()).parallel().findAny();
Integer any=op.get();
System.out.println(any);
}
/**
* 收集器
* toArray collect
*
*/
static void termination10() {
List<Integer> list1=Stream.iterate(1, x->x+1).limit(50).collect(Collectors.toList());
Object[] array=Stream.iterate(1, x->x+1).limit(50).toArray();
}
/**
* 匯聚
* reduce
*
*/
static void termination11() {
Stream<Integer> stream = number.stream();
int result=stream.reduce((a,b)->a+b).get();
System.out.println(result);
}
public static void main(String[] args) {
termination1();
termination2();
termination3();
termination4();
termination5();
termination6();
termination7();
termination8();
termination9();
termination10();
termination11();
}
}
并行流和串行流的轉換
package lambda2;
import java.util.stream.Stream;
/**
* 并行流和串行流的轉換
*
* 串行變并行 parallel()
* 并行變串行 sequential()
*/
public class ParallelStream {
public static void main(String[] args) {
String str="12,32,21";
//串行變并行 parallel()
int max1=Stream.of(str.split(",")).parallel().peek(x->{
System.out.println(Thread.currentThread().getName());
}).mapToInt(Integer::valueOf).max().getAsInt();
//并行變串行 sequential()
int max2=Stream.of(str.split(",")).parallel().mapToInt(Integer::valueOf).peek(x->{
System.out.println(Thread.currentThread().getName());
}).sequential().max().getAsInt();
System.out.println(max1);
System.out.println(max2);
}
}
