GO如何模擬流操作實現(xiàn)示例探究
更新時間：2024年01月05日 14:44:50 作者：小雷學編程?Jacksonlei
這篇文章主要為大家介紹了GO如何模擬流操作實現(xiàn)示例探究,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
前言
本篇主要是做一個記錄，希望對您有用
首先，你可能看到過類似的JAVA 代碼如下 :
return Optional.ofNullable(list).flatMap(list -> list.stream()
.filter(Objects::nonNull)
.filter(i -> stockCode.equals(i.id()))
.map(this::mathod)
.findFirst())
.orElse(null);時間有限我們今天嘗試著模擬一下部分方法，感受一下。
集合
首先我們需要一個集合如下：
var okgoarch = List{
"arm",
"arm64",
"loong64",
"mips64",
"mips64le",
"ppc64",
"riscv64",
"sparc64",
}過濾的方法
接下來我們需要嘗試寫一個過濾的方法這個方法應該要接受一個方法，并且這個方法的需要接受的類型應該是一個泛型類型，返回值是BOOL ，然后我們對集合的每個元素都操作，所以大概樣子就出來:
func (ls List) Filter(fk Predicate[string]) List {
if fk == nil {
return nil
}
var res List
for _, nod := range ls {
if fk(nod) {
res = append(res, nod)
}
}
return res
}
type Predicate[P any] func(n P) bool可能有心細的朋友已經(jīng)發(fā)現(xiàn)了 List 這個類，是我自己定義的，要是別的類型呢？往下看
type List []string
定個接口來處理通用類型
LIST 實際上就是我定義的類似，為了方便使用，這里有個問題，我如果定義的是別的類型是不是就不管用了，所以我們需要定個接口來處理通用類型，所以接口就出來了：
type Stream[T any] interface {
Filter(pre Predicate[T]) bool
}但是又有一個問題，如果別的類型實現(xiàn)的方法可能返回不是BOOL 怎么辦，那么接口就長成下面這樣，雖然不太可能為了實現(xiàn)拓展我還是愿意這么做，如下：
type Stream[T, OUT any] interface {
Filter(pre Predicate[T]) OUT
}測試對字符串切片過濾的邏輯
到這里一個簡單的對字符串切片過濾的邏輯就完成了，我們測試一下：
var okgoarch = List{
"arm",
"arm64",
"loong64",
"mips64",
"mips64le",
"ppc64",
"riscv64",
"sparc64",
}
lss := okgoarch.
Filter(func(n string) bool { return n == "sparc64" || n == "mips64le" })
fmt.Printf("%+v\n", lss)
//[mips64le sparc64]貌似還算成功過，接下來我嘗試實現(xiàn)一個稍微復雜點的方法。
stream.map(()->{}) 等操作
定義一個方法結構
我們都知道MAP的流操作方法需要接受一個方法類型作為入?yún)?，GO函數(shù)式編程很好的解決了這個問題，首先我們需要先定義一個方法結構，它大概長這樣：
type Function[F any, OUT any] func(n F) OUT
這里定義方法入?yún)⒑统鰠?/strong>都是泛型類型，我暫且認為MAP操作就是對集合的每個元素都進行一個方法操作，那么它的方法可能長這樣:
func (ls List) Map(fk Function[string, string]) List {
if fk == nil {
return nil
}
var res List
for _, nod := range ls {
res = append(res, fk(nod))
}
return res
}完整接口
同樣，如果是通用類型需要一個接口支持，不然切片可以用MAP，其他類型卻不行，所以接口我們加一個定義，完整接口如下：
type Stream[T, F2, OUT any] interface {</code><code> Filter(pre Predicate[T]) OUT</code><code> Map(function Function[T, F2]) OUT</code><code>}按照上面同樣的方法我定義了Sorted 方法和 字符串Joins方法，如下 ：
type Stream[T, F2, OUT any] interface {
Filter(pre Predicate[T]) OUT
Map(function Function[T, F2]) OUT
}同樣也要加上接口哦，字符串切片排序比較簡單。到這里字符串切片的方法就定義完了
測試一下
ls := okgoarch.
Filter(func(n string) bool { return n == "sparc64" || n == "mips64le" }).
Map(strings.ToTitle).
Sorted(). //按照ascii碼表排序
joins(":")
fmt.Printf("%+v\n",
[arm arm64 loong64 mips64 mips64le ppc64 riscv64 sparc64]
ls)字符串切片可以，是否別的類型也可以
我嘗試用了一個結構體切片來說明同樣的思路我直接貼代碼了：
type Person struct {
Name string
Age int
}
type ByAgeNameCompare []Person
func (a ByAgeNameCompare) Len() int { return len(a) }
func (a ByAgeNameCompare) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByAgeNameCompare) Less(i, j int) bool {
if a[i].Age == a[j].Age {
return a[i].Name < a[j].Name //DESC
}
return a[i].Age < a[j].Age //ASC
}
type Persons []Person
func (ls Persons) Sorted() Persons {
sort.Sort(ByAgeNameCompare(ls))
return ls
}
func (ls Persons) Filter(fk Predicate[Person]) Persons {
if fk == nil {
return nil
}
var res Persons
for _, nod := range ls {
if fk(nod) {
res = append(res, nod)
}
}
return res
}
func (ls Persons) Map(fk Function[Person, any]) any {
if fk == nil {
return nil
}
var res []any
for _, nod := range ls {
res = append(res, fk(nod))
}
return res
}
func (ls Persons) Map1(fk Function[Person, Person]) Persons {
if fk == nil {
return nil
}
var res Persons
for _, nod := range ls {
res = append(res, fk(nod))
}
return res
}以上代碼是結構體切片類型的實現(xiàn)，結構體類型可以自己定義，例如JAVA某個子類型的stream 流接口的實現(xiàn)一樣
完整代碼
type Predicate[P any] func(n P) bool
type Function[F any, OUT any] func(n F) OUT
type List []string
type Stream[T, F2, OUT any] interface {
Filter(pre Predicate[T]) OUT
Map(function Function[T, F2]) OUT
Sorted() OUT
}
func (ls List) Filter(fk Predicate[string]) List {
if fk == nil {
return nil
}
var res List
for _, nod := range ls {
if fk(nod) {
res = append(res, nod)
}
}
return res
}
func (ls List) Map(fk Function[string, string]) List {
if fk == nil {
return nil
}
var res List
for _, nod := range ls {
res = append(res, fk(nod))
}
return res
}
func (ls List) joins(delim string) string {
return strings.Join(ls, delim)
}
func (ls List) Sorted() List {
sort.Strings(ls)
return ls
}
type Person struct {
Name string
Age int
}
type ByAgeNameCompare []Person
func (a ByAgeNameCompare) Len() int { return len(a) }
func (a ByAgeNameCompare) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByAgeNameCompare) Less(i, j int) bool {
if a[i].Age == a[j].Age {
return a[i].Name < a[j].Name //DESC
}
return a[i].Age < a[j].Age //ASC
}
type Persons []Person
func (ls Persons) Sorted() Persons {
sort.Sort(ByAgeNameCompare(ls))
return ls
}
func (ls Persons) Filter(fk Predicate[Person]) Persons {
if fk == nil {
return nil
}
var res Persons
for _, nod := range ls {
if fk(nod) {
res = append(res, nod)
}
}
return res
}
func (ls Persons) Map(fk Function[Person, any]) any {
if fk == nil {
return nil
}
var res []any
for _, nod := range ls {
res = append(res, fk(nod))
}
return res
}
func (ls Persons) Map1(fk Function[Person, Person]) Persons {
if fk == nil {
return nil
}
var res Persons
for _, nod := range ls {
res = append(res, fk(nod))
}
return res
}
func main() {
var okgoarch = List{
"arm",
"arm64",
"loong64",
"mips64",
"mips64le",
"ppc64",
"riscv64",
"sparc64",
}
lss := okgoarch.
Filter(func(n string) bool { return n == "sparc64" || n == "mips64le" })
fmt.Printf("%+v\n", lss)
fmt.Printf("%+v\n", okgoarch)
ls := okgoarch.
Filter(func(n string) bool { return n == "sparc64" || n == "mips64le" }).
Map(strings.ToTitle).
Sorted(). //按照ascii碼表排序
joins(":")
fmt.Printf("%+v\n", ls)
peoples := Persons{
{"Alice", 30},
{"Bob", 25},
{"Charlie", 35},
{"Dark", 75},
}
psvar := peoples.
Filter(func(n Person) bool { return n.Name != "Charlie" }).
Map(func(n Person) any {
return n.Name
})
fmt.Printf("%+v\n", psvar)
psvar1 := peoples.
Filter(func(n Person) bool { return n.Name != "Charlie" }).
Map1(func(n Person) Person {
n.Name = n.Name + "pick"
return n
}).Sorted()
fmt.Printf("%+v", psvar1)
}
[mips64le sparc64]
[arm arm64 loong64 mips64 mips64le ppc64 riscv64 sparc64]
MIPS64LE:SPARC64
[Alice Bob Dark]
[{Name:Bobpick Age:25} {Name:Alicepick Age:30} {Name:Darkpick Age:75}]以上就是GO如何模擬流操作實現(xiàn)示例探究的詳細內(nèi)容，更多關于GO模擬流操作的資料請關注腳本之家其它相關文章！
相關文章
這篇文章主要給大家詳細介紹了Golang 中的 crypto/ecdh 包,主要包括什么是ECDH 算法和crypto/ecdh 包的使用方法,文中通過代碼示例介紹的非常詳細,需要的朋友可以參考下2023-09-09
Golang使用協(xié)程實現(xiàn)批量獲取數(shù)據(jù)
服務端經(jīng)常需要返回一個列表，里面包含很多用戶數(shù)據(jù)，常規(guī)做法當然是遍歷然后讀緩存。使用Go語言后，可以并發(fā)獲取，極大提升效率，本文就來聊聊具體的實現(xiàn)方法，希望對大家有所幫助2023-02-02
在?Go?語言中,雖然沒有像?Java?或?Python?那樣的傳統(tǒng)集合框架,但也可以非常高效地處理集合操作,下面小編就來和大家講講具體處理方法吧2025-01-01
在我們開發(fā)的過程中,每個項目都需要時間這一類的函數(shù),此時對time這個包的研究深度就顯得尤為重要,這篇文章主要給大家介紹了關于如何通過一篇文章帶你搞懂Go語言標準庫Time的相關資料,需要的朋友可以參考下2022-10-10
這篇文章主要介紹了go 中的 fmt 占位符,本文給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友參考下吧2024-01-01
Go的字符串是一個不可改變的數(shù)據(jù)結構,這和其他語言如JAVA,C++等的設定很類似.總體來說,有如下五種拼接方式,下面我們將論述各種方式的性能問題,以及如何選擇2023-04-04
Go語言輕量級高性能嵌入式規(guī)則引擎RuleGo使用詳解
這篇文章主要為大家介紹了Go語言輕量級高性能嵌入式規(guī)則引擎RuleGo使用詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-11-11
本篇文章主要介紹了Go Web框架gin的入門教程，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-05-05
Go并發(fā)編程中的錯誤恢復機制與代碼持續(xù)執(zhí)行實例探索
這篇文章主要為大家介紹了Go并發(fā)編程中的錯誤恢復機制與代碼持續(xù)執(zhí)行實例探索,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2024-01-01
這篇文章主要為大家介紹了如何在Go語言中靈活運用匿名函數(shù)和閉包實現(xiàn)實例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-10-10