JAVA8 Stream接口，map操作，filter操作，flatMap操作

Dear 丶 2021-09-26 21:42 457阅读 0赞

这篇，我们来看Stream的一些中间操作，关于中间操作的一些介绍，可以看[《JAVA8 stream接口 中间操作和终端操作》][JAVA8 stream_]

1，filter操作，我们先看方法的定义

Stream<T> filter(Predicate<? super T> predicate);

这个方法，传入一个Predicate的函数接口，关于Predicate函数接口定义，可以查看[《JAVA8 Predicate接口》][JAVA8 Predicate]，这个接口传入一个泛型参数T，做完操作之后，返回一个boolean值；filter方法的作用，是对这个boolean做判断，返回true判断之后的对象，下面一个案例，可以看到怎么使用

String[] dd = { "a", "b", "c" };
    		Stream<String> stream = Arrays.stream(dd);
    		stream.filter(str -> str.equals("a")).forEach(System.out::println);//返回字符串为a的值

2.map操作，先看方法定义

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

这个方法传入一个Function的函数式接口，接口定义可以查看[《JAVA8 Function接口》][JAVA8 Function]，这个接口，接收一个泛型T，返回泛型R，map函数的定义，返回的流，表示的泛型是R对象，这个表示，调用这个函数后，可以改变返回的类型，先看下面的案例

public class TestJava8 {
    	public static void main(String[] args) {
    		Integer[] dd = { 1, 2, 3 };
    		Stream<Integer> stream = Arrays.stream(dd);
    		stream.map(str -> Integer.toString(str)).forEach(str -> {
    			System.out.println(str);// 1 ,2 ,3
    			System.out.println(str.getClass());// class java.lang.String
    		});
    
    		List<Emp> list = Arrays.asList(new Emp("a"), new Emp("b"), new Emp("c"));
    		list.stream().map(emp -> emp.getName()).forEach(str -> {
    			System.out.println(str);
    		});
    
    	}
    
    	public static class Emp {
    		private String name;
    
    		public Emp() {
    			super();
    		}
    
    		public Emp(String name) {
    			super();
    			this.name = name;
    		}
    
    		public String getName() {
    			return name;
    		}
    
    		public void setName(String name) {
    			this.name = name;
    		}
    
    	}
    }

可以看到，我们把Integer，变成了String输出，把Emp对象里的name字符串，单独输出；现在，我们只看到了一个forEach的终端操作，后面，我们会看到，更多的终端操作，把map操作后，改变的对象类型，返回各种类型的集合，或者对数字类型的，返回求和，最大，最小等的操作；

3.flatMap操作，我们还是先看接口定义

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

这个接口，跟map一样，接收一个Fucntion的函数式接口，不同的是，Function接收的泛型参数，第二个参数是一个Stream流；方法，返回的也是泛型R，具体的作用是把两个流，变成一个流返回，下面，我们看一个案例，来详细解答，怎么把两个流的内容，变成一个流的内容

public class TestJava8 {
    	public static void main(String[] args) {
    		String[] strs = { "aaa", "bbb", "ccc" };
    		Arrays.stream(strs).map(str -> str.split("")).forEach(System.out::println);// Ljava.lang.String;@53d8d10a
    		Arrays.stream(strs).map(str -> str.split("")).flatMap(Arrays::stream).forEach(System.out::println);// aaabbbccc
    		Arrays.stream(strs).map(str -> str.split("")).flatMap(str -> Arrays.stream(str)).forEach(System.out::println);// aaabbbccc
    	}
    }

首先，第一个输出语句里，我们看到，我们输出的对象，并不是想象中的具体的字符串，第二段代码，才输出的具体的字符串；

第一段输出代码里，我们先看map操作，通过上面对map的介绍，我们可以看到，map可以改变返回的Stream的泛型，str.split("")，根据空字符串分隔，返回的类型是一个数组，返回的流也是Stream<String\[\]>，而不是Stream<String>；在第二段代码中，数组的流，经过map操作，返回Stream<String\[\]>后，再经过flatMap，把数组通过Arrays.stream变成一个新的流，再返回到原来的流里；这样，两个流就合并成一个流；第三段代码，是第二段代码的，另一种写法；

## 1.lambda表达式 ##

[《java8 Lambda表达式简介》][java8 Lambda]

[《java8 lambda表达式，方法的引用以及构造器的引用》][java8 lambda]

### 2.函数式接口 ###

[《java8 函数式接口简介》][java8]

[《JAVA8 Function接口以及同类型的特化的接口》][JAVA8 Function]

[《JAVA8 Consumer接口》][JAVA8 Consumer]

[《JAVA8 Supplier接口》][JAVA8 Supplier]

[《JAVA8 UnaryOperator接口》][JAVA8 UnaryOperator]

[《JAVA8 BiConsumer 接口》][JAVA8 BiConsumer]

3.stream接口操作

[《java8 Stream接口简介》][java8 Stream]

[《 java8 Stream-创建流的几种方式》][java8 Stream-]

[《JAVA8 stream接口 中间操作和终端操作》][JAVA8 stream_]

[《JAVA8 Stream接口，map操作，filter操作，flatMap操作》][JAVA8 Stream_map_filter_flatMap]

[《JAVA8 stream接口 distinct，sorted，peek，limit，skip》][JAVA8 stream_ distinct_sorted_peek_limit_skip]

[《java8 stream接口 终端操作 forEachOrdered和forEach》][java8 stream_ _ forEachOrdered_forEach]

[《java8 stream接口 终端操作 toArray操作》][java8 stream_ _ toArray]

[《java8 stream接口 终端操作 min，max，findFirst，findAny操作》][java8 stream_ _ min_max_findFirst_findAny]

[《java8 stream接口终端操作 count，anyMatch，allMatch，noneMatch》][java8 stream_ count_anyMatch_allMatch_noneMatch]

[《java8 srteam接口终端操作reduce操作》][java8 srteam_reduce]

[《java8 stream接口 终端操作 collect操作》][java8 stream_ _ collect]

4.其他部分

[《java8 Optional静态类简介，以及用法》][java8 Optional]

[JAVA8 stream_]: https://blog.csdn.net/qq_28410283/article/details/80634725
[JAVA8 Predicate]: https://blog.csdn.net/qq_28410283/article/details/80601495
[JAVA8 Function]: https://blog.csdn.net/qq_28410283/article/details/80615629
[java8 Lambda]: https://blog.csdn.net/qq_28410283/article/details/80961022
[java8 lambda]: https://blog.csdn.net/qq_28410283/article/details/80963351
[java8]: https://blog.csdn.net/qq_28410283/article/details/80962325
[JAVA8 Consumer]: https://blog.csdn.net/qq_28410283/article/details/80618456
[JAVA8 Supplier]: https://blog.csdn.net/qq_28410283/article/details/80625482
[JAVA8 UnaryOperator]: https://blog.csdn.net/qq_28410283/article/details/80634319
[JAVA8 BiConsumer]: https://blog.csdn.net/qq_28410283/article/details/80704487
[java8 Stream]: https://blog.csdn.net/qq_28410283/article/details/80633292
[java8 Stream-]: https://blog.csdn.net/qq_28410283/article/details/80633710
[JAVA8 Stream_map_filter_flatMap]: https://blog.csdn.net/qq_28410283/article/details/80642786
[JAVA8 stream_ distinct_sorted_peek_limit_skip]: https://blog.csdn.net/qq_28410283/article/details/80643711
[java8 stream_ _ forEachOrdered_forEach]: https://blog.csdn.net/qq_28410283/article/details/80782808
[java8 stream_ _ toArray]: https://blog.csdn.net/qq_28410283/article/details/80783286
[java8 stream_ _ min_max_findFirst_findAny]: https://blog.csdn.net/qq_28410283/article/details/80783505
[java8 stream_ count_anyMatch_allMatch_noneMatch]: https://blog.csdn.net/qq_28410283/article/details/80783946
[java8 srteam_reduce]: https://blog.csdn.net/qq_28410283/article/details/80873910
[java8 stream_ _ collect]: https://blog.csdn.net/qq_28410283/article/details/81052881
[java8 Optional]: https://blog.csdn.net/qq_28410283/article/details/80952768