Java基础教程——Stream

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