kotlin数组和集合

一、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接口，还提供了方法来添加和移除元素、清空集合等。

集合类型	只读	可变
List	listOf	mutableListOf arrayListOf
Set	setOf	mutableSetOf hashSetOf linkedSetOf sortedSetOf
Map	mapOf	mutableMapOf hashMapOf linkedMapOf sortedMapOf

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代码，会抛出异常

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

如果改成可变集合，

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

就会依次打印出

str1
str2
str3
xxxx

2.

集合类型参数非空在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()
}