数学里有向量和矩阵，在Matlab里用中括号的数组就能表示横向量、列向量、矩阵。

横向量：[1,2,3]

列向量：[1;2;3]

2×3的矩阵：[1,2,3;4,5,6]

 

Kotlin里，有数组和集合。

本文是在《Kotlin从基础到实践》里学习数组和集合。

数组

能实现遍历、修改、查询等操作，不能改变数组的长度，也就是说不能添加和删除元素。楼主在这里就遇到过坑。

 

fun main() {
    // 定义
    val arr1 = intArrayOf(1,2,3)
    val arr2 = arrayOf(1,2,3,4,3)
    val arr3 = arrayOf("a", "b")

    // 访问元素
    println("arr1[0] = ${arr1[0]}")
    println("arr2[2] = ${arr2[2]}")
    println("arr3[1] = ${arr3[1]}")

    // 数组长度
    val len = arr1.size
    println("长度：len = $len")

    // 遍历，用for循环
    for (_arr1 in arr1) {
        println(_arr1)
    }

    // 遍历角标
    for ((index, _arr1) in arr1.withIndex()) {
        println("遍历角标：元素${_arr1}在第${index}个位置")
    }

    // 修改
    arr2[0] = 10
    arr2[1] = 12
    arr2.forEachIndexed { index, i ->
        println("修改：元素${i}在第${index}个位置")
    }

    // 在arr2中，3出现2次，寻找第一个和最后一个3的角标
    println("第一种方法：第1个元素3的角标为：${arr2.indexOf(3)}")

    val index1 = arr2.indexOfFirst {
        it == 3
    }
    println("第二种方法：第1个元素3的角标为：$index1")

    println("第一种方法：最后1个元素3的角标为：${arr2.lastIndexOf(3)}")

    val index2 = arr2.indexOfLast {
        it == 3
    }
    println("第二种方法：最后1个元素3的角标为：$index2")
    
}

 

集合

在MATLAB里，向量的元素，矩阵的行列可以轻易增加或者删除。

Kotlin里数组长度不可变，而Kotlin里的集合类，能储存任意类型对象，而且长度可变。

集合类有单列集合（Iterable）和双列集合（Map）：

单列集合通常从Collection接口开始，有3个子接口：Set，List，MutableCollection。

不可变List

仅供只读操作，用不可变集合能 提高内存效率。

fun main() {
    // 创建列表
    val list1 = listOf<Int>()   // 创建空列表
    val list2 = listOf(1)
    val list3 = listOf(1,2,3,4,5)

    // 查询
    if (list3.isEmpty()) {
        println("集合中没有元素")
        return
    } else {
        println("集合中有元素，元素个数为：${list3.size}")
    }

    if (list3.contains(1)) {
        println("集合中包含元素1")
    }

    // 遍历
    println("遍历集合中的所有元素")
    val mIndex = list3.iterator()   // 获取集合中元素的迭代器
    while (mIndex.hasNext()) {
        print(mIndex.next().toString() + "\t")
    }

    println("\n遍历集合中的所有元素")
    val iterator1 = list3.listIterator()   // 获取集合中元素的迭代器
    while (iterator1.hasNext()) {
        print(iterator1.next().toString() + "\t")
    }

    println("\n从索引1开始遍历集合中的元素")
    val iterator2 = list3.listIterator(1)
    while (iterator2.hasNext()) {
        print(iterator2.next().toString() + "\t")
    }
    print("\n")

    // 批量操作
    if (list3.containsAll(list2)) {
        println("list3包含了list2")
    }

    // 检索操作
    val longList = listOf(2,3,1,3,2,1,2,1,2,1)
    println("集合中索引为0的元素是：${longList[0]}")
    println("元素1第1次出现的位置是：${longList.indexOf(1)}")
    println("元素1最后1次出现的位置是：${longList.lastIndexOf(1)}")
    println("截取集合中索引为1~4的元素${longList.subList(1, 4)}")

}

结果

可变MutableList

List的所有操作MutableList都可以用，MutableList还有元素的添加和删除操作。

fun main() {
    val muList = mutableListOf(1,2,3,4,5,6,7)
    muList.add(10)
    println("向集合中添加10：\t\t${muList}")

    muList.remove(1)
    println("移除集合中的元素1：\t${muList}")

    muList[4] = 20
    println("用20替代索引为4的元素：\t${muList}" )

    muList.add(1, 30)
    println("在索引为1处插入30：\t${muList}")

    muList.removeAt(2)
    println("删除索引为2的元素：\t${muList}")
    
    // 批量操作
    val muList1 = mutableListOf("北京", "上海")
    val muList2 = mutableListOf("北京", "上海", "深圳")

    muList2.removeAll(muList1)
    println("muList2移除muList1后的元素为：${muList2}")

    muList2.addAll(muList1)
    println("muList2添加muList1后的元素为：${muList2}")

    if (muList2.retainAll(muList1)) {
        println("muList2包含muList1")
    } else {
        println("muList2不包含muList1")
    }
    
    muList2.clear()
    println("muList2清除所有元素后，该集合的元素个数为：${muList2.size}")

}

结果

 

 

不可变Set和可变MutableSet

与List相比操作基本相同，只是Set里的元素是不可重复的

fun main() {
    val mSet = setOf(1,4,6,2,4,5,6,7,3,2,6,6)
    println(mSet)
}

结果

 

不可变Map

Map接口是一种双列集合，包含键对象（key）和值对象（value）

fun main() {
    val mMap = mapOf("1" to "江小白", 2 to "小小白", 3 to "江小小")

    if (mMap.isEmpty()) {
        println("mMap中没有元素")
    } else {
        println("mMap中有元素，元素个数为：${mMap.size}")
    }

    if (mMap.containsKey(2)) {
        println("mMap集合中的Key包含2")
    } else {
        println("mMap集合中的Key不包含2")
    }

    if (mMap.containsValue("3")) {
        println("mMap集合中的Value包含元素3")
    } else {
        println("mMap集合中的Value不包含元素3")
    }

    println("mMap集合中Key为'1'对应的Value是：${mMap["1"]}")

    // 遍历
    val mapKey = mMap.keys
    val mapValue = mMap.values
    println("集合中所有的key为：$mapKey")
    println("集合中所有的value为：$mapValue")

    val mapEntry = mMap.entries
    mapEntry.forEach{
        println("Key: ${it.key} , value: ${it.value}")
    }
}

结果

可变MutableMap

fun main() {
    val muMap = mutableMapOf("1" to "江小白", 2 to "小小白", 3 to "江小小")
    muMap[4] = "江江"
    println("添加元素后的集合：$muMap")

    muMap.remove("1")
    println("删除元素后的集合为：$muMap")

    // 批量操作 遍历
    val muMap1 = mutableMapOf("狗" to "泰迪", 2 to listOf(1,2,3), 3 to "树")
    val muMap2 = mutableMapOf(4 to "猫", 5 to "狗", 6 to "猪")

    muMap1.putAll(muMap2)
    val muMapEntry = muMap1.entries
    muMapEntry.forEach {
        println("Key: ${it.key} ,  Value: ${it.value}")
    }

    // 清空
    muMap1.clear()
    println("集合中元素的个数 = ${muMap1.size}")
}

结果

Map的键值可以用不同的数据结构