3.1、基本类型
定义
区别（基本、包装、Long类型显示、赋值问题）
1、Java中有基本类型和包装类型，Kotlin里面只有包装类型。
2、Java中表示一个长整形，后面增加 l 或者 L，kotlIn中只能有L（大写）。
3、Java中整形赋值给Long类型是可以的，但是在kotlin中会出现编译错误。
val e:Int = 10;
val f:Long = e;//编译错误，Google认为跨类型赋值是不被允许的
val g:Long = e.toLong() //采用这样的形式是可以的
4、和Java不同，kotlin有无符号类型
5、字符串输入形式不同（字符串模板）
val str = "cdx"
Log.e("test", "你好$str")
6、引入了 === 和 ==，=== 比较的是 引用值，== 比较的是值。
val str1 = "Hello"
val str2 = String("Hello".toCharArray())
// 比较的是引用值
Log.e("cdx",(str1 === str2).toString()) // false
// 比较的是值
Log.e("cdx",(str1 == str2).toString()) // true
7、按照写的方式输出
val str =
"""
轻轻的我走了
正如我轻轻的来
我轻轻的招手
""".trimIndent()
Log.e("cdx", str)
3.2、数组
数组的类型（整形、整型装箱、字符串型）
Int有整形和整形装箱，字符串只有什么？
字符串只有字符串装箱。
例子1:创建一个Int数组的4种方式
// 创建一个Int类型的数组
// 第一种方式
var arr1 = IntArray(5)
// 第二种方式
var arr2 = IntArray(5) { it }
// 第三种方式
var arr3 = intArrayOf(1, 2, 3, 4, 5)
// 第四种方式
var arr4 = Array<Int>(5) { it }
例子2：创建一个String类型的数组
val arr = arrayOf("Hello", "world")
Log.e(tag, arr.joinToString())
3.3、区间
闭区间的使用
// 闭区间例子
var arr1: IntRange = 1..10
Log.e("cdx", arr1.joinToString()) // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
var arr2: CharRange = 'a'..'z'
Log.e("cdx", arr2.joinToString())
var arr3: LongRange = 1L..100L
Log.e("cdx", arr3.joinToString())
开区间的使用
// 开区间（左必有开区间）
var arr4 = 1 until 10 //[1,10)
Log.e("cdx", arr4.joinToString()) //1, 2, 3, 4, 5, 6, 7, 8, 9
倒序区间（Progression：进展、类型）
// 倒序区间
var arr5: IntProgression = 10 downTo 1
Log.e("cdx", arr5.joinToString()) //10, 9, 8, 7, 6, 5, 4, 3, 2, 1
var arr6 = 'z' downTo 'a'
Log.e("cdx", arr6.joinToString())
区间的步长
// 区间的步长
var arr7 = 1..10 step 2
Log.e("cdx", arr7.joinToString()) // 1, 3, 5, 7, 9
1..10 和 1..10 step 2 的类型分别是什么？
3.4、集合框架
集合框架有几种类型
Java和kotlin的对比
区别：
Java的数据结构都是可变的，但是kotlin的数据结构是区分不可变或者可变的。
创建不可变List的2中方式
// 不可变List使用
var list = List<String>(5) { "" }
//list[0] = "1" // 出现编译错误
var list2 = listOf<String>("Hello", "world")
//list2[0] = "1"
可变List的3种创建方式（对象方式、方法的方式）
// 可变List
// 第一种创建方式
val list1 = MutableList<Int>(5) { it }
// 第二种创建方式
var list2 = mutableListOf<Int>(1)
// 第三种创建的方式
var list3 = ArrayList<Int>()
list1[3] = 4
Log.e(tag, list1.joinToString("*"))
// 超出边界将阻碍下面的语句的执行
list1[8] = 8
list1.set(2, 5)
Log.e(tag, list1.joinToString("*"))
可变List的3种创建方式（对象方式、方法的方式）
// 可变List
// 第一种创建方式:采用对象的方式创建
val list1 = MutableList<Int>(5) { it }
// 第二种创建方式：采用方法的方式创建
var list2 = mutableListOf<Int>(1)
// 第三种创建的方式：次用ArrayList进行创建
var list3 = ArrayList<Int>()
list1[3] = 4
Log.e(tag, list1.joinToString("*"))
// 超出边界将阻碍下面的语句的执行
list1[8] = 8
list1.set(2, 5)
Log.e(tag, list1.joinToString("*"))
ArrayList使用（默认是可变还是不可变？）
// 这个默认是:MutableList
val list3 = ArrayList<String>()
list3.add("a")
list3.add("b")
list3 += "c" //注意 += 就是add的操作
list3.remove("b") //
list3 -= "a" // -= 就是remove操作
Log.e("cdx", list3.joinToString()) //c
不可变Map创建的2种方式（to和Pair）
// 不可变Map
val map: Map<String, Any> = mapOf("name" to "xiaohong", "age" to 20)
val map = mapOf<String, String>(Pair("name", "张三"), Pair("age", "10"))
可变Map
// 可变Map
val map2: MutableMap<String, Any> = mutableMapOf("name" to "xiaohong", "age" to 20)
map2["name"] = 3
map2.put("weight", 160)
//遍历Map的key-value对，entris元素返回key-value对组成的Set
for (en in map2.entries) {
Log.e("cdx", "${en.key}->${en.value}")
}
Pair（对）
val pair = "Hello" to "kotlin"
val pair2 = Pair("Hello", "kotlin")
val first = pair2.first
val second = pair2.second
// 解构赋值
val (x, y) = pair
Log.e(
"cdx",
"first:$first,second:$second,x:$x,y:$y"
) // first:Hello,second:kotlin,x:Hello,y:kotlin
Triple（三倍的）
和Pair使用类似
3.5、函数
定义
类似于java中的方法
一个函数没有返回值，返回类型是什么？
1、Unit类似于Java的void，可以省略。
函数VS方法
test方法外面有一个Test（类），那么test就是一个方法。
class Test {
fun test(): String {
return ""
}
}
函数的引用
函数的引用类似于C语言中的指针，可用于函数传递。
利用**：：**来实现获取函数的引用。
方法函数的引用 和 引用的类型是什么
首先定义方法
private fun test(str: String): Unit {
}
然后获取方法的引用
// 定义f来接受方法的引用, (String) -> Unit表示函数的类型。
// 其中(String) -> Unit类型可以省略
val fun1: (String) -> Unit = ::test
类中方法的引用
package com.example.kotlindemo
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// 接受一个方法的引用,这两个是等价的,表示括号里和哪些有关系
// 第一个表示有Receiver，第二个形式表示和Test有关系
val fun2: Test.() -> String = Test::test
val fun3: (Test) -> String = Test::test
// 对象取函数的引用,类型不一样了
val test = Test()
val fun4: () -> String = test::test
// 函数里面有函数，并且调用
test1(::test)
test1(fun1)
}
/**
* 这个test1函数的类型是一个函数，函数的参数是String类型，返回时是Unit类型，也就是void类型
*/
private fun test1(p: (String) -> Unit) {
p("Hello")
}
private fun test(str: String): Unit {
}
}
class Test {
// 这个就是方法
fun test(): String {
return ""
}
}
对象方法的引用
// 对象取函数的引用,类型不一样了
val test = Test()
val fun1: () -> Unit = test::test
变长参数
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.e("cdx",test("1", "2"))
}
// 边长参数：类似于数组
// 使用关键字 vararg
fun test(vararg params: String): String {
return params.size.toString();
}
}
多返回值接受的两种方式（通常方式、解构赋值）
class MainActivity2 : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)
// 第一种接受方式
val test = test()
// 第二种接受方式：结构赋值
val (a,b,c) = test()
Log.e("cdx",test.toString())
}
fun test(): Triple<Int, Long, Double> {
return Triple(1, 2L, 3.0)
}
}
默认参数
class MainActivity2 : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)
test(1)
}
// 默认参数，建议放在最后，也可以放在前面
fun test(x: Int, y: Int = 0, z: String = "") {
Log.e("cdx", "x：$x y:$y z:$z")
}
}
默认参数建议放在哪？
// 默认参数，建议放在最后，也可以放在前面
具名参数
class MainActivity2 : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)
// 具名参数：在传递的时候将键值对都放入这个方法中
// 使用场景：当函数的默认值不是最后的参数时，可以使用具名参数
test(y=1)
}
// 默认参数，必须放在最后
fun test(x: Int = 1, y: Int, z: String = "") {
Log.e("cdx", "x：$x y:$y z:$z")
}
}
