kotlin--3.集合操作

// 创建一个不可变的只读List
val list1 = listOf(1, 2, 3)
println(list1)  // 输出：[1, 2, 3]

// 创建一个可变的List
val list2 = mutableListOf("apple", "banana", "orange")
println(list2)  // 输出：[apple, banana, orange]

// 创建一个可变的ArrayList
val list3 = arrayListOf(1.2, 3.4, 5.6)
println(list3)  // 输出：[1.2, 3.4, 5.6]

2.常见操作：

Kotlin 复制代码

val numbers = listOf(1, 2, 3, 4, 5)

// 访问元素
val firstNumber = numbers[0]
println(firstNumber)  // 输出：1

// 添加元素
val newList = numbers.toMutableList()
newList.add(6)
println(newList)  // 输出：[1, 2, 3, 4, 5, 6]

// 删除元素
newList.removeAt(2)
println(newList)  // 输出：[1, 2, 4, 5, 6]

// 修改元素
newList[1] = 10
println(newList)  // 输出：[1, 10, 4, 5, 6]

// 迭代元素
for (number in numbers) {
    println(number)
}

// 过滤元素
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers)  // 输出：[2, 4]

3.泛型约束

例如，在创建一个只包含整数的List时，可以指定List的泛型类型为Int：

Kotlin 复制代码

val numbers: List<Int> = listOf(1, 2, 3)

val mutableNumbers: MutableList<Int> = mutableListOf(1, 2, 3)

二.Set集合

Kotlin中的Set集合是一种不允许重复元素的集合。由于Set集合中的元素是无序的，因此不能通过索引获取元素。

1.创建Set集合：

Kotlin 复制代码

val set: Set<Int> = setOf(1, 2, 3)

val mutableSet: MutableSet<Int> = mutableSetOf(1, 2, 3)

2.Set集合的常见操作：

添加元素： 使用add方法添加元素到Set集合中。
Kotlin 复制代码
```
mutableSet.add(4)
```
删除元素： 使用remove方法从Set集合中删除指定元素。
Kotlin 复制代码
```
mutableSet.remove(3)
```
判断元素是否存在 ：使用contains方法判断Set集合中是否包含指定元素。
Kotlin 复制代码
```
val containsElement = mutableSet.contains(2)
```
获取Set集合的大小： 使用size属性获取Set集合的大小。
Kotlin 复制代码
```
val size = mutableSet.size
```

迭代遍历Set集合：

Kotlin 复制代码

for (element in mutableSet) {
    println(element)
}
---------------------
mutableSet.forEach { element ->
    println(element)
}

三.Map集合

在Kotlin中，Map集合用于存储键值对，其中键和值可以是任意类型。以下是创建Map集合和进行常见操作的示例：

创建Map集合：
- 使用mapOf函数创建不可变的Map集合：
  Kotlin 复制代码
```
val map: Map<String, Int> = mapOf("A" to 1, "B" to 2, "C" to 3)
```
- 使用mutableMapOf函数创建可变的Map集合：
  Kotlin 复制代码
```
val mutableMap: MutableMap<String, Int> = mutableMapOf("A" to 1, "B" to 2, "C" to 3)
```
Map集合的常见操作：
- 添加或更新元素 ：使用put方法添加或更新键值对。
  Kotlin 复制代码
```
mutableMap.put("D", 4)
mutableMap["E"] = 5
```
- 删除元素 ：使用remove方法从Map集合中删除指定键值对。
  Kotlin 复制代码
```
mutableMap.remove("C")
```
- 判断键是否存在 ：使用containsKey方法判断Map集合中是否包含指定键。
  Kotlin 复制代码
```
val containsKey = mutableMap.containsKey("A")
```
- 判断值是否存在 ：使用containsValue方法判断Map集合中是否包含指定值。
  Kotlin 复制代码
```
val containsValue = mutableMap.containsValue(2)
```
- 获取Map集合的大小 ：使用size属性获取Map集合的大小。
  Kotlin 复制代码
```
val size = mutableMap.size
```
- 获取键或值的集合 ：使用keys和values属性分别获取Map集合中的键和值的集合。
  Kotlin 复制代码
```
val keys = mutableMap.keys
val values = mutableMap.values
```
迭代遍历Map集合：
Kotlin 复制代码
```
for ((key, value) in mutableMap) {
    println("Key: $key, Value: $value")
}
---------------------
mutableMap.forEach { (key, value) ->
    println("Key: $key, Value: $value")
}
```

8.hashMap

Kotlin 复制代码

fun main() {
    val hashMap = HashMap<String, Int>()

    // 添加键值对
    hashMap["Alice"] = 25
    hashMap["Bob"] = 30
    hashMap["Charlie"] = 35

    // 获取键对应的值
    val age = hashMap["Alice"]
    println(age) // 输出: 25

    // 遍历键值对
    for ((name, age) in hashMap) {
        println("$name: $age")
    }
    // 输出:
    // Alice: 25
    // Bob: 30
    // Charlie: 35

    // 检查键是否存在
    val containsKey = hashMap.containsKey("Alice")
    println(containsKey) // 输出: true

    // 删除指定键值对
    hashMap.remove("Bob")
    println(hashMap) // 输出: {Alice=25, Charlie=35}

    // 清空哈希表
    hashMap.clear()
    println(hashMap.isEmpty()) // 输出: true
}

四.Stream流

在Kotlin中，Stream流操作提供了一种功能强大的方式来处理集合数据。可以使用扩展函数和lambda表达式来对集合进行处理。以下是一些常见的Stream流操作方法及其示例：

1.map

map**：**对集合中的每个元素应用函数，并将结果收集到一个新的集合中。

Kotlin 复制代码

val numbers = listOf(1, 2, 3, 4, 5)
val squaredNumbers = numbers.map { it * it }
println(squaredNumbers)   // 输出：[1, 4, 9, 16, 25]

2.filter

**filter：**根据指定的条件筛选集合中的元素。

Kotlin 复制代码

val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers)   // 输出：[2, 4]

3.reduce

reduce：将集合中的元素进行累积操作，返回一个结果。

Kotlin 复制代码

val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.reduce { acc, num -> acc + num }
println(sum)   // 输出：15

4.forEach

**forEach：**对集合中的每个元素应用指定的操作。

Kotlin 复制代码

val numbers = listOf(1, 2, 3, 4, 5)
numbers.forEach { println(it) }

5.sorted

**sorted：**对集合中的元素进行排序。

Kotlin 复制代码

val numbers = listOf(4, 2, 5, 1, 3)
val sortedNumbers = numbers.sorted()
println(sortedNumbers)   // 输出：[1, 2, 3, 4, 5]

6.distinct

distinct**：**去除集合中的重复元素。

Kotlin 复制代码

val numbers = listOf(1, 2, 2, 3, 3, 3, 4, 4, 5)
val distinctNumbers = numbers.distinct()
println(distinctNumbers)   // 输出：[1, 2, 3, 4, 5]

7.综合案例

Kotlin 复制代码

data class Person(val name: String, val age: Int)

fun main() {
    val people = listOf(
        Person("Alice", 25),
        Person("Bob", 30),
        Person("Charlie", 35),
        Person("David", 40),
        Person("Emma", 45)
    )

    val filteredPeople = people.filter { it.age > 30 }
        .sortedByDescending { it.age }
        .map { "${it.name} (${it.age})" }

    println(filteredPeople)
}

在上述案例中，我们有一个包含Person对象的人员列表。我们首先使用filter函数筛选出年龄大于30岁 的人员，然后使用sortedByDescending函数按年龄降序排序 ，最后使用map函数将**Person对象转换为格式化的字符串。**最终，我们将过滤和格式化后的结果打印出来。

输出结果将是：

[Emma (45), David (40), Charlie (35)]