Skip to content

Latest commit

 

History

History
190 lines (129 loc) · 7.12 KB

5数组和集合.md

File metadata and controls

190 lines (129 loc) · 7.12 KB
Raw

数组和集合

Kotlin为数组增加一个Array类，为元素是基本类型的增加XxxArray类。Kotlin自己提供了一套集合体系，抛弃了java中的Queue(队列)集合。增加了可变集合和不可变集合概念。它的集合体系由三种集合组成：

List、Set、Map。

kotlin的List代表有序、集合元素可重复的集合。Set代表无序，集合元素不可重复的集合。Map则采用key-value形式存储，每项都由key-value对组成。

  • 数组

    1、kotlin数组使用Array类代表。由此可见Kotlin数组就时Array类的实例。因此数组也是引用类型

    • 使用arrayOf()、arrayOfNulls()、emptyArray()工具函数
    • 使用Array(size:Int, init:(int) -> T)构造器

    Array类要求它的元素必须是引用类型，如果将基本类型存入进去，会将这些值自动装箱成包装类的实例，然后添加到Array中。kotlin还提供了8种基本类型的数组。ByteArray、ShortArray、IntArray、 LongArray、 CharArray、 FloatArray、 DoubleArray、 booleanArray

    var intArr = intArrayOf(1,2,3)
var charArr = CharArray(5) {((it * it)+97).toChar()}
//    doubleArrayOf(null,1.2) //基本类型数组不能包含null值
println(Arrays.toString(intArr))   //[1, 2, 3]
println(Arrays.toString(charArr))  //[a, b, e, j, q]
}

    2、数组的常用方法就是访问数组的元素，包括对数组元素进行赋值和取出数组元素的值。访问数组元素通过数组引用变量后跟一个方括号([])实现。方括号里是数组的索引。在kontlin中，数组的方括号运算符实际上就是调用get(index)和set(index,value)方法。

    3、数组提供一个indices属性，该属性返回数组索引的区间。

    var arr = arrayOf("a",1,"b",2)
for(i in arr.indices) {
    println(arr[i])
}
//使用indices索引性能好
  • 集合

    Kotlin的集合由两个接口派生：Collection和Map。 kotlin只提供了HashSet、 HashMap、 LinkedHashMap、 LinkedHashSet、 ArrayList 5个可变集合

    • Set集合

      Kotlin中Set集合类是通过别名借用了java集合框架中的类。因此不推荐使用构造器创建Set，而推荐使用kotlin提供的工具函数来创建Set集合。

      • setOf() ：返回LinkedHashSet的实例。有序不可重复集合

      • MutablesetOf()：返回LikedHashSet的实例，有序不可重复集合

      • hashSetOf()：返回HashSet的实例，无序不可重复

      • LinkedSetOf()：返回LikedHashSet的实例，有序不可重复集合

      • SortedSetOf()：返回TreeSet的实例，有序不可重复集合

         var set1 = setOf(2,1,3,"b","c","a","c")
 println(set1.toString())//2, 1, 3, b, c, a]
 println(set1.javaClass.name)//java.util.LinkedHashSet

 var set3 = linkedSetOf<Any>(2,1,3,"b","c","a","c")    	 
 println(set3.toString())//[2, 1, 3, b, c, a]
 println(set3.javaClass.name)//java.util.LinkedHashSet

 var set4 = mutableSetOf(2,1,3,"b","c","a","c")
 println(set4.toString())//[2, 1, 3, b, c, a]
 println(set4.javaClass.name)//java.util.LinkedHashSet

 var set2 =  hashSetOf(2,1,3,"b","c","a","c")
 println(set2.toString())//[1, a, 2, b, 3, c]
 println(set2.javaClass.name)//java.util.HashSet

 var set5 = sortedSetOf("b","c","a","c")   //需要一样的数据，需要排序
 println(set5.toString())//[a, b, c]
 println(set5.javaClass.name)//java.util.TreeSet

    • Set相关调用

       var test1 = setOf("kotlin","java","go")

println(test1.all { it.length > 3})  //false
println(test1.any{it.length > 3})   //true

var map = test1.associateBy { "ss"+it+"aaa" }
for(item in map){
    println(item.key+" : "+item.value)
}
//    sskotlinaaa : kotlin
//    ssjavaaaa : java
//    ssgoaaa : go

//-------------------------------------------
// var arr = test1.drop(2)
//println(arr) //[go]
var arr1 = test1.filter { it.contains("o") }
println(arr1)//[kotlin, go]

var arr2 = test1.find { it.length > 3 }
println(arr2)  //kotlin  直接找出第一个就返回，如果都不存在 返回null

println(test1.indexOf("go")) //2

println(test1.map { "我爱学习${it}课程" }) //[我爱学习kotlin课程, 我爱学习java课程, 我爱学习go课程]
println(test1.maxBy { it.drop(2) }) //java

var test2 = test1.fold("",{acc, s -> acc+s })  //kotlinjavago
println(test2)

    • List集合

      List最大特征是集合元素都有对应的索引。List集合允许使用重复元素。默认按元素的添加顺序设置元素的索引。

      • listOf():该函数返回不可变List集合。该函数可接收0或者多个参数，这些参数作为集合的元素。

      • listOfNotNull():该返回返回不可变List集合。与前一个相比，该函数自动会剔除null元素。

      • mutableListOf():该函数返回可变MutableList集合。

      • arrayListOf():该函数返回可变ArrayList集合。

        var a = listOf(1, 2, null, null, 4)
println(a.javaClass.name)  //java.util.Arrays$ArrayList
//    a.add()   //不可变集合
a.forEach { println(it) }  //1,2,null,null,4

var b = listOfNotNull(1, 2, null, null, 4)
println(b.javaClass.name)  //java.util.ArrayList
//    a.add()   //不可变集合
b.forEach { println(it) }  //1,2,4

var c = mutableListOf(2, 3, null, 4)
println(c.javaClass.name)  //java.util.ArrayList
c.add(c.size - 1, 1)
c.forEach { println(it) } //2,3,null,1,4

 var d = arrayListOf(3,2,null,4)
println(d.javaClass.name)  //java.util.ArrayList
 d.add(1)
d.forEach { println(it) } //3,2,null,4,1

    • Map集合

      Map集合用于保存key-value对，分为可变集合和不可变集合

      • mapOf(): 返回不可变map集合。

      • mutableMapOf(): 返回可变map集合。

      • hashMapOf(): 返回可变map集合。

      • linkedMapOf():返回可变map集合。

      • sortedMapOf():返回可变TreeMap集合。

        var a = mapOf("a" to 1,"c" to 2,"b" to  3)
println(a.javaClass.name)  //java.util.LinkedHashMap
a.forEach { (t, u) -> println("$t : $u") } //a:1,c:2,b:3

var b = hashMapOf("a" to 1,"c" to 2,"b" to  3)
println(b.javaClass.name) //java.util.HashMap
b.put("d" , 1)
b.forEach{(t,u)-> println("$t : $u")}//a:1,c:2,b:3,d:1

var c =  linkedMapOf("a" to 1,"c" to 2,"b" to  3)
println(c.javaClass.name)  //java.util.LinkedHashMap
c.put("d",1)
c.forEach { t, u -> println("$t : $u") }//a:1,c:2,b:3,d:1
 var d =  mutableMapOf("a" to 1,"c" to 2,"b" to  3)
 d.put("d",1)
 println(d.javaClass.name) //java.util.LinkedHashMap
 d.forEach { (t, u) -> println("$t : $u") } //a:1,c:2,b:3,d:1

var e = sortedMapOf("a" to 1,"c" to 2,"b" to  3)
e.put("d",1)
println(e.javaClass.name) //java.util.TreeMap 
e.forEach { (t, u) -> println("$t : $u") }//a : 1 ,b : 3 ,c : 2 ,d : 1