今天准备讲些基础的.

数组类型和它的扩展函数

我们可以通过这种方式来创建数组:

fun main() {
    val a = IntArray(3)
    val a1 = IntArray(3){
        9
    }
    println(a1)
    println(a)
}

以上是这种XXXArray这一系列的类来创建数组, 例如IntArray , ShortArray .
这段打印出来的结果是这样的:

再来看看它反编译的结果:

public final class PracticeKt {
   public static final void main() {
      int[] a = new int[3];
      byte var2 = 3;
      int[] var3 = new int[var2];

      for(int var4 = 0; var4 < var2; ++var4) {
         int var6 = false;
         byte var9 = 9;
         var3[var4] = var9;
      }

      System.out.println(var3);
      System.out.println(a);
   }

这就是XXXArray与XXXArrayof不一样的地方,XXXArray是通过循环的方式来一个一个的把元素放进去的.
XXXArrayof是在创建的时候就把元素放进去了,它其实是这样: int[] a2 = new int[]{4, 4, 4};
上面的例子打印出的是地址,如果想打出值的话用.contentToString()就可以了,例如:println(a1.contentToString()).

还可以通过Array来创建数组,

val a = Array(3){
       4
   }

先来看看它的反编译结果

 public static final void main() {
      byte var1 = 3;
      Integer[] var2 = new Integer[var1];

      for(int var3 = 0; var3 < var1; ++var3) {
         int var5 = false;
         Integer var8 = 4;
         var2[var3] = var8;
      }

注意到这里其实是public class Array<T>,既然使用到了泛型参数T,所以里面的元素是复杂类型,故是 Integer 而不是 Int .

多维数组

首先我们先简单的学习一下如何创建一个二维数组.

Array(3){
        arrayOf(0,0,0)
    }

这个很好理解,就是在一个数组里面,令它的元素也是个数组,这就是二维数组了,再来看看反编译的结果

 byte var0 = 3;
      Integer[][] var1 = new Integer[var0][];

      for(int var2 = 0; var2 < var0; ++var2) {
         int var4 = false;
         Integer[] var7 = new Integer[]{0, 0, 0};
         var1[var2] = var7;

思考一下为什么kotlin不用 java 这种创建数组的方式呢?

kotlin是用类的方式来创建数组的,
java 里数组这种类型,可用性不强, 例如我们想在获取数组的最大元素只能循环去一个一个的遍历,在kotlin中不用java里的数组,可以用扩展函数来获取,因为它是个类.这样的话可操作性就很强.

Java 里除了类似arr.length,没有提供什么有用的属性,只有object的一些方法.

kotlin的数据类型可以被称为编译器类型,只有在我们写的时候才有,编译之后就没有了.
例如:

fun showProgress(progress: Int): Int {
        return progress.coerceIn(0, 100)
    }
    println(showProgress(200))

可以提供扩展函数来调用方法,就很方便.
在这里我是故意写的200,因为我们调用 coerceIn 方法来限制 x 在 0 到 100 的范围内,由于给的 200 大于指定的上界 100，因此 coerceIn 方法返回了上界 100,如果给的原始值小于指定的下界 0，那么 coerceIn 方法会将结果限制在下界 0。需要注意的是 coerceIn 方法只适用于数值类型的数据，并且要求下界必须不大于上界。如果下界大于上界，那么这个方法会抛出 IllegalArgumentException 异常。

扩展函数

map 操作

fun main() {
    val array = intArrayOf(1,2,3)
    array.map { yy ->
        yy*2
    }.apply {
        println(this)
    }
}

在这里 map 就是对数组中每个元素执行 transform 函数,然后再将函数的返回值放入 List 中 ,最后也是返回 List

flatMap

flatMap 就是对数组中每个元素执行 transform 函数,该函数会返回一个迭代器,然后将迭代器中的全部元素放入 List ,最后返回整个 List

fun main() {
    val array = intArrayOf(1,2,3)
    array.flatMap {
        listOf(it*2)
    }.apply {
        println(this)
    }
}

如果把代码修改成:

fun main() {
    val array = intArrayOf(1,2,3)
    array.flatMap {
        listOf(it*2,1)
    }.apply {
        println(this)
    }
}

则结果是[2, 1, 4, 1, 6, 1] , 因为它会所有的元素放在一个统一的集合里.

fold

fold有两个参数, initial(初始值) ,operation(函数) , operation的参数有 initial 和数组元素,然后对数组中每个元素执行operation ,这么说有点抽象,下面我们来看一个例子:

fun main() {
    val array = intArrayOf(1,2,3)
    array.fold(4){ acc, i -> acc + i}.also {
        print(it)
    }
}

我们调用 fold() 方法并传入两个参数：初始值 0 和一个累加器函数 { acc, i -> acc + i }。累加器函数接收两个参数 acc 和 i，其中 acc 表示上一次累加的结果，而 i 则表示当前遍历到的元素.最终，输出结果为 10.
需要注意的是，累加器函数必须是一个带有两个参数并返回一个新值的 lambda 表达式.

详细关注公众号：Android老皮
还能解锁 《Android十大板块文档》 ，让学习更贴近未来实战。已形成PDF版

内容如下：

1.Android车载应用开发系统学习指南（附项目实战）
2.Android Framework学习指南，助力成为系统级开发高手
3.2023最新Android中高级面试题汇总+解析，告别零offer
4.企业级Android音视频开发学习路线+项目实战（附源码）
5.Android Jetpack从入门到精通，构建高质量UI界面
6.Flutter技术解析与实战，跨平台首要之选
7.Kotlin从入门到实战，全方面提升架构基础
8.高级Android插件化与组件化（含实战教程和源码）
9.Android 性能优化实战+360°全方面性能调优
10.Android零基础入门到精通，高手进阶之路

数组类型和扩展函数