1.新增NonNull(Function)、mapNonNull(Function);

2.flatMapIter名称修改为flatIter;
3.flatMap和flatIter主动过滤null元素;

hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java

@@ -289,6 +289,21 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 		return new FastStream<>(stream.filter(Objects::nonNull));
 	}
 
+	/**
+	 * 过滤掉 元素 指定字段值为 {@code null} 的元素, 返回剩下元素组成的流<br>
+	 * <pre>{@code
+	 * // 例如, 过滤 id为空 的元素
+	 * .of(userList).nonNull(UserEntity::getId)...
+	 * }</pre>
+	 * 这是一个无状态中间操作<br>
+	 *
+	 * @return 过滤后的流
+	 */
+	public <R> FastStream<T> nonNull(Function<? super T, ? extends R> mapper) {
+		Objects.requireNonNull(mapper);
+		return new FastStream<>(stream.filter(e -> Objects.nonNull(mapper.apply(e))));
+	}
+
 	/**
 	 * 返回与指定函数将元素作为参数执行的结果组成的流
 	 * 这是一个无状态中间操作
@@ -302,6 +317,23 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 		return new FastStream<>(stream.map(mapper));
 	}
 
+	/**
+	 * 返回 元素 转换后 并且不为 {@code null} 的 新元素组成的流<br>
+	 * 这是一个无状态中间操作<br>
+	 * <pre>{@code
+	 * // 等价于先调用map再调用nonNull
+	 * .map(...).nonNull()...
+	 * }</pre>
+	 *
+	 * @param mapper 指定的函数
+	 * @param <R>    函数执行后返回的类型
+	 * @return 新元素组成的流
+	 */
+	public <R> FastStream<R> mapNonNull(Function<? super T, ? extends R> mapper) {
+		final Stream<R> mapStream = this.stream.map(mapper);
+		return new FastStream<>(mapStream.filter(Objects::nonNull));
+	}
+
 	/**
 	 * 返回与指定函数将元素作为参数执行的结果组成的流，操作带下标，并行流时下标永远为-1
 	 * 这是一个无状态中间操作
@@ -321,7 +353,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 	}
 
 	/**
-	 * 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流
+	 * 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，并过滤{@code null}元素, 返回多个流所有非空元素组成的流<br>
 	 * 这是一个无状态中间操作
 	 * 例如，将users里所有user的id和parentId组合在一起，形成一个新的流:
 	 * <pre>{@code
@@ -334,7 +366,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 	 */
 	@Override
 	public <R> FastStream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
-		return new FastStream<>(stream.flatMap(mapper));
+		return new FastStream<>(stream.flatMap(mapper).filter(Objects::nonNull));
 	}
 
 	/**
@@ -392,8 +424,9 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 	}
 
 	/**
-	 * 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流
-	 * 这是一个无状态中间操作
+	 * 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作, 转换为迭代器元素,
+	 * 并过滤迭代器中的 {@code null} 元素，最后返回所有迭代器的所有非空元素组成的流<br>
+	 * 这是一个无状态中间操作<br>
 	 * 例如，将users里所有user的id和parentId组合在一起，形成一个新的流:
 	 * <pre>{@code
 	 *     FastStream<Long> ids = FastStream.of(users).flatMap(user -> FastStream.of(user.getId(), user.getParentId()));
@@ -403,7 +436,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>    拆分后流的元素类型
 	 * @return 返回叠加拆分操作后的流
 	 */
-	public <R> FastStream<R> flatMapIter(Function<? super T, ? extends Iterable<? extends R>> mapper) {
+	public <R> FastStream<R> flatIter(Function<? super T, ? extends Iterable<? extends R>> mapper) {
 		Objects.requireNonNull(mapper);
 		return flatMap(w -> of(mapper.apply(w)));
 	}

hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java

@@ -186,12 +186,19 @@ public class FastStreamTest {
 	}
 
 	@Test
-	public void testFlatMapIter() {
+	public void testFlatIter() {
 		List<Integer> list = Arrays.asList(1, 2, 3);
-		List<Integer> flatMapIter = FastStream.of(list).<Integer>flatMapIter(e -> null).toList();
+
+		// 一个元素 扩散为 多个元素(迭代器)
+		List<Integer> flatMapIter = FastStream.of(list).flatIter(e -> Arrays.asList(e, e * 10)).toList();
+		Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flatMapIter);
+
+		// 过滤迭代器为null的元素
+		flatMapIter = FastStream.of(list).<Integer>flatIter(e -> null).toList();
 		Assert.assertEquals(Collections.emptyList(), flatMapIter);
 
-		flatMapIter = FastStream.of(list).flatMapIter(e -> Arrays.asList(e, e * 10)).toList();
+		// 自动过滤null元素
+		flatMapIter = FastStream.of(list).flatIter(e -> Arrays.asList(e, null)).toList();
 		Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flatMapIter);
 		// 不报npe测试
 		Assert.assertTrue(FastStream.of(list).flatMapIter(e -> null).isEmpty());