Stream流
Java 8 API添加了一种新的机制——Stream（流）。Stream和IO流不是一回事。
流式思想：像生产流水线一样，一个操作接一个操作。
使用Stream流的步骤：数据源→转换成流→操作1→操作2→……
数据源（source）：可以是集合、数组等。
Stream操作有两个基础特征：
(1)Pipelining（流水线）：流操作会返回流对象（新的对象），以便后续继续进行流操作。
(2)内部迭代：不需要像for循环或Iterator一样进行显式的迭代。
import java.util.*;
public class TestStream {
public static void main(String[] args) {
List<String> lst = new ArrayList<>();
lst.add("孙悟空");
lst.add("猪八戒");
lst.add("沙僧");
lst.add("唐僧");
// 需求：(1)筛选名字是3个字的人,(2)输出结果
System.out.println("-----流式写法");
// .stream():把集合转换成流
// .filter的参数是Predicate接口，抽象方法test()方法用于判断
// .forEach的参数是Consumer接口，抽象方法accept()用于接受数据
lst.stream().filter(name -> name.length() == 3)
.forEach(name -> System.out.println(name));
System.out.println("------ 方法引用(关注做什么，不管怎么做)");
printStr(s -> System.out.println(s), "Lambda");
printStr(System.out::println, "方法引用");
}
static void printStr(Printable p, String s) {
p.print(s);
}
}
interface Printable {
void print(String s);
}
-----流式写法
孙悟空
猪八戒
------ 方法引用(关注做什么，不管怎么做)
Lambda
方法引用
获取流
import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Stream;
public class GetStream {
public static void main(String[] args) {
// List和Set
Collection<String> c = new ArrayList<>();
Stream stream = c.stream();
// Map(分k,v,k&v三种)
Map<String, String> map = new HashMap<>();
Stream<String> stream2 = map.keySet().stream();
Stream<String> stream3 = map.values().stream();
Stream<Entry<String, String>> stream4 = map.entrySet().stream();
// 数组
Integer[] arr = { 1, 2, 3, 4, 5 };
Stream<Integer> stream5 = Stream.of(arr);
}
}
常用方法
延迟方法：返回值还是Stream接口类型。
终结方法：返回类型不是Stream。如count和forEach。
import java.util.stream.Stream;
public class TestStream {
public static void main(String[] args) {
System.out.println("-- void forEach(Consumer),accept(T)获取参数");
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
stream.forEach(e -> System.out.println(e));
// -------------
System.out.println("-- Stream filter(Predicate),test(T)用于判断");
// 必须重新获取流，因为Stream只能被使用一次，数据流到下一个Stream上。
// 如果不重新获取，会得到异常：stream has already been operated upon or closed
stream = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> stream2 = stream.filter(e -> e % 2 == 0);
stream2.forEach(e -> System.out.println(e));
// -------------
stream = Stream.of(1, 2, 3, 4, 5);
System.out.println("-- Stream map(Function),R apply(T t)，类型转换");
Stream<String> stream3 = stream.map(n -> "第" + n);
stream3.forEach(e -> System.out.println(e));
// -------------
stream = Stream.of(1, 2, 3, 4, 5);
System.out.println("-- Stream limit(long maxSize):取前maxSize个");
Stream<Integer> limit = stream.limit(3);
limit.forEach(e -> System.out.println(e));
// -------------
stream = Stream.of(1, 2, 3, 4, 5);
System.out.println("-- Stream skip(long n):跳过前n个");
Stream<Integer> skip = stream.skip(1);
skip.forEach(e -> System.out.println(e));
// -------------
stream = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> stream4 = Stream.of(11, 12, 13);
System.out.println("-- Stream concat(Stream a, Stream b):二流归一");
Stream<Integer> concat = Stream.concat(stream, stream4);
concat.forEach(e -> System.out.println(e));
// -------------
stream = Stream.of(1, 2, 3, 4, 5);
System.out.println("-- long count():终结方法");
long count = stream.count();
System.out.println(count);
}
}
-- void forEach(Consumer),accept(T)获取参数
1
2
3
4
5
-- Stream filter(Predicate),test(T)用于判断
2
4
-- Stream map(Function),R apply(T t)，类型转换
第1
第2
第3
第4
第5
-- Stream limit(long maxSize):取前maxSize个
1
2
3
-- Stream skip(long n):跳过前n个
2
3
4
5
-- Stream concat(Stream a, Stream b):二流归一
1
2
3
4
5
11
12
13
-- long count():终结方法
5