Skip to content
本页内容

# List ​

List是线性表数据结构, 用go切片实现。

## 源码 ​

- https://github.com/duke-git/lancet/blob/main/datastructure/list/list.go

## 用法 ​

go

    import (
        "github.com/duke-git/lancet/v2/datastructure"
    )

    import (
        "github.com/duke-git/lancet/v2/datastructure"
    )

## 目录 ​

- NewList
- Contain
- Data
- ValueOf
- IndexOf
- LastIndexOf
- IndexOfFunc
- LastIndexOfFunc
- Push
- PopFirst
- PopLast
- DeleteAt
- InsertAt
- UpdateAt
- Equal
- IsEmpty
- Clear
- Clone
- Merge
- Size
- Cap
- Swap
- Reverse
- Unique
- Union
- Intersection
- Difference
- SymmetricDifference
- RetainAll
- DeleteAll
- ForEach
- Iterator
- ListToMap
- SubList
- DeleteIf

## 文档 ​

### NewList ​

返回List指针实例

函数签名:

go

    type List[T any] struct {
        data []T
    }
    func NewList[T any](data []T) *List[T]

    type List[T any] struct {
        data []T
    }
    func NewList[T any](data []T) *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        fmt.Println(li)
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        fmt.Println(li)
    }

### Contain ​

判断列表中是否包含特定值

函数签名:

go

    func (l *List[T]) Contain(value T) bool

    func (l *List[T]) Contain(value T) bool

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        fmt.Println(li.Contain(1)) //true
        fmt.Println(li.Contain(0)) //false
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        fmt.Println(li.Contain(1)) //true
        fmt.Println(li.Contain(0)) //false
    }

### Data ​

返回List中所有数据（切片）

函数签名:

go

    func (l *List[T]) Data() []T

    func (l *List[T]) Data() []T

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        data := li.Data()

        fmt.Println(data) //[]int{1, 2, 3}
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        data := li.Data()

        fmt.Println(data) //[]int{1, 2, 3}
    }

### ValueOf ​

返回列表中索引处的值指针

函数签名:

go

    func (l *List[T]) ValueOf(index int) (*T, bool)

    func (l *List[T]) ValueOf(index int) (*T, bool)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        v, ok := li.ValueOf(0)

        fmt.Println(*v) //1
        fmt.Println(ok) //true
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        v, ok := li.ValueOf(0)

        fmt.Println(*v) //1
        fmt.Println(ok) //true
    }

### IndexOf ​

返回列表中值的索引，如果没有找到返回-1

函数签名:

go

    func (l *List[T]) IndexOf(value T) int

    func (l *List[T]) IndexOf(value T) int

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        fmt.Println(li.IndexOf(1)) //0
        fmt.Println(li.IndexOf(0)) //-1
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        fmt.Println(li.IndexOf(1)) //0
        fmt.Println(li.IndexOf(0)) //-1
    }

### LastIndexOf ​

返回列表中最后一次出现的值的索引。如果未找到，则返回-1

函数签名:

go

    func (l *List[T]) LastIndexOf(value T) int

    func (l *List[T]) LastIndexOf(value T) int

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 1})

        fmt.Println(li.LastIndexOf(1)) // 3
        fmt.Println(li.LastIndexOf(0)) //-1
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 1})

        fmt.Println(li.LastIndexOf(1)) // 3
        fmt.Println(li.LastIndexOf(0)) //-1
    }

### IndexOfFunc ​

返回第一个符合函数条件的元素的索引。如果未找到，则返回-1

函数签名:

go

    func (l *List[T]) IndexOfFunc(f func(T) bool) int

    func (l *List[T]) IndexOfFunc(f func(T) bool) int

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 1 })) //0
        fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 0 })) //-1
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 1 })) //0
        fmt.Println(li.IndexOfFunc(func(a int) bool { return a == 0 })) //-1
    }

### LastIndexOfFunc ​

返回最后一个符合函数条件的元素的索引。如果未找到，则返回-1

函数签名:

go

    func (l *List[T]) LastIndexOfFunc(f func(T) bool) int

    func (l *List[T]) LastIndexOfFunc(f func(T) bool) int

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 1})

        fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
        fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 0 })) //-1
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 1})

        fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 1 })) // 3
        fmt.Println(li.LastIndexOfFunc(func(a int) bool { return a == 0 })) //-1
    }

### Push ​

将值附加到列表末尾

函数签名:

go

    func (l *List[T]) Push(value T)

    func (l *List[T]) Push(value T)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        li.Push(4)

        fmt.Println(li.Data()) //[]int{1, 2, 3, 4}
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        li.Push(4)

        fmt.Println(li.Data()) //[]int{1, 2, 3, 4}
    }

### PopFirst ​

删除列表的第一个值并返回该值

函数签名:

go

    func (l *List[T]) PopFirst() (*T, bool)

    func (l *List[T]) PopFirst() (*T, bool)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        v, ok := li.PopFirst()

        fmt.Println(*v) //1
        fmt.Println(ok) //true
        fmt.Println(li.Data()) //2, 3
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        v, ok := li.PopFirst()

        fmt.Println(*v) //1
        fmt.Println(ok) //true
        fmt.Println(li.Data()) //2, 3
    }

### PopFirst ​

删除列表的最后一个值并返回该值

函数签名:

go

    func (l *List[T]) PopLast() (*T, bool)

    func (l *List[T]) PopLast() (*T, bool)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        v, ok := li.PopLast()

        fmt.Println(*v) //3
        fmt.Println(ok) //true
        fmt.Println(li.Data()) //1, 2
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        v, ok := li.PopLast()

        fmt.Println(*v) //3
        fmt.Println(ok) //true
        fmt.Println(li.Data()) //1, 2
    }

### DeleteAt ​

删除索引处列表的值，如果索引不在0和列表数据长度之间，则不执行任何操作

函数签名:

go

    func (l *List[T]) DeleteAt(index int)

    func (l *List[T]) DeleteAt(index int)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})

        li.DeleteAt(-1)
        fmt.Println(li.Data()) //1,2,3,4

        li.DeleteAt(4)
        fmt.Println(li.Data()) //1,2,3,4

        li.DeleteAt(0)
        fmt.Println(li.Data()) //2,3,4

        li.DeleteAt(2)
        fmt.Println(li.Data()) //2,3
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})

        li.DeleteAt(-1)
        fmt.Println(li.Data()) //1,2,3,4

        li.DeleteAt(4)
        fmt.Println(li.Data()) //1,2,3,4

        li.DeleteAt(0)
        fmt.Println(li.Data()) //2,3,4

        li.DeleteAt(2)
        fmt.Println(li.Data()) //2,3
    }

### InsertAt ​

在索引处插入值到列表中，如果索引不在 0 和列表数据长度之间，则不执行任何操作

函数签名:

go

    func (l *List[T]) InsertAt(index int, value T)

    func (l *List[T]) InsertAt(index int, value T)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        li.InsertAt(-1, 0)
        fmt.Println(li.Data()) //1,2,3

        li.InsertAt(4, 0)
        fmt.Println(li.Data()) //1,2,3

        li.InsertAt(3, 4)
        fmt.Println(li.Data()) //1,2,3,4

        // li.InsertAt(2, 4)
        // fmt.Println(li.Data()) //1,2,4,3
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        li.InsertAt(-1, 0)
        fmt.Println(li.Data()) //1,2,3

        li.InsertAt(4, 0)
        fmt.Println(li.Data()) //1,2,3

        li.InsertAt(3, 4)
        fmt.Println(li.Data()) //1,2,3,4

        // li.InsertAt(2, 4)
        // fmt.Println(li.Data()) //1,2,4,3
    }

### UpdateAt ​

更新索引处列表的值，索引应该在0和列表数据长度-1之间

函数签名:

go

    func (l *List[T]) UpdateAt(index int, value T)

    func (l *List[T]) UpdateAt(index int, value T)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        li.UpdateAt(-1, 0)
        fmt.Println(li.Data()) //1,2,3

        li.UpdateAt(2, 4)
        fmt.Println(li.Data()) //1,2,4

        li.UpdateAt(3, 5)
        fmt.Println(li.Data()) //1,2,4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})

        li.UpdateAt(-1, 0)
        fmt.Println(li.Data()) //1,2,3

        li.UpdateAt(2, 4)
        fmt.Println(li.Data()) //1,2,4

        li.UpdateAt(3, 5)
        fmt.Println(li.Data()) //1,2,4
    }

### Equal ​

比较一个列表和另一个列表，在每个元素上使用 reflect.DeepEqual

函数签名:

go

    func (l *List[T]) Equal(other *List[T]) bool

    func (l *List[T]) Equal(other *List[T]) bool

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{1, 2, 3, 4})
        li3 := list.NewList([]int{1, 2, 3})

        fmt.Println(li1.Equal(li2)) //true
        fmt.Println(li1.Equal(li3)) //false
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{1, 2, 3, 4})
        li3 := list.NewList([]int{1, 2, 3})

        fmt.Println(li1.Equal(li2)) //true
        fmt.Println(li1.Equal(li3)) //false
    }

### IsEmpty ​

判断列表是否为空

函数签名:

go

    func (l *List[T]) IsEmpty() bool

    func (l *List[T]) IsEmpty() bool

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3})
        li2 := list.NewList([]int{})

        fmt.Println(li1.IsEmpty()) //false
        fmt.Println(li2.IsEmpty()) //true
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3})
        li2 := list.NewList([]int{})

        fmt.Println(li1.IsEmpty()) //false
        fmt.Println(li2.IsEmpty()) //true
    }

### Clear ​

清空列表数据

函数签名:

go

    func (l *List[T]) Clear()

    func (l *List[T]) Clear()

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        li.Clear()

        fmt.Println(li.Data()) // empty
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        li.Clear()

        fmt.Println(li.Data()) // empty
    }

### Clone ​

返回列表的一个拷贝

函数签名:

go

    func (l *List[T]) Clone() *List[T]

    func (l *List[T]) Clone() *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        cloneList := li.Clone()

        fmt.Println(cloneList.Data()) // 1,2,3
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3})
        cloneList := li.Clone()

        fmt.Println(cloneList.Data()) // 1,2,3
    }

### Merge ​

合并两个列表，返回新的列表

函数签名:

go

    func (l *List[T]) Merge(other *List[T]) *List[T]

    func (l *List[T]) Merge(other *List[T]) *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{4, 5, 6})
        li3 := li1.Merge(li2)

        fmt.Println(li3.Data()) //1, 2, 3, 4, 4, 5, 6
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{4, 5, 6})
        li3 := li1.Merge(li2)

        fmt.Println(li3.Data()) //1, 2, 3, 4, 4, 5, 6
    }

### Size ​

返回列表数据项的数量

函数签名:

go

    func (l *List[T]) Size() int

    func (l *List[T]) Size() int

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})

        fmt.Println(li.Size()) //4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})

        fmt.Println(li.Size()) //4
    }

### Cap ​

返回列表数据容量

函数签名:

go

    func (l *List[T]) Cap() int

    func (l *List[T]) Cap() int

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        data := make([]int, 0, 100)

        li := list.NewList(data)

        fmt.Println(li.Cap()) // 100
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        data := make([]int, 0, 100)

        li := list.NewList(data)

        fmt.Println(li.Cap()) // 100
    }

### Swap ​

交换列表中两个索引位置的值

函数签名:

go

    func (l *List[T]) Swap(i, j int)

    func (l *List[T]) Swap(i, j int)

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})
        li.Swap(0, 3)

        fmt.Println(li.Data()) //4, 2, 3, 1
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})
        li.Swap(0, 3)

        fmt.Println(li.Data()) //4, 2, 3, 1
    }

### Reverse ​

反转列表的数据项顺序

函数签名:

go

    func (l *List[T]) Reverse()

    func (l *List[T]) Reverse()

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})
        li.Reverse()

        fmt.Println(li.Data()) //4, 3, 2, 1
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 3, 4})
        li.Reverse()

        fmt.Println(li.Data()) //4, 3, 2, 1
    }

### Unique ​

列表去除重复数据项

函数签名:

go

    func (l *List[T]) Unique()

    func (l *List[T]) Unique()

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 2, 3, 4})
        li.Unique()

        fmt.Println(li.Data()) //1,2,3,4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li := list.NewList([]int{1, 2, 2, 3, 4})
        li.Unique()

        fmt.Println(li.Data()) //1,2,3,4
    }

### Union ​

两个列表取并集，去除重复数据项

函数签名:

go

    func (l *List[T]) Union(other *List[T]) *List[T]

    func (l *List[T]) Union(other *List[T]) *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{4, 5, 6})
        li3 := li1.Union(li2)

        fmt.Println(li3.Data()) //1,2,3,4,5,6
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{4, 5, 6})
        li3 := li1.Union(li2)

        fmt.Println(li3.Data()) //1,2,3,4,5,6
    }

### Intersection ​

两个列表取交集

函数签名:

go

    func (l *List[T]) Intersection(other *List[T]) *List[T]

    func (l *List[T]) Intersection(other *List[T]) *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{4, 5, 6})
        li3 := li1.Intersection(li2)

        fmt.Println(li3.Data()) //4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        li1 := list.NewList([]int{1, 2, 3, 4})
        li2 := list.NewList([]int{4, 5, 6})
        li3 := li1.Intersection(li2)

        fmt.Println(li3.Data()) //4
    }

### Difference ​

差集运算。

函数签名:

go

    func (l *List[T]) Difference(other *List[T]) *List[T]

    func (l *List[T]) Difference(other *List[T]) *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list1 := NewList([]int{1, 2, 3})
        list2 := NewList([]int{1, 2, 4})

        list3 := list1.Intersection(list2)

        fmt.Println(list3.Data()) //3
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list1 := NewList([]int{1, 2, 3})
        list2 := NewList([]int{1, 2, 4})

        list3 := list1.Intersection(list2)

        fmt.Println(list3.Data()) //3
    }

### SymmetricDifference ​

对称差集运算。

函数签名:

go

    func (l *List[T]) SymmetricDifference(other *List[T]) *List[T]

    func (l *List[T]) SymmetricDifference(other *List[T]) *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list1 := NewList([]int{1, 2, 3})
        list2 := NewList([]int{1, 2, 4})

        list3 := list1.Intersection(list2)

        fmt.Println(list3.Data()) //3, 4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list1 := NewList([]int{1, 2, 3})
        list2 := NewList([]int{1, 2, 4})

        list3 := list1.Intersection(list2)

        fmt.Println(list3.Data()) //3, 4
    }

### RetainAll ​

仅保留列表中包含在给定列表中的元素。

函数签名:

go

    func (l *List[T]) RetainAll(list *List[T]) bool

    func (l *List[T]) RetainAll(list *List[T]) bool

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})
        list1 := NewList([]int{1, 2, 3, 4})
        list2 := NewList([]int{1, 2, 3, 4})

        retain := NewList([]int{1, 2})
        retain1 := NewList([]int{2, 3})
        retain2 := NewList([]int{1, 2, 5})

        list.RetainAll(retain)
        list1.RetainAll(retain1)
        list2.RetainAll(retain2)

        fmt.Println(list.Data()) //1, 2
        fmt.Println(list1.Data()) //2, 3
        fmt.Println(list2.Data()) //1, 2
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})
        list1 := NewList([]int{1, 2, 3, 4})
        list2 := NewList([]int{1, 2, 3, 4})

        retain := NewList([]int{1, 2})
        retain1 := NewList([]int{2, 3})
        retain2 := NewList([]int{1, 2, 5})

        list.RetainAll(retain)
        list1.RetainAll(retain1)
        list2.RetainAll(retain2)

        fmt.Println(list.Data()) //1, 2
        fmt.Println(list1.Data()) //2, 3
        fmt.Println(list2.Data()) //1, 2
    }

### DeleteAll ​

从列表中删除给定列表中包含的所有元素。

函数签名:

go

    func (l *List[T]) DeleteAll(list *List[T]) bool

    func (l *List[T]) DeleteAll(list *List[T]) bool

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})
        list1 := NewList([]int{1, 2, 3, 4})
        list2 := NewList([]int{1, 2, 3, 4})

        del := NewList([]int{1})
        del1 := NewList([]int{2, 3})
        del2 := NewList([]int{1, 2, 5})

        list.DeleteAll(del)
        list1.DeleteAll(del1)
        list2.DeleteAll(del2)

        fmt.Println(list.Data()) //2,3,4
        fmt.Println(list1.Data()) //1,4
        fmt.Println(list2.Data()) //3,4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})
        list1 := NewList([]int{1, 2, 3, 4})
        list2 := NewList([]int{1, 2, 3, 4})

        del := NewList([]int{1})
        del1 := NewList([]int{2, 3})
        del2 := NewList([]int{1, 2, 5})

        list.DeleteAll(del)
        list1.DeleteAll(del1)
        list2.DeleteAll(del2)

        fmt.Println(list.Data()) //2,3,4
        fmt.Println(list1.Data()) //1,4
        fmt.Println(list2.Data()) //3,4
    }

### ForEach ​

对列表的每个元素执行给定的操作。

函数签名:

go

    func (l *List[T]) ForEach(consumer func(T))

    func (l *List[T]) ForEach(consumer func(T))

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})

        result := make([]int, 0)
        list.ForEach(func(i int) {
            result = append(result, i)
        })

        fmt.Println(result.Data()) //1,2,3,4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})

        result := make([]int, 0)
        list.ForEach(func(i int) {
            result = append(result, i)
        })

        fmt.Println(result.Data()) //1,2,3,4
    }

### Iterator ​

按顺序返回列表中元素的迭代器。

函数签名:

go

    func (l *List[T]) Iterator() iterator.Iterator[T]

    func (l *List[T]) Iterator() iterator.Iterator[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})

        iterator := list.Iterator()

        result := make([]int, 0)
        for iterator.HasNext() {
            item, _ := iterator.Next()
            result = append(result, item)
        }

        fmt.Println(result.Data()) //1,2,3,4
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})

        iterator := list.Iterator()

        result := make([]int, 0)
        for iterator.HasNext() {
            item, _ := iterator.Next()
            result = append(result, item)
        }

        fmt.Println(result.Data()) //1,2,3,4
    }

### ListToMap ​

基于iteratee函数将列表转换为映射map。

函数签名:

go

    func ListToMap[T any, K comparable, V any](list *List[T], iteratee func(T) (K, V)) map[K]V

    func ListToMap[T any, K comparable, V any](list *List[T], iteratee func(T) (K, V)) map[K]V

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})

        result := ListToMap(list, func(n int) (int, bool) {
            return n, n > 1
        })

        fmt.Println(result) //map[int]bool{1: false, 2: true, 3: true, 4: true}
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        list := NewList([]int{1, 2, 3, 4})

        result := ListToMap(list, func(n int) (int, bool) {
            return n, n > 1
        })

        fmt.Println(result) //map[int]bool{1: false, 2: true, 3: true, 4: true}
    }

### SubList ​

返回指定的fromIndex（包含）和toIndex（不包含）之间的原始列表的子列表。

函数签名:

go

    func (l *List[T]) SubList(fromIndex, toIndex int) *List[T]

    func (l *List[T]) SubList(fromIndex, toIndex int) *List[T]

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        l := list.NewList([]int{1, 2, 3, 4, 5, 6})

        fmt.Println(l.SubList(2, 5)) // []int{3, 4, 5}
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        l := list.NewList([]int{1, 2, 3, 4, 5, 6})

        fmt.Println(l.SubList(2, 5)) // []int{3, 4, 5}
    }

### DeleteIf ​

删除列表中所有符合函数（调用函数返回true)的元素，返回删除元素的数量

函数签名:

go

    func (l *List[T]) DeleteIf(f func(T) bool) int

    func (l *List[T]) DeleteIf(f func(T) bool) int

示例:

go

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})

        fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12
        fmt.Println(l.Data()) // []int{2, 3, 4}
    }

    package main

    import (
        "fmt"
        list "github.com/duke-git/lancet/v2/datastructure/list"
    )

    func main() {
        l := list.NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1})

        fmt.Println(l.DeleteIf(func(a int) bool { return a == 1 })) // 12
        fmt.Println(l.Data()) // []int{2, 3, 4}
    }