diff --git a/mapx/map.go b/mapx/map.go
index 0d3f867..78e838f 100644
--- a/mapx/map.go
+++ b/mapx/map.go
@@ -14,6 +14,8 @@
 
 package mapx
 
+import "fmt"
+
 // Keys 返回 map 里面的所有的 key。
 // 需要注意：这些 key 的顺序是随机。
 func Keys[K comparable, V any](m map[K]V) []K {
@@ -45,3 +47,28 @@ func KeysValues[K comparable, V any](m map[K]V) ([]K, []V) {
 	}
 	return keys, values
 }
+
+// ToMap 将会返回一个map[K]V
+// 请保证传入的 keys 与 values 长度相同，长度均为n
+// 长度不相同或者 keys 或者 values 为nil则会抛出异常
+// 返回的 m map[K]V 保证对于所有的 0 <= i < n
+// m[keys[i]] = values[i]
+//
+//	注意：
+//	如果传入的数组中存在 0 <= i < j < n使得 keys[i] == keys[j]
+//	则在返回的 m 中 m[keys[i]] = values[j]
+//	如果keys和values的长度为0，则会返回一个空map
+func ToMap[K comparable, V any](keys []K, values []V) (m map[K]V, err error) {
+	if keys == nil || values == nil {
+		return nil, fmt.Errorf("keys与values均不可为nil")
+	}
+	n := len(keys)
+	if n != len(values) {
+		return nil, fmt.Errorf("keys与values的长度不同, len(keys)=%d, len(values)=%d", n, len(values))
+	}
+	m = make(map[K]V, n)
+	for i := 0; i < n; i++ {
+		m[keys[i]] = values[i]
+	}
+	return
+}
diff --git a/mapx/map_test.go b/mapx/map_test.go
index 569ac2a..0d84701 100644
--- a/mapx/map_test.go
+++ b/mapx/map_test.go
@@ -15,6 +15,7 @@
 package mapx
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -147,3 +148,63 @@ func TestKeysValues(t *testing.T) {
 		})
 	}
 }
+
+func TestToMap(t *testing.T) {
+	type caseType struct {
+		keys   []int
+		values []string
+
+		result map[int]string
+		err    error
+	}
+	for _, c := range []caseType{
+		{
+			keys:   []int{1, 2, 3},
+			values: []string{"1", "2", "3"},
+			result: map[int]string{
+				1: "1",
+				2: "2",
+				3: "3",
+			},
+			err: nil,
+		},
+		{
+			keys:   []int{1, 2, 3},
+			values: []string{"1", "2"},
+			result: nil,
+			err:    fmt.Errorf("keys与values的长度不同, len(keys)=3, len(values)=2"),
+		},
+		{
+			keys:   []int{1, 2, 3},
+			values: nil,
+			result: nil,
+			err:    fmt.Errorf("keys与values均不可为nil"),
+		},
+		{
+			keys:   nil,
+			values: []string{"1", "2"},
+			result: nil,
+			err:    fmt.Errorf("keys与values均不可为nil"),
+		},
+		{
+			keys:   nil,
+			values: nil,
+			result: nil,
+			err:    fmt.Errorf("keys与values均不可为nil"),
+		},
+		{
+			keys:   []int{1, 2, 3, 1, 1},
+			values: []string{"1", "2", "3", "10", "100"},
+			result: map[int]string{
+				1: "100",
+				2: "2",
+				3: "3",
+			},
+			err: nil,
+		},
+	} {
+		result, err := ToMap(c.keys, c.values)
+		assert.Equal(t, c.err, err)
+		assert.Equal(t, c.result, result)
+	}
+}
diff --git a/tuple/pair/pair.go b/tuple/pair/pair.go
new file mode 100644
index 0000000..b692d54
--- /dev/null
+++ b/tuple/pair/pair.go
@@ -0,0 +1,132 @@
+// Copyright 2021 ecodeclub
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pair
+
+import (
+	"fmt"
+)
+
+type Pair[K any, V any] struct {
+	Key   K
+	Value V
+}
+
+func (pair *Pair[K, V]) String() string {
+	return fmt.Sprintf("<%#v, %#v>", pair.Key, pair.Value)
+}
+
+// Split 方法将Key, Value作为返回参数传出。
+func (pair *Pair[K, V]) Split() (K, V) {
+	return pair.Key, pair.Value
+}
+
+func NewPair[K any, V any](
+	key K,
+	value V,
+) Pair[K, V] {
+	return Pair[K, V]{
+		Key:   key,
+		Value: value,
+	}
+}
+
+// NewPairs 需要传入两个长度相同并且均不为nil的数组 keys 和 values，
+// 设keys长度为n，返回一个长度为n的pair数组。
+// 保证：
+//
+//	返回的pair数组满足条件（设pair数组为p）:
+//		对于所有的 0 <= i < n
+//		p[i].Key == keys[i] 并且 p[i].Value == values[i]
+//
+//	如果传入的keys或者values为nil，会返回error
+//
+//	如果传入的keys长度与values长度不同，会返回error
+func NewPairs[K any, V any](
+	keys []K,
+	values []V,
+) ([]Pair[K, V], error) {
+	if keys == nil || values == nil {
+		return nil, fmt.Errorf("keys与values均不可为nil")
+	}
+	n := len(keys)
+	if n != len(values) {
+		return nil, fmt.Errorf("keys与values的长度不同, len(keys)=%d, len(values)=%d", n, len(values))
+	}
+	pairs := make([]Pair[K, V], n)
+	for i := 0; i < n; i++ {
+		pairs[i] = NewPair(keys[i], values[i])
+	}
+	return pairs, nil
+}
+
+// SplitPairs 需要传入一个[]Pair[K, V]，数组可以为nil。
+// 设pairs数组的长度为n，返回两个长度均为n的数组keys, values。
+// 如果pairs数组是nil, 则返回的keys与values也均为nil。
+func SplitPairs[K any, V any](pairs []Pair[K, V]) (keys []K, values []V) {
+	if pairs == nil {
+		return nil, nil
+	}
+	n := len(pairs)
+	keys = make([]K, n)
+	values = make([]V, n)
+	for i, pair := range pairs {
+		keys[i], values[i] = pair.Split()
+	}
+	return
+}
+
+// FlattenPairs 需要传入一个[]Pair[K, V]，数组可以为nil
+// 如果pairs数组为nil，则返回的flatPairs数组也为nil
+//
+//	设pairs数组长度为n，保证返回的flatPairs数组长度为2 * n且满足:
+//		对于所有的 0 <= i < n
+//		flatPairs[i * 2] == pairs[i].Key
+//		flatPairs[i * 2 + 1] == pairs[i].Value
+func FlattenPairs[K any, V any](pairs []Pair[K, V]) (flatPairs []any) {
+	if pairs == nil {
+		return nil
+	}
+	n := len(pairs)
+	flatPairs = make([]any, 0, n*2)
+	for _, pair := range pairs {
+		flatPairs = append(flatPairs, pair.Key, pair.Value)
+	}
+	return
+}
+
+// PackPairs 需要传入一个长度为2 * n的数组flatPairs，数组可以为nil。
+//
+//	函数将会返回一个长度为n的pairs数组，pairs满足
+//		对于所有的 0 <= i < n
+//		pairs[i].Key == flatPairs[i * 2]
+//		pairs[i].Value == flatPairs[i * 2 + 1]
+//	如果flatPairs为nil,则返回的pairs也为nil
+//
+//	入参flatPairs需要满足以下条件：
+//		对于所有的 0 <= i < n
+//		flatPairs[i * 2] 的类型为 K
+//		flatPairs[i * 2 + 1] 的类型为 V
+//	否则会panic
+func PackPairs[K any, V any](flatPairs []any) (pairs []Pair[K, V]) {
+	if flatPairs == nil {
+		return nil
+	}
+	n := len(flatPairs) / 2
+	pairs = make([]Pair[K, V], n)
+	for i := 0; i < n; i++ {
+		pairs[i] = NewPair(flatPairs[i*2].(K), flatPairs[i*2+1].(V))
+	}
+	return
+}
diff --git a/tuple/pair/pair_test.go b/tuple/pair/pair_test.go
new file mode 100644
index 0000000..233d08a
--- /dev/null
+++ b/tuple/pair/pair_test.go
@@ -0,0 +1,237 @@
+// Copyright 2021 ecodeclub
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pair_test
+
+import (
+	"fmt"
+	"sort"
+	"testing"
+
+	"github.com/ecodeclub/ekit/mapx"
+	"github.com/ecodeclub/ekit/tuple/pair"
+	"github.com/stretchr/testify/suite"
+)
+
+type testPairSuite struct{ suite.Suite }
+
+func (s *testPairSuite) TestString() {
+	{
+		p := pair.NewPair(100, "23333")
+		s.Assert().Equal("<100, \"23333\">", p.String())
+	}
+	{
+		p := pair.NewPair("testStruct", map[int]int{
+			11: 1,
+			22: 2,
+			33: 3,
+		})
+		s.Assert().Equal("<\"testStruct\", map[int]int{11:1, 22:2, 33:3}>", p.String())
+	}
+}
+
+func (s *testPairSuite) TestNewPairs() {
+	type caseType struct {
+		// input
+		keys   []int
+		values []string
+		// expected
+		pairs []pair.Pair[int, string]
+		err   error
+	}
+	for _, c := range []caseType{
+		{
+			keys:   []int{1, 2, 3, 4, 5},
+			values: []string{"1", "2", "3", "4", "5"},
+			pairs: []pair.Pair[int, string]{
+				pair.NewPair(1, "1"),
+				pair.NewPair(2, "2"),
+				pair.NewPair(3, "3"),
+				pair.NewPair(4, "4"),
+				pair.NewPair(5, "5"),
+			},
+			err: nil,
+		},
+		{
+			keys:   nil,
+			values: []string{"1"},
+			pairs:  nil,
+			err:    fmt.Errorf("keys与values均不可为nil"),
+		},
+		{
+			keys:   []int{1},
+			values: nil,
+			pairs:  nil,
+			err:    fmt.Errorf("keys与values均不可为nil"),
+		},
+		{
+			keys:   nil,
+			values: nil,
+			pairs:  nil,
+			err:    fmt.Errorf("keys与values均不可为nil"),
+		},
+		{
+			keys:   []int{1, 2},
+			values: []string{"1"},
+			pairs:  nil,
+			err:    fmt.Errorf("keys与values的长度不同, len(keys)=2, len(values)=1"),
+		},
+	} {
+		pairs, err := pair.NewPairs(c.keys, c.values)
+		s.Assert().Equal(c.err, err)
+		s.Assert().EqualValues(c.pairs, pairs)
+	}
+}
+
+func (s *testPairSuite) TestSplitPairs() {
+	type caseType struct {
+		// input
+		pairs []pair.Pair[int, string]
+		// expected
+		keys   []int
+		values []string
+	}
+	for _, c := range []caseType{
+		{
+			pairs: []pair.Pair[int, string]{
+				pair.NewPair(1, "1"),
+				pair.NewPair(2, "2"),
+				pair.NewPair(3, "3"),
+				pair.NewPair(4, "4"),
+				pair.NewPair(5, "5"),
+			},
+			keys:   []int{1, 2, 3, 4, 5},
+			values: []string{"1", "2", "3", "4", "5"},
+		},
+		{
+			pairs: nil,
+
+			keys:   nil,
+			values: nil,
+		},
+		{
+			pairs:  []pair.Pair[int, string]{},
+			keys:   []int{},
+			values: []string{},
+		},
+	} {
+		keys, values := pair.SplitPairs(c.pairs)
+		if c.pairs == nil {
+			s.Assert().Nil(keys)
+			s.Assert().Nil(values)
+		} else {
+			s.Assert().Len(keys, len(c.pairs))
+			s.Assert().Len(values, len(c.pairs))
+			for i, pair := range c.pairs {
+				s.Assert().Equal(pair.Key, keys[i])
+				s.Assert().Equal(pair.Value, values[i])
+			}
+		}
+	}
+}
+
+func (s *testPairSuite) TestFlattenPairs() {
+	type caseType struct {
+		pairs      []pair.Pair[int, string]
+		flattPairs []any
+	}
+
+	for _, c := range []caseType{
+		{
+			pairs: []pair.Pair[int, string]{
+				pair.NewPair(1, "1"),
+				pair.NewPair(2, "2"),
+				pair.NewPair(3, "3"),
+				pair.NewPair(4, "4"),
+				pair.NewPair(5, "5"),
+			},
+			flattPairs: []any{1, "1", 2, "2", 3, "3", 4, "4", 5, "5"},
+		},
+		{
+			pairs:      nil,
+			flattPairs: nil,
+		},
+		{
+			pairs:      []pair.Pair[int, string]{},
+			flattPairs: []any{},
+		},
+	} {
+		flatPairs := pair.FlattenPairs(c.pairs)
+		s.Assert().EqualValues(c.flattPairs, flatPairs)
+	}
+}
+
+func (s *testPairSuite) TestPackPairs() {
+	type caseType struct {
+		flattPairs []any
+		pairs      []pair.Pair[int, string]
+	}
+
+	for _, c := range []caseType{
+		{
+			flattPairs: []any{1, "1", 2, "2", 3, "3", 4, "4", 5, "5"},
+			pairs: []pair.Pair[int, string]{
+				pair.NewPair(1, "1"),
+				pair.NewPair(2, "2"),
+				pair.NewPair(3, "3"),
+				pair.NewPair(4, "4"),
+				pair.NewPair(5, "5"),
+			},
+		},
+		{
+			flattPairs: nil,
+			pairs:      nil,
+		},
+		{
+			flattPairs: []any{},
+			pairs:      []pair.Pair[int, string]{},
+		},
+	} {
+		pairs := pair.PackPairs[int, string](c.flattPairs)
+		s.Assert().EqualValues(c.pairs, pairs)
+	}
+}
+
+func (s *testPairSuite) TestMapPairMapping() {
+	// map to pairs
+	expectedMap := map[int]string{
+		1: "1",
+		2: "2",
+		3: "3",
+	}
+	expectedPairs := []pair.Pair[int, string]{
+		pair.NewPair(1, "1"),
+		pair.NewPair(2, "2"),
+		pair.NewPair(3, "3"),
+	}
+
+	// 可以用这种方式实现map到[]Pair的映射
+	pairs, err := pair.NewPairs(mapx.KeysValues(expectedMap))
+	s.Assert().Nil(err)
+	sort.Slice(pairs, func(i, j int) bool {
+		return pairs[i].Key < pairs[j].Key
+	})
+	s.Assert().EqualValues(expectedPairs, pairs)
+
+	// 可以用这种方式实现[]Pair到map的映射
+	mp, err := mapx.ToMap(pair.SplitPairs(expectedPairs))
+	s.Assert().Nil(err)
+	for k, v := range mp {
+		s.Assert().Equal(expectedMap[k], v)
+	}
+}
+
+func TestPair(t *testing.T) {
+	suite.Run(t, new(testPairSuite))
+}