kotlin的基础语法1.1--数组和集合

数组定义

数组：初始化时候指定容器的大小，不可以动态的调整大小。元素安顺序存储在一连串的内存段上

kotlin 数组的创建

声明对象数组的三种形式：

(1)使用arrayOf函数和指定的数组元素创建数组，必须指定数组的元素，可以为任意类型

//Java写法:
String[] params1 = {"str1", "str2", "str3"};
//kotlin写法:`
val params1 = arrayOf("str1", "str2", "str3")

(2).使用arrayOfNulls函数创建一个指定大小的并初始化每个元素为null的数组，但是必须指定元素的类型

//Java写法:
String[] params2 = new String[12];

//kotlin写法:
val params2 = arrayOfNulls<String>(12)

(3)Array构造方法指定数组大小和一个生成元素的lambda表达式

这种方法创建的数组，其中的每个元素都是非空的

//kotlin写法:
val params3 = Array<String>(3){i -> "str" + i }
// 也可以这么写
val params=Array(3){"str$it"}

基本数据类型数组

• [] 运算符代表调用成员函数 get() 和 set()。数组是不可变的

• 除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

   val x: IntArray = intArrayOf(1, 2, 3)
   x[0] = x[1] + x[2]
   println(x[0])  //输出5
   
    val inArray = IntArray(5)
    inArray[0]= 2
    // 创建一个长度为5，值全部为100的整型数组intArray[100,100,100,100,100]
    val intArray2 = IntArray(5){100}
    //这里it是它的索引值，所以创建一个长度为5的intArray[0,2.4,8,16],it是lamble是专有表达式，这里代表数组的下标
    val intArray3 = IntArray(5){it*2 } //{i -> i*2}
  

数组的遍历

java遍历数组

/*
java遍历数组的方法：fori,forEach,
 forEach：遍历数组中的每个元素，且不需要下标
 */
for (int forEach : a) {
   System.out.println("forEach=" + forEach);
}
for (int i = 0 ; i< a.length;i++){
   System.out.println("for遍历:"+a[i]);
}

kotlin遍历数组

方法一：for-in

val numbers2 = Array(10, { value: Int -> (value + 200) })
// 数组for循环遍历 for-in
for (value in numbers2) {
    println(value) //输出200 201 202 203 204 205 206 207 208 209
}
// for-in的加强版： 根据下标在取出数组中的元素
    for (i:Int in numbers2.indices){
    println(i.toString()+"->"+numbers2[i])//输出结果0->200 1->201 2->202 3->203 4->204 5->205 6->206 7->207 8->208 9->209
    }

方法2：forEach

numbers2.forEach { 
   println("forEach:$it") 
}
   // forEach加强版，同时遍历下标和元素 
    numbers2.forEachIndexed{index, i ->
        println("$index:$i")
    }

数组的替换值

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值

字符数组转换成字符串

fun main() {
    // 第一种形式建立数组arrayOf
    val numbers = arrayOf(1, 2, 3, 4, 5, 6, 7, 8)
     println(numbers[0]) //输出1
     println(numbers[7]) //输出8
     // 数组遍历
    for (number in numbers) { 
         println(number) // 输出1 2 3 4 5 6 7 8
    }
// 第二种形式 Array value=0     长度为10，然后根据value+200循环赋值
val numbers2 = Array(10,  {value: Int -> (value + 200) })
for (value in numbers2) {
    println(value) //输出200 201 202 203 204 205 206 207 208 209

}

}

集合

集合的分类

参考学习1

参考学习2

与数组不同的是集合的大小可以任意改变 ，按照类型分类

• list:是一个有序列表，可以通过索引(下标)访问列表。元素可以在列表中出现多次，可以重复
• set:是唯一的元素集合，一组无重复数据的对象，一般来说set中元素的顺序并不重要
• map：（字典）键值对，键是唯一的，每个键刚好映射到一个值，值可以重复

按照可变性分类

• 可变集合
• 不可变集合

具体来说
对于List

• List ——声明不可变List集合
• MutableList——声明可变List集合

对于Map

• Map——声明不可变Map集合
• MutableMap——声明可变Map集合

对于Set

• Set——声明不可变Set集合
• MutableSet——声明可变Set集合

除此之外还有四个基本接口

• Iterable ——所有集合的父类
• MutableIterable —— 继承于Iterabl接口，支持遍历的同时可以执行删除操作
• Collection —— 继承于Iterable接口，仅封装了对集合的只读方法
• MutableCollection ——继承于Iterable,Collection，封装了添加或移除集合中元素的方法

list

可变

列表的创建---可变列表，必须指定元素类型
val arrayString = mutableListOf<String>()
arrayString.add("1")
arrayString.add("2")
arrayString.add("3")
arrayString.add(3, "4")
val arrayString2 = mutableListOf<String>("1", "2", "3", "4")
val iterator = arrayString2.iterator()
iterator.forEach { println("it:${it}") }// forEach循环遍历list中元素
println("add-index:${arrayString2.add(2, "33")}") // 指定位置插入元素
println("add:${arrayString2.add("34")}") //不指定位置插入元素，输出结果true
println("removeAt:${arrayString2.removeAt(3)}") //移除指定位置的元素
println("clear:${arrayString2.clear()}")// 集合中的元素会被清除
arrayString2.forEach {
    println("reverse:${arrayString2.reverse()}")//集合元素翻转  
}
arrayString2.sort()//排序。从小到大进行排序

不可变

//列表的创建---不可变列表，必须指定元素类型，必须指定初始化数据元素
val arrayInt = listOf<Int>(1, 2, 3, 4)

map

可变

//map--可变，使用Pair指定集合中初始化的元素
val arrayMap3 = mutableMapOf<String, String>()
arrayMap3["1"] = "1"
arrayMap3["2"] = "2"
arrayMap3["3"] = "3"

不可变

// map---不可变字典，不可动态添加，删除元素
val arrayMap = mapOf(Pair("key", "value"))
val arrayMap2 = mapOf<String, String>()

set

可变

// set:可变集合
val set = mutableSetOf<String>()
set.add("1")
set.add("2")
set.add("3")
set.add("4")
for (item in set) {
    println(item)
}
val set2 = mutableSetOf<String>("1", "2", "4")
print("isEmpty:${set2.isEmpty()}")//isEmpty
print("contain:${set2.contains("6")}")//contains

不可变

//set:不可变集合,元素唯一
val set3 = setOf<String>()

#### 集合的操作

add:添加元素确实改变了集合就返回true，如果集合没有发生变化就返回false。