對象數組中按對象的指定某個字段排序

                           篳路藍縷，以啓山林。撫有蠻夷，以屬華夏。不鳴則已，一鳴驚人。
                                                                                                              ——《左傳`宣公十二年》
 

目錄

 

問題背景

解決思路

方案1代碼實現

方案2代碼實現

---

問題背景

今天遇到一個現象，因部分因素形成了信息列表infoList數組，該數組內每個元素是一個Info對象，Info有一個屬性LoginTime，現在數組內對象是LoginTime亂序的，要求數組中所有對象按LoginTime由近及遠的順序排序，即結果中第一個元素應該是最新的（LoginTime最大），其它次之。

解決思路

第一種方案：既然要按LoginTime排序，那麼必先取出所有對象的LoginTime排一下，那怎樣讓每個LoginTime關聯到自己的對象呢？那就是map了，map的value用來存對應的對象，那如果有LoginTime相等也就是map的key衝突的時候呢？，那就直接append一下放一起就可以了（我這無需進一步按其它字段排序）。

第二種方案：使用sort包即可完成該需求。

方案1代碼實現

// 用來給LoginTime排序
func qSort(arr []int32) []int32 {
	if len(arr) <= 1 {
		return arr
	}

	base := arr[0]
	left, right := 0, len(arr)-1
	for i := 1; i <= right; {
		if arr[i] < base {
			if i != right {
				arr[i], arr[right] = arr[right], arr[i]
			}
			right--
		} else {
			if i != left {
				arr[i], arr[left] = arr[left], arr[i]
			}
			left++
			i++
		}
	}

	qSort(arr[:left])
	qSort(arr[left+1:])
	return arr
}

// 對象數組中的對象類型：Info
// 對入參infoList中的對象進行排序，返回排好序的resList
func SortListByLoginTime(infoList []Info) (resList []Info) {
	storgeSortMap := make(map[int32][]Info)
	var ltList []int32
	for _, info := range infoList {
		if data, ok := storgeSortMap[info.LoginTime]; ok {
			storgeSortMap[info.LoginTime] = append(data, info)
		} else {
			storgeSortMap[info.LoginTime] = []Info{info}
		}

		ltList = append(ltList, info.LoginTime)
	}

	qSort(ltList)

	for _, lt := range ltList {
		if _, ok := storgeSortMap[lt]; ok {
			resList = append(resList, storgeSortMap[lt]...)
		}
		delete(storgeSortMap, lt)
	}

	return resList
}

來驗證一下

func TestSortListByLoginTime(t *testing.T) {

	i1 := Info{
		Id:        1010,
		LoginTime: 123,
		NickName:  "wl123",
	}
	i2 := Info{
		Id:        1011,
		LoginTime: 125,
		NickName:  "wl125",
	}
	i3 := Info{
		Id:        1012,
		LoginTime: 121,
		NickName:  "wl121",
	}
	i4 := Info{
		Id:        1013,
		LoginTime: 131,
		NickName:  "wl131",
	}
	i5 := Info{
		Id:        1014,
		LoginTime: 117,
		NickName:  "wl117",
	}

	infoList := []Info{i1, i2, i3, i4, i5}
	log.Println("sort pre--->", infoList)
	res := SortListByLoginTime(infoList)
	log.Println("after sort--->", res)

}

測試結果（對象的第四項是LoginTime字段值）：

sort pre---> [{1010  wl123  0 123 0   } {1011  wl125  0 125 0   } {1012  wl121  0 121 0   } {1013  wl131  0 131 0   } {1014  wl117  0 117 0   }]
after sort---> [{1013  wl131  0 131 0   } {1011  wl125  0 125 0   } {1010  wl123  0 123 0   } {1012  wl121  0 121 0   } {1014  wl117  0 117 0   }]

方案2代碼實現

// 精簡成三個字段，好觀察，主要是LoginTime
type Info struct{
	Id int
	LoginTime int32
	NickName string
}

type InfoList []Info

func (list InfoList) Len() int {
	return len(list)
}

func (list InfoList) Swap(i, j int) {
	list[i], list[j] = list[j], list[i]
}

func (list InfoList) Less(i, j int) bool {
	return list[i].LoginTime > list[j].LoginTime
}

func SortListByLoginTime(infoList InfoList) {
	sort.Sort(infoList)
}

func main() {
	i1 := Info{
		Id:        1010,
		LoginTime: 123,
		NickName:  "wl123",
	}
	i2 := Info{
		Id:        1011,
		LoginTime: 125,
		NickName:  "wl125",
	}
	i3 := Info{
		Id:        1012,
		LoginTime: 121,
		NickName:  "wl121",
	}
	i4 := Info{
		Id:        1013,
		LoginTime: 131,
		NickName:  "wl131",
	}
	i5 := Info{
		Id:        1014,
		LoginTime: 117,
		NickName:  "wl117",
	}

	infoList := []Info{i1, i2, i3, i4, i5}
	log.Println("sort pre--->", infoList)
	SortListByLoginTime(infoList)
	log.Println("after sort--->", infoList)

}

驗證下

sort pre---> [{1010 123 wl123} {1011 125 wl125} {1012 121 wl121} {1013 131 wl131} {1014 117 wl117}]
after sort---> [{1013 131 wl131} {1011 125 wl125} {1010 123 wl123} {1012 121 wl121} {1014 117 wl117}]

美滋滋！如果解決了你的問題，可以點個贊哦！