golang将切片或数组根据某个字段进行分组操作_Golang

golang将切片或数组根据某个字段进行分组操作

2021-03-14 01:01思维的深度 Golang

这篇文章主要介绍了golang将切片或数组根据某个字段进行分组操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

我就废话不多说了，大家还是直接看代码吧~

									package main

									import (

									 "fmt"

									 "sort"

									)

									type Person struct {

									 Name string

									 Age int

									}

									func main() {

									 p1 := Person{"Tom",20}

									 p2 := Person{"Lily",21}

									 p3 := Person{"Linda",23}

									 p4 := Person{"Jass",25}

									 p5 := Person{"Tonny",20}

									 p6 := Person{"Pite",25}

									 p7 := Person{"Paul",21}

									 p8 := Person{"Kriss",27}

									 p9 := Person{"Jake",23}

									 p10 := Person{"Rose",20}

									 personList := []Person{}

									 personList = append(personList,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10)

									 fmt.Println("分组前的数据:",personList)

									 fmt.Println("分组后的数据:",splitSlice(personList))

									}

									//按某个字段排序

									type sortByAge []Person

									func (s sortByAge) Len() int   { return len(s) }

									func (s sortByAge) Swap(i, j int)  { s[i], s[j] = s[j], s[i] }

									func (s sortByAge) Less(i, j int) bool { return s[i].Age < s[j].Age}

									//切片分组

									func splitSlice(list []Person) [][]Person {

									 sort.Sort(sortByAge(list))

									 returnData := make([][]Person,0)

									 i:= 0

									 var j int

									 for {

									 if i >= len(list) {

									 break

									 }

									 for j = i + 1; j< len(list) && list[i].Age == list [j].Age; j++ {}

									 returnData = append(returnData,list[i:j])

									 i = j

									 }

									 return returnData

									}

打印结果如下：

分组前的数据：

[{Tom 20} {Lily 21} {Linda 23} {Jass 25} {Tonny 20} {Pite 25} {Paul 21} {Kriss 27} {Jake 23} {Rose 20}]

分组后的数据：

[[{Tom 20} {Rose 20} {Tonny 20}] [{Lily 21} {Paul 21}] [{Linda 23} {Jake 23}] [{Pite 25} {Jass 25}][{Kriss 27}]]

补充：golang分组和枚举

我就废话不多说了，大家还是直接看代码吧~

									package main

									//同时导入多个包

									//import “fmt”

									//import “errors”

									//同时声明多个常量或者变量，那么可以简化为下面这种分组声明的方式

									//const PI float32 = 3.14

									//const NAME string = “hello”

									//分组声明

									import(

									“fmt”

									“errors”

									)

									//常量声明大写哈，和c/c++一样

									const(

									PI = 3.14

									NAME = “HELLO”

									)

									//枚举enum,和c/c++一样哈都是从0开始

									// iota枚举，默认等于0，同一个分组内没声明一个变量那么iota加1 所以 y=1， z=2, j = 5

									const(

									// x = iota

									// y = iota

									// z = iota

									x = iota

									y = iota

									z = 6

									k  

									p

									j = iota

									)

									// 遇到一个新的const emun,那么iota就会重置为0，所以h = 0

									const(

									h = iota

									)

									//golang设计原则

									//大写字母开头的变量，则能被其他包使用的，小写字母开头的变量只能当前包使用拉

									//函数也是拉，大写可以被其他包使用，小写只能当前包使用.

									func main() {

									err := errors.New(“hello”)

									fmt.Println(err)

									//x=0 y=1 z=2 h=0

									// x=0 y=1 z=6 h=0 k=6 j=5

									fmt.Printf("x=%d y=%d z=%d h=%d k=%d j=%d\n", x,y,z,h,k,j)

									}