kotlin——数组（增删改查遍历）、haspMap（增删改查过滤）、for中断continue、去重、双数组查找

一、数组的增删改查

1、数组遍历（查）

 val array: Array<String> = Array(5) { (it * 10).toString() }
//        下标
        for (item in array.indices) {
            println("下标为==>" + item)
        }
//        项的内容
        for (item in array) {
            println("项为==>" + item)
        }
//        下标和项
        for ((item,i) in array.withIndex()) {
            println("项为==> $item;下标为==>$i")
        }

另一种写法（推荐）：

    val array: Array<String> = Array(5) { (it * 10).toString() }
    array.forEach {
            println("项的内容为：$it")
        }

        array.forEachIndexed { index, item ->
            println("下标为：$index;项的内容为：$item")
        }

A、使用map形式遍历(给数组的值都乘以2)

val num = listOf(1, 2, 3, 4, 5)
        val collect1 = num.stream().map { n: Int -> n * 2 }.collect(Collectors.toList())
        println(collect1) //[2, 4, 6, 8, 10]

B、使用filter形式遍历(找出大于2的数)

val num = listOf(1, 2, 3, 4, 5)
        val collect1 = num.stream().filter() { n: Int -> n > 2 }.collect(Collectors.toList())
        println(collect1) //[3,4,5]

C、使用anyMatch遍历（找出里面是否有2的值，返回boolean类型）

val num = listOf(1, 2, 3, 4, 5)
val collect1 = num.stream().anyMatch { n: Int -> n == 2 }
println(collect1) // true

// 对应kotlin的any

D、allMatch:检测state是否全部是2(返回true或false)

对应kotlin的all 

F、findFirst

val list = mutableListOf<Int>(2, 5, 6, 7, 8, 9, 10, 11)

        val aa = list.stream().filter {
           return@filter it > 4
        }.findFirst()

        Log.e("wy","结果==》"+ aa.getOrDefault(1)  ) 

// aa.isPresent 如果有大于4的值，是true 没有就是false
// aa.getOrDefault(1)如果有值就输出值5，如果没有就输出1
// aa.get()如果有值就输出值5，如果没有就会crash



// 找出满足条件的第一个的值，更简单的方式：
val aa = list.firstOrNull { it > 4 }
// 如果都没有则返回空，有满足条件的值则返回第一个5

G、最大最小值max、min

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

找出age最大值

val list: List<UserBean> = mutableListOf(UserBean(12, "张三"), UserBean(18, "李四"))
val maxUser = list.stream().max(Comparator.comparing(UserBean::age)).get()

找出age最小值

val list: List<UserBean> = mutableListOf(UserBean(12, "张三"), UserBean(18, "李四"))
val minUser = list.stream().min(Comparator.comparing(UserBean::age)).get()

H、从Person对象数组里提取出name 作为新数组

示例代码：

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

fun main() {
    val persons = arrayOf(
        Person("Alice", 20),
        Person("Bob", 25),
        Person("Charlie", 30)
    )

    val names = persons.map { it.name }.toTypedArray()
    println(names.joinToString()) // 输出：Alice, Bob, Charlie
}

核心代码 

// 常规的从PatientHead类里提取drugsCode 出来作为新数组
val drugCodeList = displayList.map { it.drugsCode }

// 如果有二级项，上面的代码就会报 body不能转为head的错误，此时需要使用到下面的代码
val drugCodeList = displayList.filterIsInstance<PatientHead>().map { it.drugsCode }

2、数组添加元素（不能add的解决方法）

在数组结尾加一个元素

 var array: Array<String> = Array(5) { (it * 10).toString() }
 val array1 = array.plus("100")

下面来说说不能add的解决方法：

        var adapterList11: List<Int> = ArrayList() // 此处adapterList11是不能直接使用add方法的
        val mIntList = mutableListOf<Int>()
        mIntList.add(1)
        mIntList.add(2)
        adapterList11 = mIntList

3、数组删除元素

删除数组第一个元素

 var array: Array<String> = Array(5) { (it * 10).toString() }
        val arr1=array.drop(1)

删除数组最后一个元素

 var array: Array<String> = Array(5) { (it * 10).toString() }
        val arr1=array.dropLast(1)

4、数组修改元素

 var array: Array<String> = Array(5) { (it * 10).toString() }
        array[2]="99"

5、数组去重

        data class User(val studentName: String, val studentAge: String)
        val list = mutableListOf(User("张三", "18"), User("李四", "18"), User("王五", "19"))
        val filterList = list.distinctBy {
            it.studentAge
        }
        Log.e("TAG", "==>$filterList")

运行结果：

6、双数组查找

// 创建一个 Map，用于快速查找 displayList 中的项
val displayMap = displayList.associateBy { it.tagId }

tagList.forEach { tag ->
    val item = displayMap[tag.tag_id]
    if (item != null) {
        // 已经找到
    }
}

二、map的增删改查过滤

val hashMap = hashMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)

1、hasMap增加元素

hashMap.put("uniapp",93)

批量放入多个 key-value 对，putAll(from: Map<out K, V>): Unit

2、hasMap删除元素

hashMap.remove("Go")

删除map里面的所有元素

 hashMap.clear()

3、hasMap修改元素

 hashMap["Java"] = 88

4、hasMap遍历所有元素

for ((key, value) in hashMap) {
            println("==>$key: $value")
        }

5、过滤（filter、any、all）

        //1、返回所有value大于90的数据
        val hashMap1 = hashMap.filter {
            it.value > 90
            //"o" in it.key       //key里面包含有字母o
        }
        println("hashMap1的值为==>: $hashMap1")//{Kotlin=92}

        //2、map里面是否有92的数据，返回true或者false
        val hashMap2 = hashMap.any {
            it.value == 92
        }
        println("hashMap2的值为==>: $hashMap2")//true

        //3、 map.all 如果所有的元素都满足给定的条件，则返回 true
        val hashMap3 = hashMap.all {
            it.value < 100 && it.value > 60
        }
        println("hashMap3的值为==>: $hashMap3")//true

三、for循环中断

1、return中断循环

 fun test3() {
        val list = ArrayList<Int>()
        list.add(1)
        list.add(2)
        list.add(3)
        list.add(4)

        run outside@{
            list.forEachIndexed { index, i ->
            println("-------------$index--------$i")                
                if (index == 2) { // 2改为5，就可以运行 “结束1” 这行输出代码，不然就会跳到outside标签
                    return@outside
                }
            }
            println("====结束1====")
        }
        println("====结束2====")
    }

运行结果：

如果中断用的是return@test3，这个日志“====结束2====”就不会运行

2、continue中断当前次循环

fun test3() {
        out@ for (i in 0..2) {
            outj@ for (j in 0..2) {
                if (j == 1) continue@outj
                println("j ===》 $j")// 1的时候就不运行
            }
        }
    }

日志

Kotlin 用 5 行代码实现快排算法

我想分享一个快速排序算法，这是一个很酷的函数编程的例子 share cool examples，当我看到这段代码的时候惊呆了，居然还可以这么写。

fun <T : Comparable<T>> List<T>.quickSort(): List<T> = 
    if(size < 2) this
    else {
        val pivot = first()
        val (smaller, greater) = drop(1).partition { it <= pivot}
        smaller.quickSort() + pivot + greater.quickSort()
    }
    
// 使用 [2,5,1] -> [1,2,5]
listOf(2,5,1).quickSort() // [1,2,5]