feat(Go-StudyExample):2021/02/23:新增linq包使用示例

example/linqUse/DataInit.go

@@ -0,0 +1,127 @@
+/*
+ *  @Author : huangzj
+ *  @Time : 2020/11/12 14:04
+ *  @Description：
+ */
+
+package linqUse
+
+import "time"
+
+type Book struct {
+	Name        string
+	Author      string
+	Money       float64
+	WordsNum    int
+	PublishTime time.Time
+}
+
+func MakeBook() []Book {
+	bookList := make([]Book, 0)
+	bookList = append(bookList, Book{
+		Name:        "Go语言",
+		Author:      "Go",
+		Money:       100,
+		WordsNum:    1000,
+		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "Effective Java",
+		Author:      "Java",
+		Money:       78,
+		WordsNum:    9000,
+		PublishTime: time.Date(2020, 2, 15, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "Java语言",
+		Author:      "Java",
+		Money:       50,
+		WordsNum:    3000,
+		PublishTime: time.Date(2020, 2, 1, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "Lua语言",
+		Author:      "Lua",
+		Money:       75,
+		WordsNum:    45000,
+		PublishTime: time.Date(2020, 1, 10, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "React语言",
+		Author:      "React",
+		Money:       99,
+		WordsNum:    14500,
+		PublishTime: time.Date(2020, 7, 1, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "Red语言",
+		Author:      "Red",
+		Money:       28,
+		WordsNum:    880,
+		PublishTime: time.Date(2019, 4, 1, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "JavaScript语言",
+		Author:      "JavaScript",
+		Money:       81,
+		WordsNum:    3776,
+		PublishTime: time.Date(2019, 5, 17, 10, 0, 0, 0, time.Local),
+	})
+	return bookList
+}
+
+func MakeBook1() []Book {
+	bookList := make([]Book, 0)
+	bookList = append(bookList, Book{
+		Name:        "Go语言",
+		Author:      "Go",
+		Money:       100,
+		WordsNum:    1000,
+		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "Effective Java",
+		Author:      "Java",
+		Money:       78,
+		WordsNum:    9000,
+		PublishTime: time.Date(2020, 2, 15, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "Go语言(第二版)",
+		Author:      "Go",
+		Money:       50,
+		WordsNum:    3000,
+		PublishTime: time.Date(2020, 2, 1, 10, 0, 0, 0, time.Local),
+	})
+	return bookList
+}
+func MakeBook2() []Book {
+	bookList := make([]Book, 0)
+	bookList = append(bookList, Book{
+		Name:        "Go语言",
+		Author:      "Go",
+		Money:       100,
+		WordsNum:    1000,
+		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
+	})
+	return bookList
+}
+
+func MakeBook3() []Book {
+	bookList := make([]Book, 0)
+	bookList = append(bookList, Book{
+		Name:        "Go语言",
+		Author:      "Go",
+		Money:       100,
+		WordsNum:    1000,
+		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
+	})
+	bookList = append(bookList, Book{
+		Name:        "Go语言(第三版)",
+		Author:      "Go",
+		Money:       50,
+		WordsNum:    3000,
+		PublishTime: time.Date(2020, 2, 1, 10, 0, 0, 0, time.Local),
+	})
+	return bookList
+}

example/linqUse/DataInit2.go

@@ -0,0 +1,57 @@
+/*
+ *  @Author : huangzj
+ *  @Time : 2020/11/24 16:17
+ *  @Description：
+ */
+
+package linqUse
+
+type Person struct {
+	Name string //拥有者的名字
+}
+
+type Pet struct {
+	Name      string //动物的名字
+	OwnerName string //拥有者的名字
+}
+
+type Man struct {
+	Name string //拥有者的名字
+	Pets []Pets //宠物们
+}
+
+type Pets struct {
+	Name string //动物的名字
+}
+
+func MakeInnerData() []Man {
+	man := make([]Man, 0)
+	man = append(man, Man{
+		Name: "康康",
+		Pets: []Pets{{Name: "康康的狗"}, {Name: "康康的猫"}},
+	})
+	man = append(man, Man{
+		Name: "老施",
+		Pets: []Pets{{Name: "老施的🐟"}, {Name: "老施的鸟"}},
+	})
+	man = append(man, Man{
+		Name: "小明",
+		Pets: []Pets{{Name: "小明的🐖"}, {Name: "小明的狗"}},
+	})
+
+	return man
+}
+
+func MakeJoinData() ([]Person, []Pet) {
+	kangkang := Person{Name: "爱吃合合乐的康康"}
+	laoshi := Person{Name: "老施"}
+	xiaoming := Person{Name: "不要催-小明"}
+	expect := Person{Name: "我是没有宠物的人"}
+
+	dog := Pet{Name: "康康的狗", OwnerName: kangkang.Name}
+	cat := Pet{Name: "康康的猫", OwnerName: kangkang.Name}
+	fish := Pet{Name: "老施的🐟", OwnerName: laoshi.Name}
+	pig := Pet{Name: "小明的🐖", OwnerName: xiaoming.Name}
+
+	return []Person{kangkang, laoshi, xiaoming, expect}, []Pet{dog, cat, fish, pig}
+}

example/linqUse/FuncSet.go

@@ -0,0 +1,41 @@
+/*
+ *  @Author : huangzj
+ *  @Time : 2020/11/12 14:43
+ *  @Description：测试方法集合
+ */
+
+package linqUse
+
+import "time"
+
+//书籍发布时间是否早于--.--.--
+var PublishTimeBeforeFunc = func(thisBook interface{}) bool {
+	if thisBook.(Book).PublishTime.Before(time.Date(2019, 1, 1, 0, 0, 0, 0, time.Local)) {
+		return true
+	}
+	return false
+}
+
+//书籍发布时间是否晚于--.--.--
+var PublishTimeAfterFunc = func(thisBook interface{}) bool {
+	if thisBook.(Book).PublishTime.After(time.Date(2018, 1, 1, 0, 0, 0, 0, time.Local)) {
+		return true
+	}
+	return false
+}
+
+//书籍发布时间是否晚于--.--.--
+var PublishTimeAfterFunc2 = func(thisBook interface{}) bool {
+	if thisBook.(Book).PublishTime.After(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local)) {
+		return true
+	}
+	return false
+}
+
+//自定义聚合操作方法
+var AggregateFunc = func(first interface{}, second interface{}) interface{} {
+	if first.(Book).PublishTime.Before(second.(Book).PublishTime) {
+		return first
+	}
+	return second
+}

example/linqUse/LinqUse_test.go

@@ -0,0 +1,531 @@
+/*
+ *  @Author : huangzj
+ *  @Time : 2020/11/12 10:52
+ *  @Description：这边是linq包的使用操作，为之后的使用做一些示例
+ *  包引用命令： go get github.com/ahmetb/go-linq
+ *  示例参考地址：https://godoc.org/github.com/ahmetb/go-linq#
+ *  在Idea中对应方法名上使用 Shift+F1 组合键操作可以直接跳转到方法对应的地址
+ */
+
+package linqUse
+
+import (
+	"Go-Tool/util/timed"
+	"fmt"
+	"github.com/ahmetb/go-linq"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func Test(t *testing.T) {
+
+	Aggregate() //自定义聚合操作
+
+	All() //判断数组的所有元素是否都满足条件
+
+	Where() //根据条件查询对应的元素
+
+	AnyWith() //判断数组是否有任意个元素满足条件
+
+	Calculate() //这个方法只能计算数值类型
+
+	Combine() //组合两个数组的两种方式
+
+	Contains() //包含
+
+	FirstAndLast() //第一个和最后一个
+
+	Distinct() //返回数组中唯一的元素
+
+	Except() //返回第一个序列没有出现在第二个序列中的成员
+
+	GroupBy() //按照对应规则进行分组
+
+	Intersect() //产生两个数组的交集
+
+	OrderBy() //排序
+
+	Skip() //略过指定条件的元素
+
+	Count() //计算数组总长度
+
+	Result() //对结果集进行操作
+
+	Take() //获取对应数量的元素，一般多用在排序后前几个的元素
+
+	Select() //筛选结构体中对应的元素
+
+	SelectMany() //对多维数组进行合并或者其他处理 对结构体中的数组进行处理(与结构体结合操作)
+
+	Join() //对两个有关联的数据进行处理
+
+}
+
+func Where() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	fmt.Println()
+	fmt.Println()
+	query.WhereT(func(book Book) bool {
+		return book.Money > float64(70)
+	}).ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
+	})
+}
+
+func Take() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	query.OrderByDescendingT(func(book Book) string {
+		return book.Author
+	}).Take(3).ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
+	})
+
+	fmt.Println()
+	fmt.Println()
+
+	//超出对应数量的元素会不会报错（输出所有的元素）
+	query.OrderByDescendingT(func(book Book) string {
+		return book.Author
+	}).Take(100).ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
+	})
+
+	fmt.Println()
+	fmt.Println()
+	//负数会发生什么情况(直接返回，不做操作)
+	query.OrderByDescendingT(func(book Book) string {
+		return book.Author
+	}).Take(-2).ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
+	})
+
+	//TakeWhile系列的方法，虽然能够根据条件进行查询，但是有一个弊端就是一旦查询到的结果和条件不符合则直接返回，也就是说后面满足条件的元素不会再被做筛选
+	//那么比如这边的这个大于的操作，就需要对整个数组进行排序之后然后进行筛选，如果不希望排序，则用原生的for循环可能会更好
+	fmt.Println()
+	fmt.Println()
+	query.TakeWhileT(func(book Book) bool {
+		return book.Money > float64(70)
+	}).ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
+	})
+}
+
+func Result() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+
+	bookMap := make(map[string]string, 0)
+	query.SelectT(func(book Book) linq.KeyValue {
+		return linq.KeyValue{
+			Key:   book.Author,
+			Value: book.Name,
+		}
+	}).ToMap(&bookMap)
+
+	for key, value := range bookMap {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", key, value))
+	}
+
+	fmt.Println()
+	fmt.Println()
+
+	//如果key相同的话，前面的元素会被覆盖掉（只会保留最后一个）
+	bookList1 := MakeBook1()
+	query1 := linq.From(bookList1)
+	bookMap1 := make(map[string]string, 0)
+	query1.SelectT(func(book Book) linq.KeyValue {
+		return linq.KeyValue{
+			Key:   book.Author,
+			Value: book.Name,
+		}
+	}).ToMap(&bookMap1)
+
+	for key, value := range bookMap1 {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", key, value))
+	}
+
+	fmt.Println()
+	fmt.Println()
+	bookList2 := MakeBook()
+	query2 := linq.From(bookList2)
+
+	bookMap2 := make(map[string]Book, 0)
+	query2.ToMapByT(&bookMap2,
+		//这个方法决定key的字段是什么
+		func(book Book) string {
+			return book.Author
+		}, //这个方法决定value的字段是什么
+		func(book Book) Book {
+			return book
+		})
+
+	for key, value := range bookMap2 {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", key, value.Name))
+	}
+
+	fmt.Println()
+	fmt.Println()
+	bookListResult := make([]Book, 0)
+	linq.From(MakeBook()).OrderByDescendingT(func(book Book) string {
+		return book.Author
+	}).ToSlice(&bookListResult)
+	for _, value := range bookListResult {
+		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", value.Author, value.Name))
+	}
+}
+
+func Count() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	fmt.Println(fmt.Sprintf("数组中发布时间早于2019-1-1的书有%d本", query.CountWithT(PublishTimeBeforeFunc)))
+	fmt.Println(fmt.Sprintf("数组中发布时间晚于2018-1-1的书有%d本", query.CountWithT(PublishTimeAfterFunc)))
+}
+
+func Skip() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+
+	fmt.Println(fmt.Sprintf("跳过三个元素，返回的数组中包含%d个元素", len(query.Skip(3).Results())))
+	fmt.Println(fmt.Sprintf("跳过发布时间在2018.1.1之后的元素，返回的数组中包含%d个元素", query.SkipWhile(PublishTimeAfterFunc).Count()))
+}
+
+func SelectMany() {
+	input := [][]int{{1, 2, 3}, {4, 5, 6, 7}}
+
+	//二位数组进行合并
+	linq.From(input).SelectManyT(
+		func(i []int) linq.Query {
+			return linq.From(i)
+		},
+	).ForEachT(func(num int) {
+		fmt.Println(num)
+	})
+
+	fmt.Println()
+	fmt.Println()
+
+	//三维数组进行合并
+	input1 := [][][]int{{{1, 2, 3}}, {{4, 5, 6, 7}, {8, 9, 10}}}
+	linq.From(input1).SelectManyT(
+		func(i [][]int) linq.Query {
+			return linq.From(i)
+		},
+	).SelectManyT(
+		func(i []int) linq.Query {
+			return linq.From(i)
+		},
+	).ForEachT(func(num int) {
+		fmt.Print(num)
+		fmt.Print(" ")
+	})
+
+	//SelectMany的主要作用是,结构体中包含数组元素，可以把数组元素取出来和结构体做相应的操作
+	//如果是结构体中有多个数组的操作，可以把对应的多个数组放到一个新定义的结构体数组中
+	fmt.Println()
+	men := MakeInnerData()
+	linq.From(men).
+		//第一个方法筛选出结构体对应的数组
+		SelectManyByT(func(man Man) linq.Query {
+			return linq.From(man.Pets)
+		},
+			//第二个方法这边可以拿到数组中元素对应的结构体的数据.
+			func(pet Pets, man Man) map[string]Pets {
+				return map[string]Pets{
+					man.Name: pet,
+				}
+			}).ForEachT(func(petWithMan map[string]Pets) {
+		for key, value := range petWithMan {
+			fmt.Println(fmt.Sprintf("%v拥有一只宠物，它的名字叫做%v", key, value.Name))
+		}
+	})
+
+}
+
+func Select() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+
+	//筛选出结构体对应的元素
+	query.SelectT(func(book Book) string {
+		return book.Name
+	}).ForEachT(func(bookName string) {
+		fmt.Println(fmt.Sprintf("书名%v", bookName))
+	})
+
+	fmt.Println()
+	fmt.Println()
+
+	//根据下标进行返回，如果是跟下标有关的，则可以通过这个方法进行组合然后返回.
+	query.SelectIndexedT(func(index int, book Book) []string {
+		return []string{strconv.Itoa(index + 1), book.Name}
+	}).ForEachT(func(book []string) {
+		fmt.Println(fmt.Sprintf("第%v本书,书名%v", book[0], book[1]))
+	})
+}
+
+//OrderBy可以按照对应的规则进行排序，可以实现多重排序，需要注意的就是OrderBy是从到达，orderByDescending是从大到小
+func OrderBy() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	query = query.OrderByDescendingT(func(book Book) string {
+		return book.Name
+	}).ThenByDescendingT(func(book Book) string {
+		return book.Author
+	}).ThenByDescendingT(func(book Book) float64 {
+		return book.Money
+	}).Query
+
+	query.ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+	})
+
+	fmt.Println()
+	fmt.Println()
+
+	//reverse: 把结果逆序
+	query.Reverse().ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+	})
+}
+
+func Join() {
+	//任务和动物有关联，直接找到对应的关系，没有对应关系的数据不会处理，正常情况下应该用更单一的数据来做关联
+	persons, pets := MakeJoinData()
+	query1 := linq.From(persons)
+	query2 := linq.From(pets)
+	query1.JoinT(query2,
+		func(person Person) string {
+			return person.Name
+		},
+		func(pet Pet) string {
+			return pet.OwnerName
+		},
+		func(person Person, pet Pet) map[string]Pet {
+			petMap := make(map[string]Pet)
+			petMap[person.Name] = pet
+			return petMap
+		},
+	).ForEachT(func(petMap map[string]Pet) {
+		for key, value := range petMap {
+			fmt.Println(fmt.Sprintf("%v拥有一只宠物，它的名字叫做:%v", key, value.Name))
+		}
+	})
+}
+
+func Intersect() {
+	bookList1 := MakeBook1()
+	query1 := linq.From(bookList1)
+	bookList2 := MakeBook2()
+	query2 := linq.From(bookList2)
+
+	fmt.Println("输出对应的书籍元素，按照结构体判断交集")
+	query3 := query1.Intersect(query2)
+	query3.ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+	})
+
+	fmt.Println()
+	fmt.Println("输出对应的书籍元素，按照元素判断交集")
+	query3 = query1.IntersectByT(query2, func(book Book) string {
+		return book.Author
+	})
+	query3.ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+	})
+
+	//这边计算是按照结构体的一个元素进行比较。事实证明无论是否按照结构体的元素筛选，返回的都是完全相同的元素
+	fmt.Println()
+	fmt.Println("输出对应的书籍元素，按照元素判断交集2")
+	bookList1 = MakeBook1()
+	query1 = linq.From(bookList1)
+	bookList3 := MakeBook3()
+	query2 = linq.From(bookList3)
+	query3 = query2.IntersectByT(query1, func(book Book) string {
+		return book.Author
+	})
+	query3.ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+	})
+
+	fmt.Println()
+	fmt.Println("判断是否会不重复的处理")
+	query1 = linq.From([]int{1, 2, 3, 4, 5, 3})
+	query2 = linq.From([]int{1, 3, 3, 78, 99, 0, 111})
+	query3 = query2.IntersectByT(query1, func(i int) int {
+		return i
+	})
+	fmt.Println(query3.Results())
+}
+
+func GroupBy() {
+	bookList1 := MakeBook1()
+	query := linq.From(bookList1)
+
+	fmt.Println("输出对应书名和作者")
+	//第一个func是分组的依据，第二个func是分组后返回的元素.
+	query = query.GroupByT(func(book Book) string {
+		return book.Author
+	}, func(book Book) Book {
+		return book
+	})
+
+	query.ForEachT(func(bookGroup linq.Group) {
+		fmt.Println(fmt.Sprintf("作者是%v", bookGroup.Key))
+		for _, item := range bookGroup.Group {
+			fmt.Println(fmt.Sprintf("书名%v,作者%v", item.(Book).Name, item.(Book).Author))
+			fmt.Println()
+		}
+
+	})
+	fmt.Println()
+	fmt.Println("输出对应书名")
+
+	bookList1 = MakeBook1()
+	query = linq.From(bookList1)
+	var nameGroups []linq.Group
+	query.GroupByT(
+		func(book Book) string { return book.Author },
+		func(book Book) string { return book.Name },
+	).ToSlice(&nameGroups)
+
+	for _, item := range nameGroups {
+		fmt.Println(fmt.Sprintf("作者是%v", item.Key))
+		for _, row := range item.Group {
+			fmt.Println(fmt.Sprintf("书名%v", row))
+		}
+	}
+}
+
+func Except() {
+	bookList1 := MakeBook1()
+	query1 := linq.From(bookList1)
+	bookList2 := MakeBook2()
+	query2 := linq.From(bookList2)
+
+	fmt.Println("输出对应书名和作者")
+	//判断结构结构体本身是否相等
+	query1.Except(query2).
+		ForEachT(func(book Book) {
+			fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+		})
+
+	fmt.Println()
+	fmt.Println("输出对应书名和作者")
+	//判断结构体的某个字段是否出现
+	query1.ExceptByT(query2, func(book Book) string {
+		return book.Author
+	}).ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+	})
+}
+
+func Distinct() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	query = query.Append(Book{
+		Name:        "Go语言",
+		Author:      "Go",
+		Money:       100,
+		WordsNum:    1000,
+		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
+	})
+	bookList1 := make([]Book, 0)
+	query.ToSlice(&bookList1)
+	fmt.Println(fmt.Sprintf("筛选之前query中总共有%d个数据", query.Count()))
+	//这边的distinct如果是结构体，则判断的是结构体的所有值，如果是指针则判断的是指针地址.
+	query = query.Distinct()
+	fmt.Println(fmt.Sprintf("筛选之后query中总共有%d个数据", query.Count()))
+
+	fmt.Println()
+	fmt.Println("输出对应书名和作者")
+	query = query.Append(Book{
+		Name:        "Go语言(第二版)",
+		Author:      "Go",
+		Money:       100,
+		WordsNum:    1000,
+		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
+	})
+	//根据对应的规则来判断是否相同 -- 如果对应的字段一样，只会保留第一个找到的，后面的会被清除掉
+	query.DistinctByT(func(book Book) string {
+		return book.Author
+	}).ForEachT(func(book Book) {
+		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
+	})
+}
+
+func Combine() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	query1 := query.Concat(query) //不会排除重复项
+	query2 := query.Union(query)  //会排除重复项
+	fmt.Println(fmt.Sprintf("不会排除重复项的方法返回的元素个数是%d", len(query1.Results())))
+	fmt.Println(fmt.Sprintf("会排除重复项的方法返回的元素个数是%d", len(query2.Results())))
+	query1 = query1.Append(Book{Name: "Last One"})   //加在原来的Query的最后面
+	query2 = query2.Prepend(Book{Name: "First One"}) //加在原来的Query的第一个
+	fmt.Println(fmt.Sprintf("最后一个元素是%v", query1.Last()))
+	fmt.Println(fmt.Sprintf("第一个元素是%v", query2.First()))
+}
+
+func FirstAndLast() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	fmt.Println(fmt.Sprintf("数组第一本书书名叫:%s", query.First().(Book).Name))
+	fmt.Println(fmt.Sprintf("数组第一本书发布时间在2018年1月1号之后的书书名叫:%s", query.FirstWith(PublishTimeAfterFunc).(Book).Name))
+
+	fmt.Println(fmt.Sprintf("数组最后一本书书名叫:%s", query.Last().(Book).Name))
+	fmt.Println(fmt.Sprintf("数组最后一本书发布时间在2018年1月1号之后的书书名叫:%s", query.LastWith(PublishTimeAfterFunc).(Book).Name))
+}
+
+func Contains() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	//这边需要注意是的是如果要判断两个元素是否相等，在go里面不能使用元素的地址
+	// 所以这边加到query里面的必须不能是元素的地址，否则没办法比较结构体本身，而是比较结构体的地址
+	fmt.Println(fmt.Sprintf("判断当前数组是否包含相同的元素,判断的是所有的值，而不是地址，结果是%v", query.Contains(Book{
+		Name:        "Go语言",
+		Author:      "Go",
+		Money:       100,
+		WordsNum:    1000,
+		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
+	})))
+}
+
+func Calculate() {
+	query := linq.From([]int{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	fmt.Println(fmt.Sprintf("平均值为：%f", query.Average()))
+	fmt.Println(fmt.Sprintf("最大的值为%d", query.Max()))
+	fmt.Println(fmt.Sprintf("最小的值为%d", query.Min()))
+}
+
+func AnyWith() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	result := query.AnyWith(PublishTimeBeforeFunc) //判断是否有任意个元素满足条件
+	fmt.Println(fmt.Sprintf("是否有任意书的发表时间早于2020年1月1号，答案是%v", result))
+
+	result = query.AnyWith(PublishTimeAfterFunc2) //判断是否有任意个元素满足条件
+	fmt.Println(fmt.Sprintf("是否有任意书的发表时间晚于2021年1月1号，答案是%v", result))
+}
+
+func All() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	result := query.All(PublishTimeBeforeFunc)
+	fmt.Println(fmt.Sprintf("是否所有的书的发表时间都早于2020年1月1号，答案是%v", result))
+
+	result = query.All(PublishTimeAfterFunc)
+	fmt.Println(fmt.Sprintf("是否所有的书的发表时间都晚于2018年1月1号，答案是%v", result))
+}
+
+func Aggregate() {
+	bookList := MakeBook()
+	query := linq.From(bookList)
+	// 这边的聚合操作其实就是【自定义对应的比较方法】。
+	// 根据注释，第一次拿到的是数组的第一个元素，然后跟第二个元素进行比较，如果第二个元素符合条件则【替换第一个元素】，否则当前聚合操作还是持有第一个元素。
+	// 以此类推后面的元素
+	result := query.Aggregate(AggregateFunc).(Book)
+	fmt.Println(fmt.Sprintf("聚合操作查询出的结果是【%s】这本书，它的发布时间最早为：%v", result.Name, timed.GetTimeDefaultFormatString(result.PublishTime.Unix())))
+}

readme.md

@@ -55,6 +55,8 @@ json与struct之间转换处理工具使用示例
 
 2021/02/09:新增merge源码阅读和单测代码
 
+2021/02/23:新增linq包使用示例
+
 # mod vendor模式加载包
 通过go mod的方式加载的github上面的包会有报红的问题，但是包本身是可以运行的，这样就是会有一个问题，如果你想要点击去看方法的内容，没办法做到