Kotlin数组相关学习笔记（一维数组）

Kotlin数组相关学习笔记

---

前言

Kotlin数组相关学习笔记。

---

提示：以下是本篇文章正文内容

一、kotlin数组？

Kotlin 为数组增加了一个 Array 类，为元素是基本类型的数组增加XxxArray 类（其中Xxx 可以是 Byte 、 Short、 Int 等基本类型〉。Kotlin 的数组使用 Array<T＞类代表，是一个 Array 类的实例，因此 Kotlin数组也是引用类型。

二、使用数组

1.创建数组

使用 arrayOf（）、 arrayOfNulls（）、 emptyArray（）工具函数

1.1 使用 arrayOf（）函数：这种方式无须显式指定数组的长度，但需要依次列出每个数组元 素。因此，这种方式其实就相当于 Java 数组的静态初始化。使用这种方式创建数组时， 由于程序己经给出了每个数组元素，因此 Kotlin 可以推断出数组元素的类型。所以， 不需要在 arrayOf（）函数上使用泛型来指定数组元素的类型。

//类型是引用类型，使用arrayOf
var strArray = arrayOf("kotlin","java","android")

//如果是基本数据类型，可使用对应的XxxArrayOf
var intArray = intArrayOf(3,13,5,54)
var floatArray = floatArrayOf(3f,13f,5f,54f)
...

1.2 使用 arrayOfNulls（）函数：这种方式需要显式指定数组的长度，数组元素全部被初始化 为 null，可见这种方式就是 Java 数组的动态初始化。使用这种方式创建数组时，由于 Kotlin 无法推断出数组元素的类型，所以需要在 arrayOfNulls（）函数上使用泛型来指定 数组元素的类型。

 var  intArray = arrayOfNulls<Int>(5)

1.3 使用 emptyArray（）函数： 这种方式会创建一个长度为 0 的空数组。由于没有指定数组 元素，因此需要使用泛型来指定数组元素的类型。

  val emptyArray:Array<String> = emptyArray<String>()

使用 Array(size: Int, init: (Int) -> T）构造器

1.4 使用 Array(size: I川， init: (Int) -> T）构造器： 这种方式需要显式指定数组的长度，并可 通过 Lambda 表达式来动态计算各数组元素的值。这种方式是原来 Java 所不具备的。

  //使用构造器（it表示数组的下标，{}中表达式的结果为对应下标数组元素的值）
    //如果是引用类型
  val stringArray:Array<String> = Array<String>(5) { (it +1).toString()}
    //如果是基本数据类型，可使用XxxArray
  val intArray2: IntArray = IntArray(5) { it }
   

2.数组的使用

2.1 访问与修改 ：与java类似，访问数组元素，使用变量名后跟一个方括号([])，方括号里的索引值也是0~length-1，Koti in 的方括号运算符其实是 get(index）和 set(index, value）方法， 因此，当程序使用［i］获取数组元素的值时，实际上就是调用 get(index）方法；当使用［index］对 数组元素赋值时，实际上就是调用 set(index , value）方法。

//访问和修改数组元素
  val strArray = arrayOf("kotlin", "java", "android")
        
//修改数组元素
  strArray[1] = "kotlin good"
  strArray.set(2,"java good")
        
//访问数组元素
  Log.d("arrayTest", strArray[1])
  Log.d("arrayTest", strArray.get(2))
        
  //打印结果
  kotlin good 
  java good

3.遍历数组

3.1使用数组索引(类java写法不推荐，参考3.3)：所有的数组都提供了一个 size 属性，可以通过循环来遍历该数组的每个数组元素。

   //遍历数组 写法一：size
   //0 until arr.size 相当于  [0,length -1]
   val arr = arrayOf("21", 3, 6f, 4.0, 'd')
   for (index in 0 until arr.size){
       Log.d("arrayTest", "${arr[index]}")
   }

   //输出
   arrayTest：21
   arrayTest：3
   arrayTest：6.0
   arrayTest：4.0
   arrayTest：d

3.2 for-in 循环可自动遍历数组的每个元素

   //遍历数组 写法二，for in 直接遍历
   val arr = arrayOf("21", 3, 6f, 4.0, 'd')
   for (item in arr){
   Log.d("arrayTest", "$item")
   }

   //输出
   arrayTest：21
   arrayTest：3
   arrayTest：6.0
   arrayTest：4.0
   arrayTest：d

3.3 kotlin还提供了一个 indices 属性，该属性即可返回数组的索引区间。利用 indices 属性返回的区间来遍历数组。

   //遍历数组 写法三：indices 
   //0 until arr.size 相当于  [0,length -1]
   val arr = arrayOf("21", 3, 6f, 4.0, 'd')
   for (index in arr.indices ){
       Log.d("arrayTest", "${arr[index]}")
   }
   //拓展：防止数组越界异常，还可以检查下标是否在界限内
   if( i in books.indices) // 意为：i >=0  && i < books . size

   //输出
   arrayTest：21
   arrayTest：3
   arrayTest：6.0
   arrayTest：4.0
   arrayTest：d

注意：使用for-in 循环来遍历数组元素或集合元素时，不允许对循环变量进行赋值。 对数组使用 for-in 循环依然会被编译成使用基于索引的循环，井不会创建迭代器进行遍历，
因此使用 for-in 循环遍历数组依然具有很好的性能。

3.4 forEach遍历数组（别纠结这个it,你敲得时候自动会有的，甚至你还可以改名字）

   //遍历数组 写法四，forEach遍历数组
   val arr = arrayOf("21", 3, 6f, 4.0, 'd')
   arr.forEach {
      Log.d("arrayTest", "$it")
   }
   
   //输出
   arrayTest：21
   arrayTest：3
   arrayTest：6.0
   arrayTest：4.0
   arrayTest：d

3.5 迭代器遍历数组

   //遍历数组 写法五，forEach遍历数组
   val arr = arrayOf("21", 3, 6f, 4.0, 'd')
   val iterator = arr.iterator()
       iterator.forEach {
       Log.d("arrayTest", "$it")
    }
   
   //输出
   arrayTest：21
   arrayTest：3
   arrayTest：6.0
   arrayTest：4.0
   arrayTest：d

3.6 withlndex()： 如果程序需要同时访问数组的索引和元素，则也可使用数组的 withlndex() 方法，该方法返
回一个 Iterable 对象，该对象的所有元素都是 IndexedValue。

   //遍历数组 写法六，withlndex() 遍历数组
   val arr = arrayOf("21", 3, 6f, 4.0, 'd')
   for ((index,value) in arr.withIndex()){
      Log.d("arrayTest", "第 ${index + 1}个值为 $value")
   }  
   
  //输出
  arrayTest: 第 1 个值为 21
  arrayTest: 第 2 个值为 3
  arrayTest: 第 3 个值为 6.0
  arrayTest: 第 4 个值为 4.0
  arrayTest: 第 5 个值为 d

3.7 以上等等…

4.数组的常用方法

all(predicate: (T} -> Boolean ）： 使用 Lambda 表达式要求所有数组元素都满足该表达式， 如果都满足，那么该方法返回 true 。
any(predicate: (T} -> Boolean ）： 使用 Lambda 表达式要求任一数组元素都满足该表达 式，如果都满足，那么该方法返回 true 。
aslist（）： 将该数组转换成 List 集合。~ associate(transform: (T) -> Pair<K, V＞）：使用 Lambda 表达式根据数组元素进行计算， 返回元素是＜K,V＞的 Map 集合。
associateBy(keySelector: (T) -> K）：使用 Lambda 表达式根据数组元素进行计算，返 回元素是＜K,T＞的 Map 集合。
associateBy(keySelector: (T) -> K, value Transform: (T) -> V）：使用 Lambda 表达式根 据数组元素进行计算，返回元素是＜K,V＞的 Map 集合。
associateByTo(dest: M, keySelector: (T) -> K）：使用 Lambda 表达式根据数组元素进 行计算，并将计算得到的＜K, T＞对添加到可变 Map 集合中，该方法返回被修改的 dest 集合。
associateByTo(dest: M, keySelector: (T) -> K, valueTransform: (T) -> V）：使用 Lambda 表达式根据数组元素进行计算，并将计算得到的＜K, V＞对添加到可变 Map 集 合中，该方法返回被修改的 dest 集合。
associateTo(dest: M, transform: (T) -> Pair<K, V＞）：使用 Lambda 表达式根据数组元 素进行计算，并将计算得到的＜K,V＞对添加到可变 Map 集合中，该方法返回被修改的 dest 集合。
average（）： 计算数值型数组的平均值。
binarySearch(element: T, comparator: Comparator, fromlndex: Int = 0, tolndex: Int = size ）：使用二分法查询 element 元素值在数组中出现的索引：如果数组 不包含 element 元素值，则返回负数。调用该方法时要求数组中元素己经按升序排列， 这样才能得到正确的结果。
int binarySearch(element: T, fromlndex: Int= 0, tolndex: Int = size ）：这个方法与前一 个方法类似，只是该方法要求数组元素按自然排（数组元素要实现Comparable 接口） 升序排列。
contains(element: T）： 判断该数组是否包含某个元素，该方法可用 in 、！ in 运算符执行。
contentEquals(other: Array<out T＞）： 比较两个数组是否相等。
contentT oSt「ing （）：把数组转换成字符串，相当于 Arrays 类的 toString（）方法。
copyOf(newSize: Int）： 这个方法将会把该数组复制成一个新数组，其中 newSize 是新 数组的长度。如果 newSize 小于原数组的长度，则新数组就是原数组的前面 newSize 个元素；如果 newSize 大于原数组的长度，则新数组的前面元素就是原数组的所有元 素，后面补充 0 （数值类型）、 false （布尔类型）或者 null （引用类型〉。该方法有个 重载的版本，允许不指定 newSize 参数，则新数组与原数组长度相同。
copyOfRange(fromlndex: Int, tolndex: Int）：这个方法与前一个方法相似，但该方法只 复制该数组的企om 到 to 索引的元素。
count(predicate: (T) -> Boolean ）： 返回该数组符合给定 Lambda 条件的元素的个数。 该方法有个重载的版本，允许不指定 predicate 参数，此时直接返回该数组中元素的个 数，相当于 size 属性的返回值。
distinct（）： 该方法用于去掉数组中重复的元素。
drop I droplast(n: Int）： 该方法用于去掉数组前面或后面 n 个元素。
dropWhile I droplastWhile(predicate: (T) ->Boolean）：该方法用于去掉数组前面或后 面的某些元素，直到前面或后面第一个元素不再符合 predicate 条件。
fill(element: T, fromlndex: Int= 0, tolndex: Int = size）：该方法将会把数组中从企fromlndex到 toIndex 索引的数组元素赋值为 element 。
filterXxx（）： 一系列过滤方法，用于对数组元素进行过滤。
findXxx（）： 一系列用于查找元素的方法。
first I last(predicate: (T) -> Boolean ）： 获取数组中第一个或最后一个符合 predicate 条 件的元素。
fold(initial: R, operation : (ace: R, T）：将 initial、数组元素作为参数传入 operation 表达 式执行计算，将计算得到的结果作为下一个数组元素的 initial ， 依此类推，直到使用最 后一个数组元素计算，该方法返回使用最后一个数组元素计算得到的值。
indexOf I lastlndexOf(element: T）： 获取从前搜索或从后搜索时元素 element 在数组中 的索引。
indexOfFirst I indexOflast(predicate: (T) -> Boolean ）： 返回第一个或最后一个符合 predicate 条件的元素的索引 。
intersect I plus(other: lterable<T＞）： 获取两个数组的交集或并集。maxlmin （）： 按照自然排序规则（要求元素必须实现 Comparable 接口）找出该数组中 最大值或最小值。
sort（fromlndex: Int= 0, tolndex: Int= size ）： 该方法对数组的元素按自然排序（要求所 有元素实现 Comparable 接口）进行排列。
sortWith(comparator: Comparator<in T＞）： 该方法对数组的所有元素按 comparator 排 序（定制排序〉进行排列。

        val arrNew = arrayOf(2,4,6,8)
        //all()方法，判断所有元素是否为偶数
        Log.d("arrayTest", "${arrNew.all { it % 2 == 0 }}")//打印true

        //any()方法，判断是否有元素大于6
        Log.d("arrayTest", "${arrNew.any { it > 6 }}")//打印ture

        //根据数组元素来计算＜K , V＞对，返回所有＜K , V＞对组成的 Map 集合,K 是数组元素平方, v 是数组元素除2
        Log.d("arrayTest", "${arrNew.associate { it * it to it/2}}")

        //fold()方法，累加元素
        Log.d("arrayTest", "${arrNew.fold(0,{acc, i -> acc + i }) }")

        //定义一个 a 数组
        var a= arrayOf(3 , 4 , 5, 6)
        // 定义一个 a2 数组
        var a2 = arrayOf(3, 4 , 5, 6)
        // a 数组和 a2 数组的长度相等，每个元素依次相等， 将输出 true
        Log.d("arrayTest", "a 数组和 a2 数组是否相等${a.contentEquals(a2)}")

        // 通过复制 a 数组，生成一个新的 b 数组
        var b = a.copyOf (6)
        //输出 b 数组的元素，将输出［ 3 , 4, 5, 6, null , null]
        Log.d("arrayTest", "a 数组和 a2 数组是否相等${ b.contentToString()}")

        //将 b 数组的第 5 个元素（包括）到第 7 个元素（不包括）赋值为 l
        b . fill(1, 4 , 6)
        //输出 b 数组的元素， 将输出[1, 4 , 5 , 6 , 1 , l]
        Log.d("arrayTest", "a 数组和 a2 数组是否相等${ b.contentToString()}")

        // 对 b 数组进行排序 b . sort() 输出 b 数组的元素，将输出口， 1 , 3 , 4 , 5 , 6]
        Log.d("arrayTest", "a 数组和 a2 数组是否相等${ b.contentToString()}")