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