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)
}
//在末尾增加元素:add元素，添加另一个数组addAll方法
println("----------------add添加元素----------------")
mutableCountry.add("Korea")
for (s in mutableCountry) {
println(s)
}
val newCountry = arrayOf("Britain", "France")
println("----------------整体添加元素----------------")
mutableCountry.addAll(newCountry)
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
元素计数：10
元素是否为空：false
1,2
获取第三个元素3
获取最后一个元素10
----------------获取筛选重复后的数组----------------
China
Japan
American
Germany
----------------获取筛选重复后的set----------------
China
Japan
American
Germany
----------------切割数组：sliceArray----------------
American
Germany
----------------新建mutableList----------------
China
Japan
American
Germany
China
China
----------------移除首位置元素----------------
Japan
American
Germany
China
China
----------------add添加元素----------------
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)
}
println("----------------MutableSet添加数据：add----------------")
mutableCountry.add("Thailand")
for (s in mutableCountry) {
println(s)
}
println("----------------MutableSet添加集合数据：addAll----------------")
val newCountry = setOf("Brazil","Mexico")
mutableCountry.addAll(newCountry)
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
元素计数：6
否包含China元素：true
----------------转换成数组：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
----------------MutableSet添加数据：add----------------
Britain
France
China
Japan
American
Germany
Korea
Vietnam
Thailand
----------------MutableSet添加集合数据：addAll----------------
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
获取某个key对应的value：6888
获取某个key对应的value，给定默认值：0
----------------获得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
