# Kotlin 进阶之路2 区间与集合类型

Kotlin 进阶之路 目录

#### 1.区间(Range)

• 一个数学上的概念，表示范围
• ClosedRange的子类，IntRange最常用
• 基本写法：
``````- 0..100表示[0,100]
- 0 until 100 表示[0，100)
- i in 0..100 判断i是否在区间[0,100]中
``````
``````val range: IntRange = 0..1024 //[0,1024]---闭区间
val range_exclusive: IntRange = 0 until 30 //[0,30)---半闭区间
val emptyRange: IntRange = 0..-1

fun main(args: Array<String>) {
println(emptyRange.isEmpty())
println(range.contains(100))
println(50 in range)

for (i in range_exclusive) {
print("\$i  ")
}
}
``````
``````true
true
true
0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29
``````

#### 2.数组类型

##### 基本写法：
``````- val array:Array<String> = arrayOf(...)
``````

#### 基本类型的数组

Java Kotlin
int[] IntArray
short[] ShortArray
long[] LongArray
float[] FloatArray
double[] DoubleArray
char[] CharArray
##### 基本操作
``````- print array[i] 输出第i个元素
- array[i] = "Hello" 给第i个成员赋值
- array.length 数组的长度
``````
``````val arrayOfInt: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7)
val arrayOfChar: CharArray = charArrayOf('H', 'e', 'l', 'l', 'o', ',', 'W', 'o', 'r', 'l', 'd', '!')
val arrayOfString:Array<String> = arrayOf("你好","美女")

fun main(args: Array<String>) {
println(arrayOfInt.size)
for (i in arrayOfInt){
println(i)
}
println(arrayOfInt.slice(2..4))

println(arrayOfChar.joinToString())
println(arrayOfChar.joinToString(""))

println(arrayOfString[0])
arrayOfString[1] ="帅哥"
println(arrayOfString[1])

}
``````
``````1
2
3
4
5
6
7
[3, 4, 5]
H, e, l, l, o, ,, W, o, r, l, d, !
Hello,World!

``````
``````/**
*集合类型
*
* 同类型的值的组合，根据整体特性分：
* 1.有序可重复 - Array ，索引从0开始(index,i)
* 2.无序不重复 - set
* 3.无序可重复 - Map ,有唯一的键(key)
* */
fun main(args: Array<String>) {
//Array: Array<类型> 或arrayOf(元素一、元素二、元素三，...元素三)
var country = arrayOf("China", "Japan", "American", "Germany", "China", "China")

for (s in country) {
println(s)
}
//创建一个有默认值的数组，Array(计算,{默认值})
println("----------------创建一个有默认值的数组----------------")
var countryPlaceHolder = Array(5, { "Australian" })
for (s in countryPlaceHolder) {
println(s)
}

//创建1到10的数组:Array(10,{i -> i+1})
//i代表元素的索引值，从0开始
println("----------------创建1到10的Array数组----------------")
var oneToTen = Array(10, { i -> i + 1 })
for (i in oneToTen) {
println(i)
}
//元素计数：count，空否:isEmpty()
println("元素计数：" + oneToTen.count())
println("元素是否为空：" + oneToTen.isEmpty())

//获取其中元素：数组名{索引}，首元素：数组名.frist，尾元素：数组名.last
//获取前5各元素的快捷方法.compoent 1到5
println("\${oneToTen.component1()},\${oneToTen.component2()}")
println("获取第三个元素" + oneToTen[2])
println("获取最后一个元素" + oneToTen.last())

//获取筛选重复后的数组：.distinct() 或用.toSet()转换为set。
println("----------------获取筛选重复后的数组----------------")
val countryNotRepeat = country.distinct()
for (i in countryNotRepeat) {
println(i)
}
println("----------------获取筛选重复后的set----------------")
val countryNotRepeat2 = country.toSet()
for (i in countryNotRepeat2) {
println(i)
}
//切割数组：sliceArray
println("----------------切割数组：sliceArray----------------")
val countrySlice = country.sliceArray(2..3)
for (s in countrySlice) {
println(s)
}

//mutableList：MutableList<类型>或mutableListOf(元素1，元素2，...，元素n)
//大小可变，类型不可变
println("----------------新建mutableList----------------")
var mutableCountry = mutableListOf("China", "Japan", "American", "Germany", "China", "China")

for (s in mutableCountry) {
println(s)
}

println("----------------移除首位置元素----------------")
mutableCountry.removeAt(0)
for (s in mutableCountry) {
println(s)
}

for (s in mutableCountry) {
println(s)
}
val newCountry = arrayOf("Britain", "France")
println("----------------整体添加元素----------------")
for (s in mutableCountry) {
println(s)
}

println("----------------移除新加的数组元素----------------")
mutableCountry.removeAll(newCountry)
for (s in mutableCountry) {
println(s)
}

println("----------------获取筛选重复后的mutableList----------------")
for (s in mutableCountry.distinct()) {
println(s)
}
}
``````
``````China
Japan
American
Germany
China
China
----------------创建一个有默认值的数组----------------
Australian
Australian
Australian
Australian
Australian
----------------创建1到10的Array数组----------------
1
2
3
4
5
6
7
8
9
10

1,2

----------------获取筛选重复后的数组----------------
China
Japan
American
Germany
----------------获取筛选重复后的set----------------
China
Japan
American
Germany
----------------切割数组：sliceArray----------------
American
Germany
----------------新建mutableList----------------
China
Japan
American
Germany
China
China
----------------移除首位置元素----------------
Japan
American
Germany
China
China
Japan
American
Germany
China
China
Korea
----------------整体添加元素----------------
Japan
American
Germany
China
China
Korea
Britain
France
----------------移除新加的数组元素----------------
Japan
American
Germany
China
China
Korea
----------------获取筛选重复后的mutableList----------------
Japan
American
Germany
China
Korea
``````

#### 3.Set集合

``````/**
* 集合类型 Set:无序不重复
* 主要方法 交差并补
* */
fun main(args: Array<String>) {

//Set<类型> 或 setOf(元素1，元素2，...，元素n)
//大小不固定，元素类型不可变

val country = setOf("Britain", "France", "China", "Japan", "American", "Germany")
val countryAsia = setOf("China", "Japan", "Korea", "Vietnam")
val countryPermanent = setOf("American", "China", "France", "Britain", "Russia")
for (s in country) {
println(s)
}

//元素计数：count()，空否：isEmpty()
println("元素计数：" + country.count())

//检查是否包含某个元素：contains，包含另一个set：containAll
println("否包含China元素：" + country.contains("China"))

//转换成数组：toTypedArray()
println("----------------转换成数组：toTypedArray()----------------")
val array = country.toTypedArray()
for (s in array) {
println(s)
}
//结合之间的运算：intersect/subtract/union/minus(补集的被操作对象无需是Set类型)
println("----------------集合交集数据：intersect----------------")
val interCountry = country.intersect(countryAsia)
for (s in interCountry) {
println(s)
}
println("----------------集合差集数据：subtract----------------")
val subtractCountry = country.subtract(countryAsia)
for (s in subtractCountry) {
println(s)
}
println("----------------集合并集数据：union----------------")
val unionCountry = country.union(countryAsia).union(countryPermanent)
for (s in unionCountry) {
println(s)
}
println("----------------集合补集数据：minus----------------")
val minusCountry = country.minus(countryAsia)
for (s in minusCountry) {
println(s)
}
//MutableSet<类型>或mutableSetOf(元素1，元素2，...，元素n)
//大小可变，类型不可变
val mutableCountry = country.union(countryAsia).toMutableSet()
println("----------------MutableSet----------------")
for (s in mutableCountry) {
println(s)
}
for (s in mutableCountry) {
println(s)
}
val newCountry = setOf("Brazil","Mexico")
for (s in mutableCountry) {
println(s)
}
println("----------------MutableSet移除数据：remove----------------")
//移除元素：remove，移除另一集合：removeAll
mutableCountry.remove("Thailand")
for (s in mutableCountry) {
println(s)
}
println("----------------MutableSet移除集合数据：removeAll----------------")
//移除集合元素：removeAll，移除另一集合：removeAll
mutableCountry.removeAll(newCountry)

for (s in mutableCountry) {
println(s)
}
}
``````
``````Britain
France
China
Japan
American
Germany

----------------转换成数组：toTypedArray()----------------
Britain
France
China
Japan
American
Germany
----------------集合交集数据：intersect----------------
China
Japan
----------------集合差集数据：subtract----------------
Britain
France
American
Germany
----------------集合并集数据：union----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Russia
----------------集合补集数据：minus----------------
Britain
France
American
Germany
----------------MutableSet----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Thailand
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Thailand
Brazil
Mexico
----------------MutableSet移除数据：remove----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Brazil
Mexico
----------------MutableSet移除集合数据：removeAll----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
``````

#### 4.Map集合

``````/**
* 集合类型 Map ：无序可重复，类似于"字典"的意思
*
* */
fun main(args: Array<String>) {

//mapOf<Key,Value>(Pair(key,value)，...)
//显示指定类型，可防止初始化值类型的错误

val products = mapOf<String, String>(Pair("IPhone", "6888"), Pair("Xiaomi", "3499"), Pair("Huawei", "5999"))

//元素计数：size，空否：isEmpty
println("元素计数：" + products.size)

//获取某个key对应的value：get，getOrDefalt
println("获取某个key对应的value：" + products.get("IPhone"))
println("获取某个key对应的value，给定默认值：" + products.getOrDefault("ZTE", "0"))
println("----------------获得map所有的key：keys----------------")
//返回所有的key：keys，所有的value：values
for (key in products.keys) {
println(key)
}
println("----------------获得map所有的value：values----------------")
for (value in products.values) {
println(value)
}

//mutableMapOf<Key,Value>(Pair(key,value),...)
val mutableProducts = products.toMutableMap()
println("----------------获得map所有的value：values----------------")
//添加或更新:下标方法 map变量名[key] = value
mutableProducts["IPhone"]="7999"
mutableProducts["Xiaomi"]="1999"
for (mutableProduct in mutableProducts) {
println("\${mutableProduct.key}，"+"\${mutableProduct.value}")
}

println("----------------移除元素:remove----------------")
//移除元素:remove
mutableProducts.remove("IPhone")
for (mutableProduct in mutableProducts) {
println("\${mutableProduct.key}，"+"\${mutableProduct.value}")
}

println("----------------添加元素:put----------------")
//添加元素:remove
mutableProducts.put("Samsung","6999")
for (mutableProduct in mutableProducts) {
println("\${mutableProduct.key}，"+"\${mutableProduct.value}")
}
}
``````
``````元素计数：3

----------------获得map所有的key：keys----------------
IPhone
Xiaomi
Huawei
----------------获得map所有的value：values----------------
6888
3499
5999
----------------获得map所有的value：values----------------
IPhone，7999
Xiaomi，1999
Huawei，5999
----------------移除元素:remove----------------
Xiaomi，1999
Huawei，5999
----------------添加元素:put----------------
Xiaomi，1999
Huawei，5999
Samsung，6999
``````