kotlin数组和集合

淡淡的烟草味﹌ 2022-03-10 08:54 280阅读 0赞

## 一、Kotlin数组 ##

1.对象数组

由Kotlin的main函数的写法，可以看出Kotlin中的对象数组写法与泛型的写法很像。

fun main(args: Array<String>)\{  
\}

声明对象数组的三种形式：

(1)使用arrayOf函数和指定的数组元素创建数组

//Java写法:
    String[] params1 = {"str1", "str2", "str3"};
    
    //kotlin写法:
    val params1 = arrayOf("str1", "str2", "str3")

(2).使用arrayOfNulls函数创建一个指定大小的并初始化每个元素为null的数组

//Java写法:
    String[] params2 = new String[12];
    
    //kotlin写法:
    val params2 = arrayOfNulls<String>(12)

(3)Array构造方法指定数组大小和一个生成元素的lambda表达式

这种方法创建的数组，其中的每个元素都是非空的，就像下面这样:

//kotlin写法:
    val params3 = Array<String>(3){i -> "str" + i }
    
    // 也可以这么写
     val params=Array(3){"str$it"}

因为数组的原始大小已经确定，在lambda表达式中接收数组的下标，并返回一个该下标位置的值。

2.基本数据类型的数组

var arr1 = arrayOf("java", "kotlin")
    var arrInt = arrayOf(1, 2, 3)
    //创建指定长度，元素为null的数组
    var arr2 = arrayOfNulls<String>(6)
    var arr2Duble = arrayOfNulls<Double>(5)
    arr2.set(0, "java")
    arr2[1] = "Kotlin"
    
    val intArray: IntArray = intArrayOf(1, 2)
    val charyArray:CharArray= charArrayOf('H','E','T','Y','W','K','B')
    val strArray:Array<String> = arrayOf("Hello","Kotlin")

还有ByteArray、ShortArray、LongArray、FloatArray、DoubleArray、BooleanArray

数组遍历

for (char in charyArray){
      println(char+"cccc")
    }

替换值

arr2.set(0, "java")
    arr2[1] = "Kotlin"

字符数组转换成字符串

charyArray.joinToString

## 二、集合 ##

1.集合与可空性

前边我们知道如果一个变量可以为空，我们在定义的时候就在该变量前边加个?，来表示该变量的值可为null。同样集合也可以事先在定义的时候知道是否持有null元素。对于一个集合，我们也应该考虑到，这个集合是否可以存储null值，对应于有包含可空值的集合和包含非空值的集合。

举例     val result=ArrayList<Int?>()   ArrayList<Int?>是能持有Int?类型值的列表，换句话说就是，可以持有Int或者是null。

这里需要注意的是，变量自己类型的可空性和用作类型参数的类型的可控性是有区别的。 即包含可空Int列表和包含Int的可空列表

包含可空的int列表 ：（指的是列表中单个值是可空的），列表本身始终不为null，但是列表中的每个值都可以为null，

包含int的可空列表：（指的是整个列表是可空的） 可能包含空引用，而不是列表实例，但列表中的元素保证是非空的

所以要小心决定是集合的元素还是集合本身可空。

2.只读集合和可变集合

Kotlin的集合设计与Java不同的是，它把访问集合数据的接口和修改集合数据的接口分开了。这种区别存在于最基础的使用集合的接口之中，Kotlin.collections.Collection。使用这个接口，可以遍历集合中的元素、获取集合的大小、判断集合中是否包含某个元素，以及执行其他从该集合中读取数据的操作。但是这个接口没有任何添加或移除元素的方法。

使用Kotlin.collections.MutableCollections接口可以修改集合中的数据。它继承了普通的Kotlin.collections.Collection接口，还提供了方法来添加和移除元素、清空集合等。

<table style="width:660px;"> 
 <thead> 
  <tr> 
   <th>集合类型</th> 
   <th>只读</th> 
   <th>可变</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>List</td> 
   <td>listOf</td> 
   <td>mutableListOf<br> arrayListOf</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>setOf</td> 
   <td>mutableSetOf<br> hashSetOf<br> linkedSetOf<br> sortedSetOf</td> 
  </tr> 
  <tr> 
   <td>Map</td> 
   <td>mapOf</td> 
   <td>mutableMapOf<br> hashMapOf<br> linkedMapOf<br> sortedMapOf</td> 
  </tr> 
 </tbody> 
</table>

3.集合的使用

声明一个集合并进行遍历，遍历的方式有4种

fun main(args: Array<String>) {
        val titleList = listOf<String>("推荐", "热点", "视频", "北京", "社会", "问答", "图片", "科技", "财经", "军事", "国际")
        //集合遍历的方法 for-in  forEach   迭代器遍历
        for (i in titleList.indices) {
            val item = titleList[i]
            println(item)
        }
    
        for (title in titleList) {
             println(title+"//")
        }
        
         val  iterator=titleList.iterator()
         while (iterator.hasNext()){
           val item=iterator.next()
           println(item+"//")
        }
    
        //forEach遍历 内部使用it指代每条记录
        titleList.forEach {
            println(it + "")
        }  
    }

使用filter来过集合

fun main(args: Array<String>) {
    
        val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
        fruits.filter { it.startsWith("a") }
                .sortedBy { it }
                .map { it.toUpperCase() }
                .forEach { println(it)    //集合遍历的方法 for-in  forEach   迭代器遍历
    }
    
    APPLE
    AVOCADO

使用map集合

只读Map

可变的MutableMap

fun main(args: Array<String>) {
    
        //map和MutableMap
        var goodsMap: Map<String, String> = mapOf("苹果" to "iphone8", "华为" to "Mate 10", "小米" to "小米9", "魅族" to "魅族Pro6s")
    
        //Pair方式初始化映射
        var goodsMutmap: MutableMap<String, String> = mutableMapOf(Pair("苹果", "iphone9"), Pair("华为", "荣耀10"), Pair("Vivo", "Vivox9"))
    
    
        //打印元素的总个数
        println(goodsMap.size)
        //获取某个key对应的value
        println(goodsMap.get("苹果"))  //iphone8
    
        println(goodsMap.getOrDefault("11","不存在值"))  //不存在值
    
        //获取所有的key，和 value
        for (key in goodsMap.keys){
            println(key)
        }
        for (value in goodsMap.values){
            println(value)
        }
    
        //可以将map转换成mutablemap
        val toMutableMap = goodsMap.toMutableMap()
        toMutableMap["苹果"]="iphone x max"
    
        println(toMutableMap.get("苹果"))  //iphone x max
    
        //移除元素
        toMutableMap.remove("小米")
        
    
        //也是3种遍历map的方式 for-in forEach iterator
        for (item in goodsMutmap) {
            println(item.key + "")
            println(item.value + "/")
        }
    
        val iterator = goodsMutmap.iterator()
        while (iterator.hasNext()){
            val item=iterator.next()
           println(item.key + "")
            println(item.value + "/")
        }
    
       // 使用forEach遍历
        goodsMap.forEach { key, value ->
            println(key)
            println(value)
        }
    
        goodsMutmap.forEach { key, value ->
            println(key)
            println(value)
        }
    
    }

## 三、Kotlin集合与Java集合互调 ##

Kotlin中创建的集合可以直接传递给Java方法进行操作。

Java集合调用Kotlin集合

fun main(args: Array<String>) {
        //创建一个只读集合
        val list= listOf("str1","str2","str3")
        Sample.modifyCollection(list)
    }

Java代码

public class Sample {
        public static void modifyCollection(Collection<String> collection) {
            if (collection != null) {
                collection.add("xxxx");
            }
    
            for (String x:collection){
                System.out.println(x);
            }
        }
    }

编译运行Kotlin代码，会抛出异常

![2019031115094648.png][]

Kotlin中的只读集合在Java中无法被约束。

如果改成可变集合，

val list= mutableListOf("str1","str2","str3")

就会依次打印出

str1  
str2  
str3  
xxxx

集合类型参数非空在Java中无法被约束  
在前面说过kotlin的集合可以在泛型的类型参数上约束该集合中的元素是否是非空的，但是因为Java中并没有将类型分为可空类型和非空类型，所以Java可以向集合中加入null值，就像下面这样:

//kotlin代码
    fun main(args: Array<String>) {
        val list1: MutableCollection<String> = mutableListOf("str1", "str2", "str3")
        //报错,元素必须是非空的
        //list1.add(null)
        Sample.modifyCollection(list1)
    }
    
    //Java代码
    import java.util.Collection;
    
    public class Sample {
        public static void modifyCollection(Collection<String> collection){
            if (collection != null){
                //Java可以向集合中添加null值
                collection.add(null);
            }
        }
    }

由此可以看出，Kotlin只能在Kotlin相关的编译层面去判断约束非空条件。

## 四、集合与数组互相转化 ##

最后再补充一下，可以将集合类型和数组类型进行相互，在编码过程中我们经常会用到:

fun main(args: Array<String>) {
    
        //声明一个数组
        val array1 = arrayListOf("str1", "str2", "str3")
    
        //将数组转化为集合
        val list1 = array1.toList()
    
        //将集合转化为数组
        val array2 = list1.toTypedArray()
    }

[2019031115094648.png]: /images/20220310/46888f7ca4814ad7ba189226cffe8403.png