diff --git a/utils/stream/map.go b/utils/stream/map.go
index 1d28fbf..ba4d398 100644
--- a/utils/stream/map.go
+++ b/utils/stream/map.go
@@ -4,6 +4,11 @@ import (
 	"github.com/kercylan98/minotaur/utils/hash"
 )
 
+// WithMap 将映射转换为流
+func WithMap[K comparable, V any](m map[K]V) Map[K, V] {
+	return m
+}
+
 type Map[K comparable, V any] map[K]V
 
 // Map 返回映射
@@ -60,7 +65,7 @@ func (slf Map[K, V]) FilterFCopy(expression func(key K, value V) bool) Map[K, V]
 }
 
 // Chunk 是 hash.Chunk 的快捷方式
-func (slf Map[K, V]) Chunk(size int) Slice[Map[K, V]] {
+func (slf Map[K, V]) Chunk(size int) Maps[K, V] {
 	chunks := hash.Chunk(slf, size)
 	var res = make([]Map[K, V], 0, len(chunks))
 	for i := range chunks {
diff --git a/utils/stream/map_test.go b/utils/stream/map_test.go
new file mode 100644
index 0000000..c037496
--- /dev/null
+++ b/utils/stream/map_test.go
@@ -0,0 +1,14 @@
+package stream_test
+
+import (
+	"github.com/kercylan98/minotaur/utils/stream"
+	"testing"
+)
+
+func TestMap_Chunk(t *testing.T) {
+	var m = map[string]int{
+		"a": 1,
+		"b": 2,
+	}
+	t.Log(stream.WithMap(m).Chunk(1).Merge())
+}
diff --git a/utils/stream/maps.go b/utils/stream/maps.go
new file mode 100644
index 0000000..96503a1
--- /dev/null
+++ b/utils/stream/maps.go
@@ -0,0 +1,166 @@
+package stream
+
+import "github.com/kercylan98/minotaur/utils/slice"
+
+// WithMaps 将多个 map 转换为流
+func WithMaps[K comparable, V any](maps ...map[K]V) Maps[K, V] {
+	var ms = make(Maps[K, V], len(maps))
+	for i, m := range maps {
+		ms[i] = m
+	}
+	return ms
+}
+
+// WithStreamMaps 将多个 map 转换为流
+func WithStreamMaps[K comparable, V any](maps ...Map[K, V]) Maps[K, V] {
+	var ms = make(Maps[K, V], len(maps))
+	for i, m := range maps {
+		ms[i] = m
+	}
+	return ms
+}
+
+type Maps[K comparable, V any] []Map[K, V]
+
+// Merge 将多个 map 合并为一个 map，返回该 map 的流
+//   - 当多个 map 中存在相同 key 的元素时，将会发生随机覆盖
+func (slf Maps[K, V]) Merge() Map[K, V] {
+	var m = make(map[K]V)
+	for _, stream := range slf {
+		for k, v := range stream {
+			m[k] = v
+		}
+	}
+	return m
+}
+
+// Drop 是 slice.Drop 的快捷方式
+func (slf Maps[K, V]) Drop(start, n int) Maps[K, V] {
+	return slice.Drop(start, n, slf)
+}
+
+// DropBy 是 slice.DropBy 的快捷方式
+func (slf Maps[K, V]) DropBy(fn func(index int, value Map[K, V]) bool) Maps[K, V] {
+	return slice.DropBy(slf, fn)
+}
+
+// Each 是 slice.Each 的快捷方式
+func (slf Maps[K, V]) Each(abort bool, iterator func(index int, item Map[K, V]) bool) Maps[K, V] {
+	slice.Each(abort, slf, iterator)
+	return slf
+}
+
+// EachT 是 slice.EachT 的快捷方式
+func (slf Maps[K, V]) EachT(iterator func(index int, item Map[K, V]) bool) Maps[K, V] {
+	slice.EachT(slf, iterator)
+	return slf
+}
+
+// EachF 是 slice.EachF 的快捷方式
+func (slf Maps[K, V]) EachF(iterator func(index int, item Map[K, V]) bool) Maps[K, V] {
+	slice.EachF(slf, iterator)
+	return slf
+}
+
+// EachReverse 是 slice.EachReverse 的快捷方式
+func (slf Maps[K, V]) EachReverse(abort bool, iterator func(index int, item Map[K, V]) bool) Maps[K, V] {
+	slice.EachReverse(abort, slf, iterator)
+	return slf
+}
+
+// EachReverseT 是 slice.EachReverseT 的快捷方式
+func (slf Maps[K, V]) EachReverseT(iterator func(index int, item Map[K, V]) bool) Maps[K, V] {
+	slice.EachReverseT(slf, iterator)
+	return slf
+}
+
+// EachReverseF 是 slice.EachReverseF 的快捷方式
+func (slf Maps[K, V]) EachReverseF(iterator func(index int, item Map[K, V]) bool) Maps[K, V] {
+	slice.EachReverseF(slf, iterator)
+	return slf
+}
+
+// FillBy 是 slice.FillBy 的快捷方式
+func (slf Maps[K, V]) FillBy(fn func(index int, value Map[K, V]) Map[K, V]) Maps[K, V] {
+	return slice.FillBy(slf, fn)
+}
+
+// FillByCopy 是 slice.FillByCopy 的快捷方式
+func (slf Maps[K, V]) FillByCopy(fn func(index int, value Map[K, V]) Map[K, V]) Maps[K, V] {
+	return slice.FillByCopy(slf, fn)
+}
+
+// FillUntil 是 slice.FillUntil 的快捷方式
+func (slf Maps[K, V]) FillUntil(abort bool, fn func(index int, value Map[K, V]) (Map[K, V], bool)) Maps[K, V] {
+	return slice.FillUntil(abort, slf, fn)
+}
+
+// FillUntilCopy 是 slice.FillUntilCopy 的快捷方式
+func (slf Maps[K, V]) FillUntilCopy(abort bool, fn func(index int, value Map[K, V]) (Map[K, V], bool)) Maps[K, V] {
+	return slice.FillUntilCopy(abort, slf, fn)
+}
+
+// FillUntilT 是 slice.FillUntilT 的快捷方式
+func (slf Maps[K, V]) FillUntilT(fn func(index int, value Map[K, V]) (Map[K, V], bool)) Maps[K, V] {
+	return slice.FillUntilT(slf, fn)
+}
+
+// FillUntilF 是 slice.FillUntilF 的快捷方式
+func (slf Maps[K, V]) FillUntilF(fn func(index int, value Map[K, V]) (Map[K, V], bool)) Maps[K, V] {
+	return slice.FillUntilF(slf, fn)
+}
+
+// FillUntilTCopy 是 slice.FillUntilTCopy 的快捷方式
+func (slf Maps[K, V]) FillUntilTCopy(fn func(index int, value Map[K, V]) (Map[K, V], bool)) Maps[K, V] {
+	return slice.FillUntilTCopy(slf, fn)
+}
+
+// FillUntilFCopy 是 slice.FillUntilFCopy 的快捷方式
+func (slf Maps[K, V]) FillUntilFCopy(fn func(index int, value Map[K, V]) (Map[K, V], bool)) Maps[K, V] {
+	return slice.FillUntilFCopy(slf, fn)
+}
+
+// Filter 是 slice.Filter 的快捷方式
+func (slf Maps[K, V]) Filter(reserve bool, expression func(index int, item Map[K, V]) bool) Maps[K, V] {
+	return slice.Filter(reserve, slf, expression)
+}
+
+// FilterT 是 slice.FilterT 的快捷方式
+func (slf Maps[K, V]) FilterT(expression func(index int, item Map[K, V]) bool) Maps[K, V] {
+	return slice.FilterT(slf, expression)
+}
+
+// FilterF 是 slice.FilterF 的快捷方式
+func (slf Maps[K, V]) FilterF(expression func(index int, item Map[K, V]) bool) Maps[K, V] {
+	return slice.FilterF(slf, expression)
+}
+
+// FilterCopy 是 slice.FilterCopy 的快捷方式
+func (slf Maps[K, V]) FilterCopy(reserve bool, expression func(index int, item Map[K, V]) bool) Maps[K, V] {
+	return slice.FilterCopy(reserve, slf, expression)
+}
+
+// FilterTCopy 是 slice.FilterTCopy 的快捷方式
+func (slf Maps[K, V]) FilterTCopy(expression func(index int, item Map[K, V]) bool) Maps[K, V] {
+	return slice.FilterTCopy(slf, expression)
+}
+
+// FilterFCopy 是 slice.FilterFCopy 的快捷方式
+func (slf Maps[K, V]) FilterFCopy(expression func(index int, item Map[K, V]) bool) Maps[K, V] {
+	return slice.FilterFCopy(slf, expression)
+}
+
+// Shuffle 是 slice.Shuffle 的快捷方式
+func (slf Maps[K, V]) Shuffle() Maps[K, V] {
+	return slice.Shuffle(slf)
+}
+
+// ShuffleCopy 是 slice.ShuffleCopy 的快捷方式
+func (slf Maps[K, V]) ShuffleCopy() Maps[K, V] {
+	return slice.ShuffleCopy(slf)
+}
+
+// UniqueBy 是 slice.UniqueBy 的快捷方式
+func (slf Maps[K, V]) UniqueBy(fn func(Map[K, V]) any) Maps[K, V] {
+	return slice.UniqueBy(slf, fn)
+}
diff --git a/utils/stream/slice.go b/utils/stream/slice.go
index 66e0827..43d8b28 100644
--- a/utils/stream/slice.go
+++ b/utils/stream/slice.go
@@ -2,6 +2,11 @@ package stream
 
 import "github.com/kercylan98/minotaur/utils/slice"
 
+// WithSlice 将切片转换为流
+func WithSlice[V any](slice []V) Slice[V] {
+	return slice
+}
+
 type Slice[V any] []V
 
 // Slice 返回切片
diff --git a/utils/stream/slices.go b/utils/stream/slices.go
index e0d7ca1..2b42c3c 100644
--- a/utils/stream/slices.go
+++ b/utils/stream/slices.go
@@ -2,6 +2,24 @@ package stream
 
 import "github.com/kercylan98/minotaur/utils/slice"
 
+// WithSlices 将多个切片转换为流
+func WithSlices[V any](slices ...[]V) Slices[V] {
+	var ss = make(Slices[V], len(slices))
+	for i, s := range slices {
+		ss[i] = s
+	}
+	return ss
+}
+
+// WithStreamSlices 将多个切片转换为流
+func WithStreamSlices[V any](slices ...Slice[V]) Slices[V] {
+	var ss = make(Slices[V], len(slices))
+	for i, s := range slices {
+		ss[i] = s
+	}
+	return ss
+}
+
 type Slices[V any] []Slice[V]
 
 // Merge 合并为一个切片
@@ -13,133 +31,133 @@ func (slf Slices[V]) Merge() Slice[V] {
 	return s
 }
 
-// Drop 的快捷方式
+// Drop 是 slice.Drop 的快捷方式
 func (slf Slices[V]) Drop(start, n int) Slices[V] {
 	return slice.Drop(start, n, slf)
 }
 
-// DropBy 的快捷方式
+// DropBy 是 slice.DropBy 的快捷方式
 func (slf Slices[V]) DropBy(fn func(index int, value Slice[V]) bool) Slices[V] {
 	return slice.DropBy(slf, fn)
 }
 
-// Each 的快捷方式
+// Each 是 slice.Each 的快捷方式
 func (slf Slices[V]) Each(abort bool, iterator func(index int, item Slice[V]) bool) Slices[V] {
 	slice.Each(abort, slf, iterator)
 	return slf
 }
 
-// EachT 的快捷方式
+// EachT 是 slice.EachT 的快捷方式
 func (slf Slices[V]) EachT(iterator func(index int, item Slice[V]) bool) Slices[V] {
 	slice.EachT(slf, iterator)
 	return slf
 }
 
-// EachF 的快捷方式
+// EachF 是 slice.EachF 的快捷方式
 func (slf Slices[V]) EachF(iterator func(index int, item Slice[V]) bool) Slices[V] {
 	slice.EachF(slf, iterator)
 	return slf
 }
 
-// EachReverse 的快捷方式
+// EachReverse 是 slice.EachReverse 的快捷方式
 func (slf Slices[V]) EachReverse(abort bool, iterator func(index int, item Slice[V]) bool) Slices[V] {
 	slice.EachReverse(abort, slf, iterator)
 	return slf
 }
 
-// EachReverseT 的快捷方式
+// EachReverseT 是 slice.EachReverseT 的快捷方式
 func (slf Slices[V]) EachReverseT(iterator func(index int, item Slice[V]) bool) Slices[V] {
 	slice.EachReverseT(slf, iterator)
 	return slf
 }
 
-// EachReverseF 的快捷方式
+// EachReverseF 是 slice.EachReverseF 的快捷方式
 func (slf Slices[V]) EachReverseF(iterator func(index int, item Slice[V]) bool) Slices[V] {
 	slice.EachReverseF(slf, iterator)
 	return slf
 }
 
-// FillBy 的快捷方式
+// FillBy 是 slice.FillBy 的快捷方式
 func (slf Slices[V]) FillBy(fn func(index int, value Slice[V]) Slice[V]) Slices[V] {
 	return slice.FillBy(slf, fn)
 }
 
-// FillByCopy 的快捷方式
+// FillByCopy 是 slice.FillByCopy 的快捷方式
 func (slf Slices[V]) FillByCopy(fn func(index int, value Slice[V]) Slice[V]) Slices[V] {
 	return slice.FillByCopy(slf, fn)
 }
 
-// FillUntil 的快捷方式
+// FillUntil 是 slice.FillUntil 的快捷方式
 func (slf Slices[V]) FillUntil(abort bool, fn func(index int, value Slice[V]) (Slice[V], bool)) Slices[V] {
 	return slice.FillUntil(abort, slf, fn)
 }
 
-// FillUntilCopy 的快捷方式
+// FillUntilCopy 是 slice.FillUntilCopy 的快捷方式
 func (slf Slices[V]) FillUntilCopy(abort bool, fn func(index int, value Slice[V]) (Slice[V], bool)) Slices[V] {
 	return slice.FillUntilCopy(abort, slf, fn)
 }
 
-// FillUntilT 的快捷方式
+// FillUntilT 是 slice.FillUntilT 的快捷方式
 func (slf Slices[V]) FillUntilT(fn func(index int, value Slice[V]) (Slice[V], bool)) Slices[V] {
 	return slice.FillUntilT(slf, fn)
 }
 
-// FillUntilF 的快捷方式
+// FillUntilF 是 slice.FillUntilF 的快捷方式
 func (slf Slices[V]) FillUntilF(fn func(index int, value Slice[V]) (Slice[V], bool)) Slices[V] {
 	return slice.FillUntilF(slf, fn)
 }
 
-// FillUntilTCopy 的快捷方式
+// FillUntilTCopy 是 slice.FillUntilTCopy 的快捷方式
 func (slf Slices[V]) FillUntilTCopy(fn func(index int, value Slice[V]) (Slice[V], bool)) Slices[V] {
 	return slice.FillUntilTCopy(slf, fn)
 }
 
-// FillUntilFCopy 的快捷方式
+// FillUntilFCopy 是 slice.FillUntilFCopy 的快捷方式
 func (slf Slices[V]) FillUntilFCopy(fn func(index int, value Slice[V]) (Slice[V], bool)) Slices[V] {
 	return slice.FillUntilFCopy(slf, fn)
 }
 
-// Filter 的快捷方式
+// Filter 是 slice.Filter 的快捷方式
 func (slf Slices[V]) Filter(reserve bool, expression func(index int, item Slice[V]) bool) Slices[V] {
 	return slice.Filter(reserve, slf, expression)
 }
 
-// FilterT 的快捷方式
+// FilterT 是 slice.FilterT 的快捷方式
 func (slf Slices[V]) FilterT(expression func(index int, item Slice[V]) bool) Slices[V] {
 	return slice.FilterT(slf, expression)
 }
 
-// FilterF 的快捷方式
+// FilterF 是 slice.FilterF 的快捷方式
 func (slf Slices[V]) FilterF(expression func(index int, item Slice[V]) bool) Slices[V] {
 	return slice.FilterF(slf, expression)
 }
 
-// FilterCopy 的快捷方式
+// FilterCopy 是 slice.FilterCopy 的快捷方式
 func (slf Slices[V]) FilterCopy(reserve bool, expression func(index int, item Slice[V]) bool) Slices[V] {
 	return slice.FilterCopy(reserve, slf, expression)
 }
 
-// FilterTCopy 的快捷方式
+// FilterTCopy 是 slice.FilterTCopy 的快捷方式
 func (slf Slices[V]) FilterTCopy(expression func(index int, item Slice[V]) bool) Slices[V] {
 	return slice.FilterTCopy(slf, expression)
 }
 
-// FilterFCopy 的快捷方式
+// FilterFCopy 是 slice.FilterFCopy 的快捷方式
 func (slf Slices[V]) FilterFCopy(expression func(index int, item Slice[V]) bool) Slices[V] {
 	return slice.FilterFCopy(slf, expression)
 }
 
-// Shuffle 的快捷方式
+// Shuffle 是 slice.Shuffle 的快捷方式
 func (slf Slices[V]) Shuffle() Slices[V] {
 	return slice.Shuffle(slf)
 }
 
-// ShuffleCopy 的快捷方式
+// ShuffleCopy 是 slice.ShuffleCopy 的快捷方式
 func (slf Slices[V]) ShuffleCopy() Slices[V] {
 	return slice.ShuffleCopy(slf)
 }
 
-// UniqueBy 的快捷方式
+// UniqueBy 是 slice.UniqueBy 的快捷方式
 func (slf Slices[V]) UniqueBy(fn func(Slice[V]) any) Slices[V] {
 	return slice.UniqueBy(slf, fn)
 }