Kotlin集合

集合派生的两个接口

• Collection
  • MutableCollection
    • MutableSet 可变集合
    • MutableList 可变集合
  • Set 不可变集合
  • List 不可变集合
• Map

集合的分类

• 可变集合
• 不可变集合

1）Set
set的声明：

 //通过setOf（）创建不可变集合，元素可以为0个或多个
    var result = setOf("Java","Python","C++")
    print(result)//[Java, Python, C++]
   
    //mutableSetOf  元素可以为0个或多个
    var result2 = mutableSetOf("Java","Python","C++")
    print(result2)//[Java, Python, C++]
   
    //hashSetOf   不保证元素的顺序   元素可以为0个或多个
    var result3 = hashSetOf("Java","Python","C++")
    print(result3)//[Java, C++,Python]
   
   //linkedSetOf   元素可以为0个或多个
    var result4 = linkedSetOf("Java","Python","C++")
    print(result4)//[Java, Python, C++]
   
   //sortedSetOf    对元素进行排序   元素可以为0个或多个
    var result5 = sortedSetOf("Java","Python","C++")
    print(result5)//[Java, Python, C++]

set的使用：和Array差不多

 //创建不可变集合
   var set = setOf("java","python","C++","C")
   
   //判断是否所有元素的长度都大于4
   print(set.all({it.length > 4}))
   
   //判断是否任一元素的长度都大于4
   print(set.any({it.length > 4}))
   
   //以Lambda表达式的值为key，集合元素为value，组成Map集合
   print(set.associateBy({"${it}的值"}))//{java的值=java, python的值=python, C++的值=C++, C的值=C}
   
   //使用in !in运算符
   print("java" in set);//true
   print("java" !in set)//false
   
  
  //set删除元素
   print(set.drop(2))//删除集合前两个元素
   
   //对集合进行过滤
   print(set.filter({"C" in it}))//[C++, C]
   
   //查找set中的元素并返回，没有返回null
   print(set.find({"C++" in it}))//C++
     
   //将 Set 集合中的所有字符串拼接在一起
   print(set.fold ("",{ace,e ->ace+ e}))//javapythonC++C
   
   //查找某个元素出现的位置
   print(set.indexOf("C++"))//2  索引为2
   
   //将每个集合元素映射成新值，返回所有新值组成的 Set 集合
   print(set.map({"疯狂"+it}))//[疯狂java, 疯狂python, 疯狂C++, 疯狂C]
   
   //max()和min()分别获取最大值和最小值
   val result2 = setOf(1,3,4)
   print(result2.max());print(result2.min());
    
   //反转集合顺序
   print(result2.reversed())//[4, 3, 1]

遍历Set

• 使用for ... in

 var set = setOf(1,2,3,4,5)
  for(item in set){
        print(item)
  }

• 使用forEach:需要接受 Lambda 表达式作为参数

set.forEach({print(it)})

• 使用了 indices返回集合索引区间

  for(index in set.indices){
       print(index)//索引
       print(set.elementAt(index))//某个元素
  }

mutableSetOf可变集合 添加 删除 清空

  var set = mutableSetOf(1,2,3,4,5)
  var set2 = mutableSetOf(6,7,8)
 
  //添加集合  add   addAll
  set.add(9)
  print(set)//[1, 2, 3, 4, 5, 9]
  
  set.addAll(set2)
  print(set)//[1, 2, 3, 4, 5, 9, 6, 7, 8]
  
  
  //删除集合  remove   removeAll
  set.remove (1)    
  set.removeAll(setOf(1,2))
  
  //清空集合
  set.clear()

Set和mutableSetOf都提供了Iterator 。

• Set只有 hasNext和 next()两个方法
• mutableSetOf除了hasNext和 next()，还有remove()方法，可用于遍历时删除元素

    var set = mutableSetOf(1,2,3,4,5)
    var it = set.iterator()
    
    while(it.hasNext()){
        var item = it.next()
        if(item==1){
            it.remove()
        }
    }
    print(set)//[2, 3, 4, 5]

2）List

List的声明：

• listOf（）： 该函数返回不可变的 list集合。该函数可接受 0个或多个参数。
• listOfNotNull ():该函数与前一个函数的唯一区别是，该函数会自动去掉传入的 null。
• mutablelistOf():可变集合
• arraylistOf(）： 该函数返回可变的 ArrayList 集合。如果要使用ArrayList，就用arraylistOf声明，不要用mutablelistOf声明。

    //listOf                     不可变集合
    var list = listOf(1,2,3,4,5)
    print(list) //[1, 2, 3, 4, 5]
    
    //listOfNotNull         不可变集合
    var list2 = listOfNotNull(null,1,2,3,4,5)
    print(list2)//[1, 2, 3, 4, 5]
    
    //arrayListOf           可变集合
    var list3 = arrayListOf(1,2,3,4,5)
    print(list3)//[1, 2, 3, 4, 5]
    
     //listOfNotNull        可变集合
    var list4 = mutableListOf(1,2,3,4,5)
    print(list4)//[1, 2, 3, 4, 5]

List的方法：

• 通过 [index]访问集合元素
• indexOf返回元素在List中的位置
• lastlndexOf返回集合元素在List中最后出现一次的位置
• subList获取集合元素的子元素

list.subList((1,3))//包含下标1，不包含3

对可变List(mutableListOf,arrayListOf)的操作

    list3[0] = 10           //替换元素
    list3.add(2,100)   //添加元素
    list3.removeAt(1)  //移除某个元素
    list3.clear()   //清空元素

3）Map集合

map的声明:
Kotlin 需要使用 to 指定 key-value

  //key ralue 对按添加顺序排列     不可变map
   var map = mapOf("value1" to 1,"value2" to 2,"value3" to 3)
   print(map)//{value1=1, value2=2, value3=3}
   
   // key-value 对按添加顺序排列   可变map
   var mutableMapOf = mutableMapOf("value1" to 1,"value2" to 2,"value3" to 3)
   
   //／不保证 key-value 对的顺序   可变map
   var hashMap = hashMapOf("value1" to 1,"value2" to 2,"value3" to 3)
   
   // key-value 对按添加顺序排列    可变map
   var linkedMapOf = linkedMapOf("value1" to 1,"value2" to 2,"value3" to 3)
   
   //key-value 对按 key 由小到大排列  可变map
   var sortedMapOf = sortedMapOf("value1" to 1,"value2" to 2,"value3" to 3)

Map使用方法：
all
any

通过in !in 来判断map中是否存在某个key

 var map = mapOf("value1" to 1,"value2" to 2,"value3" to 3)
 print("value1" in map)//true

 //对map进行过滤，要求key包含"value1"
 print(map.filter({"value1" in it.key}))//{value1=1}

遍历Map:

• 通过 [] 来获取value值

   var map = mapOf("value1" to 1,"value2" to 2,"value3" to 3)
   print(map["value1"])  //1

• map遍历的几种方式

   var map = mapOf("value1" to 1,"value2" to 2,"value3" to 3)
   
   //第一种：entrie包含了key-value
   for(entrie in map.entries){
       print("${entrie.key}的值是${entrie.value}\n")
   }
   
   //第二种：先遍历Key，通过key获取value
    for(key in map.keys){
       print("${map[key]}")
   }
   
   //第三种：直接获取key-value
   for((key,value) in map){
       print("key是${key},value是${value}")
   }
   
   //第四种：使用Lambda表达式
   map.forEach({print("${it.key} -> ${it.value}")})
    

Map的操作：

• clear():清空所有的key-value
• put(key,value):放入key-value，如果已经有，就会覆盖原来的。
  除了put放入元素外，还可以使用 [] 更加简单：

//以下这两种是一样的，[]这种更简单
mutableMap [”Swift” ]1 = 9000
mutableMap.put （”Swift ”， 9000)

• putAll(Map对象)：批量放入多个key-value。
• remove(key):移除某个key-value键值对。