feat(Go-Tool)：创建ArrayUtils测试类，修改对应方法

readme.md

@@ -15,3 +15,5 @@
 2020/4/30 ：添加FileUtil.go、FileReadTool.go单测类代码，修改相应bug-----IniTool.go依赖获取不到，注释掉代码
 
 2020/4/30 : 创建ArrayUtil.go，添加数组对应方法
+
+2020/5/6 : 创建ArrayUtils测试类，修改对应方法

test/array/ArrayUtil_test.go

@@ -7,51 +7,151 @@
 package array
 
 import (
+	"Go-Tool/util/array"
+	"encoding/json"
 	"fmt"
 	"testing"
 )
 
 type MM struct {
-	a int
+	A int
-	b string
+	B string
-	n NN
+	N NN
 }
 
 type NN struct {
-	a int
+	A int
-	b float64
+	B float64
 }
 
-func TestArray(t *testing.T) {
+var (
-	n := NN{
+	mm  []interface{}
-		a: 12,
+	mm1 []interface{}
-		b: 2.22,
+	mm2 []interface{}
-	}
+	nn  []interface{}
-	n1 := NN{
+	nn1 []interface{}
-		a: 12,
+)
-		b: 2.22,
+
-	}
+func TestBool(t *testing.T) {
-	n2 := NN{
+	fmt.Print("\n\nContains\n\n")
-		a: 12,
+	fmt.Println(array.Contains(mm, mm))
-		b: 2.212,
+	fmt.Println(array.Contains(mm, mm1))
-	}
+	fmt.Println(array.Contains(mm, MM{
-	x := MM{
+		A: 1,
-		a: 1,
+		B: "2",
-		b: "1",
+	}))
-		n: n,
+	fmt.Print("\n\nNotContains\n\n")
-	}
+	fmt.Println(array.NotContains(mm, mm))
-	y := MM{
+	fmt.Println(array.NotContains(mm, mm1))
-		a: 1,
+	fmt.Println(array.NotContains(mm, MM{
-		b: "1",
+		A: 1,
-		n: n1,
+		B: "2",
-	}
+	}))
-	z := MM{
+	fmt.Print("\n\nIsSameList\n\n")
-		a: 1,
+	fmt.Println(array.IsSameList(mm, mm))
-		b: "1",
+	fmt.Println(array.IsSameList(mm, nn1))
-		n: n2,
+	fmt.Println(array.IsSameList(mm, mm2))
+	fmt.Println(array.IsSameList(mm, nn))
+
+	fmt.Print("\n\nIsSubSet\n\n")
+	fmt.Println(array.IsSubSet(mm, mm))
+	fmt.Println(array.IsSubSet(mm, mm1))
+	fmt.Println(array.IsSubSet(mm, mm2))
+	fmt.Println(array.IsSubSet(mm, nn))
+
 }
 
-	fmt.Print(x == y)
+func TestJoin(t *testing.T) {
-	fmt.Print("\n\n测试一下")
+	fmt.Print("\n\nmm-nn\n\n")
-	fmt.Print(x == z)
+	intersection(mm, nn)
+	fmt.Print("\n\nmm-mm\n\n")
+	intersection(mm, mm)
+	fmt.Print("\n\nmm-mm1\n\n")
+	intersection(mm, mm1)
+	fmt.Print("\n\nmm-mm2\n\n")
+	intersection(mm, mm2)
+
+	fmt.Print("\n\ndiff\n\n")
+	diffSet(mm, nn)
+	fmt.Print("\n\n\n\n")
+	diffSet(mm, mm)
+	fmt.Print("\n\n\n\n")
+	diffSet(mm, mm1)
+	fmt.Print("\n\n\n\n")
+	diffSet(mm, mm2)
+
+	fmt.Print("\n\nunion\n\n")
+	union(mm, nn)
+	fmt.Print("\n\n\n\n")
+	union(mm, mm)
+	fmt.Print("\n\n\n\n")
+	union(mm, mm1)
+	fmt.Print("\n\n\n\n")
+	union(mm, mm2)
+}
+
+func intersection(mm, nn []interface{}) {
+	i1 := array.Intersection(mm, nn)
+	for _, row := range i1 {
+		b, err := json.Marshal(row)
+		fmt.Println(err)
+		fmt.Print(string(b))
+	}
+}
+
+func diffSet(mm, nn []interface{}) {
+	i1 := array.DiffSet(mm, nn)
+	for _, row := range i1 {
+		b, _ := json.Marshal(row)
+		fmt.Print(string(b))
+	}
+}
+
+func union(mm, nn []interface{}) {
+	i1 := array.Union(mm, nn)
+	for _, row := range i1 {
+		b, _ := json.Marshal(row)
+		fmt.Print(string(b))
+	}
+}
+
+func init() {
+	mm = make([]interface{}, 0)
+	mm1 = make([]interface{}, 0)
+	nn = make([]interface{}, 0)
+	nn1 = make([]interface{}, 0)
+	mm = append(mm, MM{
+		A: 1,
+		B: "1",
+	})
+	mm = append(mm, MM{
+		A: 1,
+		B: "2",
+	})
+	mm1 = append(mm1, MM{
+		A: 1,
+		B: "2",
+	})
+	mm2 = append(mm2, MM{
+		A: 1,
+		B: "2",
+	})
+	mm2 = append(mm2, MM{
+		A: 1,
+		B: "3",
+	})
+
+	nn = append(nn, NN{
+		B: 1.2,
+		A: 1,
+	})
+	nn = append(nn, NN{
+		B: 2.9,
+		A: 20,
+	})
+
+	nn1 = append(nn1, NN{
+		A: 30,
+		B: 2.2,
+	})
 }

util/array/ArrayUtil.go

@@ -12,20 +12,12 @@ package array
 
 import "reflect"
 
-var (
-	invalid = [7]reflect.Kind{reflect.UnsafePointer, reflect.Map, reflect.Slice,
-		reflect.Interface, reflect.Func, reflect.Chan, reflect.Ptr}
-)
-
 /*
  * 返回数组中是否包含对应元素的结果
  */
 func Contains(list []interface{}, ele interface{}) bool {
-	if typeInvalid(reflect.TypeOf(ele).Kind()) {
-		panic("该类型不支持比较")
-	}
 	for _, row := range list {
-		if row == ele {
+		if reflect.DeepEqual(row, ele) {
 			return true
 		}
 	}
@@ -43,19 +35,12 @@ func NotContains(list []interface{}, ele interface{}) bool {
  * 返回两个数组的所有元素是否相等的结果
  */
 func IsSameList(list, eList []interface{}) bool {
-	same := 0
 	if len(list) != len(eList) {
 		return false
 	}
-	for _, l := range list {
+
-		for _, r := range eList {
+	return reflect.DeepEqual(list, eList)
-			if l == r {
+
-				same++
-				break
-			}
-		}
-	}
-	return same == len(list)
 }
 
 /*
@@ -113,19 +98,9 @@ func Union(aList, bList []interface{}) []interface{} {
 		}
 	}
 	for _, row := range bList {
-		if NotContains(bList, row) {
+		if NotContains(result, row) {
 			result = append(result, row)
 		}
 	}
 	return result
 }
-
-func typeInvalid(k reflect.Kind) bool {
-	for _, row := range invalid {
-		if k == row {
-			return true
-		}
-	}
-
-	return false
-}