Kotlin系列四(kotlin中的数组)

六.kotlin中的数组

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

基本数据类型数组

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

名称含义
BtyeArray存储8bit整型的数组
ShortArray存储16bit整型的数组
IntArray存储32bit整型的数组
LongArray存储64bit整型的数组
UByteArray存储8bit无符号整型的数组
UShortArray存储16bit无符号整型的数组
UIntArray存储32bit无符号整型的数组
ULongArray存储64bit无符号整型的数组
CharArray存储字符类型的数组
FloatArray存储单精度浮点型的数组
DoubleArray存储双精度浮点型的数组
BooleanArray存储布尔型的数组

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

方法名含义
byteArrayOf()创建底层存储byte类型数据的数组
shortArrayOf()创建底层存储short类型数据的数组
intArrayOf()创建底层存储int类型数据的数组
longArrayOf()创建底层存储long类型数据的数组
ubyteArrayOf()创建底层存储无符号byte类型数据的数组
ushortArrayOf()创建底层存储无符号short类型数据的数组
uintArrayOf()创建底层存储无符号int类型数据的数组
ulongArrayOf()创建底层存储无符号long类型数据的数组
charArrayOf()创建底层存储char类型数据的数组
floatArrayOf()创建底层存储float类型数据的数组
doubleArrayOf()创建底层存储double类型数据的数组
booleanArrayOf()创建底层存储boolran类型数据的数组
  • 创建基本数据类型数组的三种方式

    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}");
    }

运行结果

多维数组

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