Kotlin系列四(kotlin中的数组)

六.kotlin中的数组

• 数组是存储一组相同数据类型的容器

基本数据类型数组

kotlin中基本数据类型数组的种类

kotlin内置创建基本数据类型数组的方法

• 创建基本数据类型数组的三种方式

  1. 使用构造方法创建指定长度的空数组

     //语法格式
     数组类型(数组长度);
     

  2. 使用构造方法创建指定长度的数组，并使用Lambda表达式初始化数组中的元素

     //语法格式
     数组类型(数组长度){
         Lambda表达式代码块
     }
     

  3. 使用内置方法创建包含指定元素的数组

     //语法格式,以Int类型的数组为例
     intArrayOf(元素一,元素二,元素三);
     
     

• 案例

        //以IntArray类型数组为例
        //创建基本数据类型数组的三种方式
        //1.使用构造方法创建指定长度的空数组,Int数组的默认值是0
        val array1 = IntArray(5);
        //使用构造方法创建指定长度的空数组:[0, 0, 0, 0, 0]
        println("使用构造方法创建指定长度的空数组:${array1.contentToString()}");

       //2.使用构造方法创建指定长度的数组，并使用Lambda表达式初始化数组中的元素
        val  array2 = IntArray(5){
            //隐世参数it表示当前遍历的元素下标,会遍历的次数为数组的长度
            it;
            println("当前隐式参数it的值为:$it");
            //Lambda表达式代码块的最后一行作为当前数组索引处的值
            2;
        }
        //等价写法,也可以在参数中使用lambda表达式
//        val array2 = IntArray(5,{
//            it;
//        });
        //使用构造方法创建指定长度的数组，并初始化数组中的元素:[2, 2, 2, 2, 2]
        println("使用构造方法创建指定长度的数组，并初始化数组中的元素:${array2.contentToString()}");
        
        //3.使用内置方法创建包含指定元素的数组
        val array3 = intArrayOf(1,2,3,4,5);
        //使用内置方法创建包含指定元素的数组:[1, 2, 3, 4, 5]
        println("使用内置方法创建包含指定元素的数组:${array3.contentToString()}");

引用类型数据数组

• 引用数组中的元素都是引用类型,int等基本数据类型存储在引用数组中,实现存储的是对应java中的Integer包装类

• 创建引用型数组的三种方式

  1. 创建指定长度的空数组

     //语法格式
     arrayOfNull<数据类型>(数组长度);
     

  2. 创建数组时指定元素

     //语法格式
     arrayOf<数据类型>(元素一,元素二,元素三);
     //因为kotlin中的类型推断机制,使用指定元素进行创建数组时,可以省略数据
     arrayOf(元素一,元素二,元素三);
     

  3. 使用Array类的构造方法配合Lambda表达式创建指定长度的数组

     //语法格式
     Array<数据类型>(数组长度){
         Lambda表达式代码块
     }
     

  • 案例

          println("kotlin中的引用数据类型数组");
  
          //1.创建指定长度的空数组
          val array1 = arrayOfNulls<String>(5);
          //创建指定长度的空数组:[null, null, null, null, null]
          println("创建指定长度的空数组:${array1.contentToString()}");
  
          //2.创建数组时指定元素
  //        val array2 = arrayOf<String>("a", "b", "c", "d", "e");
          //简写
          val array2 = arrayOf("a", "b", "c", "d", "e");
          //创建数组时指定元素:[a, b, c, d, e]
          println("创建数组时指定元素:${array2.contentToString()}");
  
          //3.使用Array类的构造器创建数组
          val array3 = Array(5){
              //Lambda表达式中可以使用隐式参数it
              println("当前隐式参数it的值为:$it");
              'a'+it;
          }
          //使用Array类的构造器创建数组:[a, b, c, d, e]
          println("使用Array类的构造器创建数组:${array3.contentToString()}");
  
          //4.当引用类型数组存储的元素数据类型不一致时,这时元素的数组就是存储Any类型的引用型数组,元素也是Any类型的,就不再是原本的数据类型了
          val array4 = arrayOf(1, "a", 3.14);
          println(array4.javaClass);
  

数组的常用操作

1. 获取数组的长度,通过size属性
2. 通过索引获取元素,"[]"索引操作符的方式或get()方法的方式
3. 修改索引位置的元素,"[]"索引操作符的方式或set()方法的方式
4. 遍历数组,"for"循环的方式,通过数组属性indeces的方式,通过withIndex()方法同时遍历索引和值的方式

• 案例

    //数组的常用操作
    val array = arrayOf(1, 2, 3, 4, 5);
    println("创建的数组为:${array.contentToString()}");

    //1.数组的长度
    val length = array.size;
    //创建的数组为:[1, 2, 3, 4, 5]
    println("数组的长度为:$length");

    //2.通过索引获取数组的元素
    var element = array[0];
//    var element = array.get(0);
    //通过索引获取数组的元素为:1
    println("通过索引获取数组的元素为:$element");

    //3.通过索引修改元素
    array[0] = 10;
//    array.set(0,10);
    //修改后的数组为:[10, 2, 3, 4, 5]
    println("修改后的数组为:${array.contentToString()}");

    //4.遍历数组
    //4.1直接遍历数组的元素
    for (v in array){
        println("当前元素为:$v");
    }
    //4.2通过索引遍历数组的元素
    for (i in  array.indices){
        println("当前索引为:${array.indices},当前元素为:${array[i]}");
    }

    //4.3同时遍历索引和值

    for ((index,value) in array.withIndex()){
        println("当前索引为:$index,当前元素为:$value");
    }

    for (indexvalue in array.withIndex()){
        println("当前索引为:${indexvalue.index},当前元素为:${indexvalue.value}");
    }

多维数组

• 数组中存储数组便是多维数组,也就是数组可以套娃,数组套娃一层就是二维数组,两层就是三维数组,以此类推