diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java b/hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java
index eb9a4d248..d0d302519 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java
@@ -289,21 +289,6 @@ 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))));
-	}
-
 	/**
 	 * 返回与指定函数将元素作为参数执行的结果组成的流
 	 * 这是一个无状态中间操作
@@ -330,8 +315,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 	 * @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));
+		return nonNull().<R>map(mapper).nonNull();
 	}
 
 	/**
@@ -366,7 +350,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).filter(Objects::nonNull));
+		return new FastStream<>(stream.flatMap(mapper));
 	}
 
 	/**
@@ -429,18 +413,22 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 	 * 这是一个无状态中间操作<br>
 	 * 例如，将users里所有user的id和parentId组合在一起，形成一个新的流:
 	 * <pre>{@code
-	 *     FastStream<Long> ids = FastStream.of(users).flatMap(user -> FastStream.of(user.getId(), user.getParentId()));
+	 *     FastStream<Long> ids = FastStream.of(users).flat(user -> FastStream.of(user.getId(), user.getParentId()));
 	 * }</pre>
 	 *
 	 * @param mapper 操作，返回可迭代对象
 	 * @param <R>    拆分后流的元素类型
 	 * @return 返回叠加拆分操作后的流
 	 */
-	public <R> FastStream<R> flatIter(Function<? super T, ? extends Iterable<? extends R>> mapper) {
+	public <R> FastStream<R> flat(Function<? super T, ? extends Iterable<? extends R>> mapper) {
 		Objects.requireNonNull(mapper);
 		return flatMap(w -> of(mapper.apply(w)));
 	}
 
+	public <R> FastStream<R> flatNonNull(Function<? super T, ? extends Iterable<? extends R>> mapper) {
+		return nonNull().flat(mapper).nonNull();
+	}
+
 	/**
 	 * 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流
 	 * 这是一个无状态中间操作
@@ -1457,8 +1445,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 	 * <p>与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
 	 * <pre>本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
 	 * FastStream.iterate(1, i -> i + 1)
-	 *	.parallel()
-	 *	// 顺序执行
+	 * 	.parallel()
+	 * 	// 顺序执行
 	 * 	.takeWhile(e -> e < 50)
 	 * 	// 并发
 	 * 	.map(e -> e + 1)
@@ -1476,25 +1464,14 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 		return of(StreamUtil.takeWhile(stream, predicate));
 	}
 
-	/**
-	 * 保留 与指定断言 匹配的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
-	 * <p>takeWhile 的别名方法</p>
-	 *
-	 * @param predicate 断言
-	 * @return 与指定断言匹配的元素组成的流
-	 * @see #takeWhile(Predicate)
-	 */
-	public FastStream<T> limit(Predicate<? super T> predicate) {
-		return takeWhile(predicate);
-	}
 
 	/**
 	 * 删除 与指定断言 匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
 	 * <p>与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
 	 * <pre>本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
 	 * FastStream.iterate(1, i <= 100, i -> i + 1)
-	 *	.parallel()
-	 *	// 顺序执行
+	 * 	.parallel()
+	 * 	// 顺序执行
 	 * 	.dropWhile(e -> e < 50)
 	 * 	// 并发
 	 * 	.map(e -> e + 1)
@@ -1512,18 +1489,6 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
 		return of(StreamUtil.dropWhile(stream, predicate));
 	}
 
-	/**
-	 * 跳过 与断言匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
-	 * <p>dropWhile 的别名方法</p>
-	 *
-	 * @param predicate 断言
-	 * @return 剩余元素组成的流
-	 * @see #dropWhile(Predicate)
-	 */
-	public FastStream<T> skip(Predicate<? super T> predicate) {
-		return dropWhile(predicate);
-	}
-
 	/**
 	 * 流是否为空
 	 *
diff --git a/hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java b/hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java
index dd15418e3..e9d51b7c5 100644
--- a/hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java
@@ -23,6 +23,12 @@ public class FastStreamTest {
 		Assert.assertEquals(Arrays.asList(1, 2, 3), list);
 	}
 
+	@Test
+	public void testGenerate() {
+		List<Integer> list = FastStream.generate(() -> 0).limit(3).toList();
+		Assert.assertEquals(Arrays.asList(0, 0, 0), list);
+	}
+
 	@Test
 	public void testOf() {
 		Assert.assertEquals(3, FastStream.of(Arrays.asList(1, 2, 3), true).count());
@@ -140,6 +146,13 @@ public class FastStreamTest {
 		Assert.assertEquals(Arrays.asList(1, 2, 2, 3, 3, 3), mapMulti);
 	}
 
+	@Test
+	public void testMapNonNull() {
+		List<Integer> list = Arrays.asList(1, 2, 3, null);
+		List<String> mapNonNull = FastStream.of(list).mapNonNull(String::valueOf).toList();
+		Assert.assertEquals(Arrays.asList("1", "2", "3"), mapNonNull);
+	}
+
 	@Test
 	public void testDistinct() {
 		List<Integer> list = ListUtil.of(3, 2, 2, 1, null, null);
@@ -174,6 +187,11 @@ public class FastStreamTest {
 		FastStream.FastStreamBuilder<String> builder = FastStream.builder();
 		FastStream.of(list).forEachOrderedIdx((e, i) -> builder.accept(i + 1 + "." + e));
 		Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList());
+
+		FastStream.FastStreamBuilder<String> streamBuilder = FastStream.builder();
+		FastStream.of(list).parallel().forEachOrderedIdx((e, i) -> streamBuilder.accept(i + 1 + "." + e));
+		Assert.assertEquals(Arrays.asList("0.dromara", "0.hutool", "0.sweet"), streamBuilder.build().toList());
+
 	}
 
 	@Test
@@ -186,22 +204,22 @@ public class FastStreamTest {
 	}
 
 	@Test
-	public void testFlatIter() {
+	public void testFlat() {
 		List<Integer> list = Arrays.asList(1, 2, 3);
 
 		// 一个元素 扩散为 多个元素(迭代器)
-		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);
+		List<Integer> flat = FastStream.of(list).flat(e -> Arrays.asList(e, e * 10)).toList();
+		Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flat);
 
 		// 过滤迭代器为null的元素
-		flatMapIter = FastStream.of(list).<Integer>flatIter(e -> null).toList();
-		Assert.assertEquals(Collections.emptyList(), flatMapIter);
+		flat = FastStream.of(list).<Integer>flat(e -> null).toList();
+		Assert.assertEquals(Collections.emptyList(), flat);
 
 		// 自动过滤null元素
-		flatMapIter = FastStream.of(list).flatIter(e -> Arrays.asList(e, null)).toList();
-		Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flatMapIter);
+		flat = FastStream.of(list).flat(e -> Arrays.asList(e, e > 2 ? e : null)).toList();
+		Assert.assertEquals(ListUtil.of(1, null, 2, null, 3, 3), flat);
 		// 不报npe测试
-		Assert.assertTrue(FastStream.of(list).flatMapIter(e -> null).isEmpty());
+		Assert.assertTrue(FastStream.of(list).flat(e -> null).isEmpty());
 	}
 
 	@Test
@@ -238,6 +256,8 @@ public class FastStreamTest {
 		List<Integer> list = Arrays.asList(1, 2);
 		List<Integer> push = FastStream.of(list).push(3).toList();
 		Assert.assertEquals(Arrays.asList(1, 2, 3), push);
+
+		Assert.assertEquals(Arrays.asList(1, 2, 3, 4), FastStream.of(list).push(3, 4).toList());
 	}
 
 	@Test
@@ -245,6 +265,8 @@ public class FastStreamTest {
 		List<Integer> list = Arrays.asList(2, 3);
 		List<Integer> unshift = FastStream.of(list).unshift(1).toList();
 		Assert.assertEquals(Arrays.asList(1, 2, 3), unshift);
+
+		Assert.assertEquals(Arrays.asList(1, 2, 2, 3), FastStream.of(list).unshift(1, 2).toList());
 	}
 
 	@Test