kotlin 常见的集合操作

骑猪看日落 2024-04-19 09:57 52阅读 0赞

集合操作

## List ##

> `List` 的默认实现是 `ArrayList`  
> 是一个有序集合，可通过索引（反映元素位置的整数）访问元素

val bob = Person("Bob", 31)
    val people = listOf<Person>(Person("Adam", 20), bob, bob)
    val people2 = listOf<Person>(Person("Adam", 20), Person("Bob", 31), bob)
    println(people == people2)
    bob.age = 32
    println(people == people2)
    
    输出：
    true
    false

### `MutableList` ###

> 可以进行写操作的 `List`，例如用于在特定位置添加或删除元素

val numbers = mutableListOf(1, 2, 3, 4)
    numbers.add(5)
    numbers.removeAt(1)
    numbers[0] = 0
    numbers.shuffle() // 打乱顺序
    println(numbers)
    
    输出：
    [3, 5, 4, 0]

## `Set` ##

> `Set`的默认实现 `LinkedHashSet`  
> 是唯一元素的集合。它反映了集合`（set）`的数学抽象：一组无重复的对象。`null` 元素也是唯一的：一个 `Set` 只能包含一个`null`  
> 当两个 `set` 具有相同的大小并且对于一个 `set` 中的每个元素都能在另一个 `set` 中存在相同元素，则两个 `set` 相等。

val numbers = setOf(1, 2, 3, 4)
    
    val numbersBackwards = setOf(4, 3, 2, 1)
    println("The sets are equal: ${numbers == numbersBackwards}")
    
    输出：
    The sets are equal: true

由于默认实现是`LinkedHashSet`,其保留了元素的插入顺序，因此，依赖于顺序的函数，例如 `first() 或 last()`，会在这些 `set`上返回可预测的结果。  
`Set`的另一种实现方式`HashSet`, 只需要较少的内存来存储相同数量的元素。它不声明元素的顺序，所以在它上面调用这些函数会返回不可预测的结果。

val numbers = setOf(1, 2, 3, 4)  // LinkedHashSet is the default implementation
    val numbersBackwards = setOf(4, 3, 2, 1)
    
    println(numbers.first() == numbersBackwards.first())
    println(numbers.first() == numbersBackwards.last())
    
    输出：
    false
    true

## Map ##

> （或者字典）是一组键值对。键是唯一的，每个键都刚好映射到一个值。值可以重复。  
> MutableMap 是一个具有写操作的 Map 接口,可以使用该接口添加一个新的键值对或更新给定键的值。  
> Map 的默认实现 – LinkedHashMap – 迭代 Map 时保留元素插入的顺序。 反之，另一种实现 – HashMap – 不声明元素的顺序。

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)
    println("All keys: ${numbersMap.keys}")
    
    输出：
    All keys: [key1, key2, key3, key4]
    
    
    val numbersMap = mutableMapOf("one" to 1, "two" to 2)
    numbersMap.put("three", 3)
    numbersMap["one"] = 11
    
    println(numbersMap)
    
    输出：
    {one=11, two=2, three=3}

### 空集合 ###

val empty = emptyList<String>()
    
    val empty = emptySet<String>()
    
    val map = emptyMap<String, Int>()

### 迭代器 ###

val numbers = listOf("one", "two", "three", "four")
    val numbersIterator = numbers.iterator()
    while (numbersIterator.hasNext()) {
        println(numbersIterator.next())
    }
    
    
    或者是 for 循环
    
    val numbers = listOf("one", "two", "three", "four")
    for (item in numbers) {
        println(item)
    }
    
    或者是 forEach 循环
    val numbers = listOf("one", "two", "three", "four")
    numbers.forEach {
        println(it)
    }
    
    输出：
    one
    two
    three
    four

`listOf`迭代器，倒序输出

val numbers = listOf("one", "two", "three", "four")
    val listIterator = numbers.listIterator()
    while (listIterator.hasNext()) {
        listIterator.next()
    }
    println("Iterating backwards:")
    while (listIterator.hasPrevious()) {
        print("Index: ${listIterator.previousIndex()}")
        println(", value: ${listIterator.previous()}")
    }
    输出：
    Iterating backwards:
    Index: 3, value: four
    Index: 2, value: three
    Index: 1, value: two
    Index: 0, value: one

`mutableListOf`可变迭代器

val numbers = mutableListOf("one", "four", "four") 
    val mutableListIterator = numbers.listIterator()
    
    mutableListIterator.next()
    mutableListIterator.add("two")
    mutableListIterator.next()
    mutableListIterator.set("three")   
    println(numbers)
    
    输出：
    [one, two, three, four]

### 区间与数列 ###

// 在 1-4 的范围内
    if (i in 1..4) {  // 等同于 1 <= i && i <= 4
        print(i)
    }
    
    // 顺序输出 结果：1234
    for (i in 1..4) print(i)
    
    
    // 倒序输出 结果：4321
    for (i in 4 downTo 1) print(i)
    
    // 顺序步长 结果：1357
    // 倒序步长 结果：8642
    for (i in 1..8 step 2) print(i)
    println()
    for (i in 8 downTo 1 step 2) print(i)
    
    
    // until包头不包尾【1，10） 结果：123456789
    for (i in 1 until 10) {
        print(i)
    }

### 序列 ###

> 也是一种容器，提供了和`iterable`相同的功能，但实现了多步骤处理的另一种方法。

构造函数创建

val numbersSequence = sequenceOf("four", "three", "two", "one")

组块

val oddNumbers = sequence {
        yield(1)
        yieldAll(listOf(3, 5))
        yieldAll(generateSequence(7) { it + 2 })
    }
    println(oddNumbers.take(5).toList())
    
    输出：
    [1, 3, 5, 7, 9]

val oddNumbersLessThan10 = generateSequence(1) { if (it < 10) it + 2 else null }
    println(oddNumbersLessThan10.count())
    println(oddNumbersLessThan10.toList())
    
    输出：
    6
    [1, 3, 5, 7, 9, 11]
    
    序列处理
    
    val words = "The quick brown fox jumps over the lazy dog".split(" ")
    val lengthsList = words.filter { println("filter: $it"); it.length > 3 }
        .map { println("length: ${it.length}"); it.length }
        .take(4)
    
    println("Lengths of first 4 words longer than 3 chars:")
    println(lengthsList)
    
    输出结果：
    filter: The
    filter: quick
    filter: brown
    filter: fox
    filter: jumps
    filter: over
    filter: the
    filter: lazy
    filter: dog
    length: 5
    length: 5
    length: 5
    length: 4
    length: 4
    Lengths of first 4 words longer than 3 chars:
    [5, 5, 5, 4]

### 取集合的一部分 `Slice` ###

val numbers = listOf("one", "two", "three", "four", "five", "six")    
    println(numbers.slice(1..3))
    println(numbers.slice(0..4 step 2))
    println(numbers.slice(setOf(3, 5, 0)))  
    
    输出：
    [two, three, four]
    [one, three, five]
    [four, six, one]

### 取集合的一部分 ###

Slice
    
    val numbers = listOf("one", "two", "three", "four", "five", "six")    
    println(numbers.slice(1..3))
    println(numbers.slice(0..4 step 2))
    println(numbers.slice(setOf(3, 5, 0)))  
    
    输出：
    [two, three, four]
    [one, three, five]
    [four, six, one]
    
    Take 与 drop
    
    val numbers = listOf("one", "two", "three", "four", "five", "six")
    println(numbers.take(3))
    println(numbers.takeLast(3))
    println(numbers.drop(1))
    println(numbers.dropLast(5))
    
    输出：
    [one, two, three]
    [four, five, six]
    [two, three, four, five, six]
    [one]
    
    val numbers = listOf("one", "two", "three", "four", "five", "six")
    println(numbers.takeWhile { !it.startsWith('f') })
    println(numbers.takeLastWhile { it != "three" })
    println(numbers.dropWhile { it.length == 3 })
    println(numbers.dropLastWhile { it.contains('i') })
    
    输出：
    [one, two, three]
    [four, five, six]
    [three, four, five, six]
    [one, two, three, four]
    
    
    chunked
    
    val numbers = (0..13).toList() 
    println(numbers.chunked(3)) 
    println(numbers.chunked(3) { it.sum() }) 
    
    输出：
    [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13]]
    [3, 12, 21, 30, 25]
    
    
    Windowed
    
    
    val numbers = listOf("one", "two", "three", "four", "five")    
    println(numbers.windowed(3))
    
    输出：
    [[one, two, three], [two, three, four], [three, four, five]]
    
    
    val numbers = (1..10).toList()
    println(numbers.windowed(3, step = 2, partialWindows = true))
    println(numbers.windowed(3) { it.sum() })
    
    输出：
    [[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9], [9, 10]]
    [6, 9, 12, 15, 18, 21, 24, 27]
    
    zipWithNext
    
    val numbers = listOf("one", "two", "three", "four", "five")    
    println(numbers.zipWithNext())
    println(numbers.zipWithNext() { s1, s2 -> s1.length > s2.length})
    
    输出：
    [(one, two), (two, three), (three, four), (four, five)]
    [false, false, true, false]

### 取单个元素 ###

按位置取
    val numbers = linkedSetOf("one", "two", "three", "four", "five")
    println(numbers.elementAt(3))    
    
    val numbersSortedSet = sortedSetOf("one", "two", "three", "four")
    println(numbersSortedSet.elementAt(0)) // elements are stored in the ascending order
    
    输出：
    four
    four
    
    val numbers = listOf("one", "two", "three", "four", "five")
    println(numbers.first())    
    println(numbers.last()) 
    
    输出：
    one
    five
    
    使用安全的 elementAt:
    val numbers = listOf("one", "two", "three", "four", "five")
    println(numbers.elementAtOrNull(5))
    println(numbers.elementAtOrElse(5) { index -> "The value for index $index is undefined"})
    
    输出：
    null
    The value for index 5 is undefined
    
    
    按条件取
    val numbers = listOf("one", "two", "three", "four", "five", "six")
    println(numbers.first { it.length > 3 })
    println(numbers.last { it.startsWith("f") })
    
    输出：
    three
    five
    
    使用安全的 firstOf
    val numbers = listOf("one", "two", "three", "four", "five", "six")
    println(numbers.firstOrNull { it.length > 6 })
    
    输出：
    null
    
    随机取元素
    val numbers = listOf(1, 2, 3, 4)
    println(numbers.random())
    
    输出（numbers 里面的随机一个数）：
    1
    
    检测存在与否
    val numbers = listOf("one", "two", "three", "four", "five", "six")
    println(numbers.contains("four"))
    println("zero" in numbers)
    
    println(numbers.containsAll(listOf("four", "two")))
    println(numbers.containsAll(listOf("one", "zero")))
    
    输出：
    true
    false
    true
    false

### 排序 ###

自然顺序
    val numbers = listOf("one", "two", "three", "four")
    println("Sorted ascending: ${numbers.sorted()}")
    println("Sorted descending: ${numbers.sortedDescending()}")
    
    输出：
    Sorted ascending: [four, one, three, two]
    Sorted descending: [two, three, one, four]
    
    自定义顺序
    val numbers = listOf("one", "two", "three", "four")
    
    val sortedNumbers = numbers.sortedBy { it.length }
    println("Sorted by length ascending: $sortedNumbers")
    val sortedByLast = numbers.sortedByDescending { it.last() }
    println("Sorted by the last letter descending: $sortedByLast")
    
    输出：
    Sorted by length ascending: [one, two, four, three]
    Sorted by the last letter descending: [four, two, one, three]
    
    倒序
    val numbers = listOf("one", "two", "three", "four")
    println(numbers.reversed())
    
    输出：
    [four, three, two, one]
    
    随机顺序
    val numbers = listOf("one", "two", "three", "four")
    println(numbers.shuffled())
    
    输出：
    [three, two, one, four]

### 集合聚合操作 ###

*  min() and max() return the smallest and the largest element respectively;
 *  average() returns the average value of elements in the collection of numbers;
 *  sum() returns the sum of elements in the collection of numbers;
 *  count() returns the number of elements in a collection;
 *  maxBy()/minBy() take a selector function and return the element for which it returns the largest or the smallest value.
 *  maxWith()/minWith() take a Comparator object and return the largest or smallest element according to that Comparator.
 *  sumBy() applies functions that return Int values on collection elements.
 *  sumByDouble() works with functions that return Double.