一丶基本类型
- 声明变量
- 声明变量(类型自动推导)
- 易混淆的 Long 类型标记
- Kotlin 的数值转换
- Kotlin 的字符串
声明变量
声明变量(类型自动推导)
易混淆的 Long 类型标记
Kotlin 的数值转换
Kotlin 的字符串
总结
二丶数组
- 区别
- 数组的创建
- 数组的长度
- 数组的读写
- 数组的遍历写法一
- 数组的遍历写法二
- 数组的包含关系
区别:
数组的创建:
数组的长度
数组的读写:
数组的遍历写法一:
数组的遍历写法二:
数组的包含关系:
package com.wangrui.kotlin
fun main(){
// 方式一:创建一个可变长度的整型数组
val c0 = intArrayOf(1,2,3,4,5)
// 方式二:创建整型数组并且按照每个下标(0~4)依次+1 赋值给数组 c1
val c1 = IntArray(5){it + 1}
// contentToString() — 将内容转换成字符串格式
println(c1.contentToString());
val c0 = intArrayOf(1,2,3,4,5);
// 创建整型数组并且按照每个下标(0~4)依次(坐标+1)*3 赋值给数组c1
val c1 = IntArray(5){(it + 1)*3}
println(c0.contentToString());
println(c1.contentToString());
val a = IntArray(5)
// 得到集合长度
println(a.size)
val d = arrayOf("Hello","World")
d[1] = "Kotlin"
println("${d[0]},${d[1]}")
val e = floatArrayOf(1f,2f,3f,4f,5f)
// in—遍历
for (a in e){
println(a)
}
// array.foreach() 高阶函数遍历
//遍历集合e,并将每次循环得到的每个值赋给a,然后打印a
e.forEach { a -> println(a) }
}
三丶区间
- 区间的创建
- 开区间
- 倒序区间
- 区间的迭代
- 区间的包含关系
- 区间的应用写法一
- 区间的应用写法二
区间的创建
开区间
倒序区间
区间的迭代
区间的包含关系
区间的应用写法一:
区间的应用写法二:
package com.wangrui.kotlin
fun main(){
// in—包含
if (1f in e){
println("包含")
}
if (20f !in e){
println("不包含")
}
//区间(正序)
val intRange = 1..10
val charRange = 'a'..'z'
val longRange = 1L..100L
val floatRange = 1f..2f
val doubRange = 1.0..2.0
// joinToString() — 加入并转成字符串,join — 加入
println(intRange.joinToString())
// toString() — 转成字符串
println(floatRange.toString())
// 止步——step
val intRangeWitStep = 1..10 step 2
val charRangeWithStep = 'a'..'z' step 2
val longRanWitStep = 1L..100L step 5
println(longRanWitStep.joinToString())
// 倒序区间
val intRangeReverse = 10 downTo 1
val charRangeReverse = 'z' downTo 'a'
val longRangeReverse = 100L downTo 1L
println(longRangeReverse.joinToString())
val array = intArrayOf(1,3,5,7)
//遍历方式1
// until — 直到,所以是 0 到 数组.size
for (i in (0 until array.size)){
println(array[i])
}
//遍历方式2
// indices — 索引,所以 array[i] = 对应元素
for (i in array.indices){
println(array[i])
}
}
四丶集合框架
- 简介
- 集合框架的接口类型对比
- 集合框架的创建【List】
- 集合框架的创建【Map】
- 集合实现类服用与类型别名
- 集合框架的读写
- 集合框架的修改
- 集合框架的读写2
- 集合框架的读写3
- Pair
- Triple
- 思考题
简介
集合框架的接口类型对比
集合框架的创建【List】
集合框架的创建【Map】
集合实现类服用与类型别名
集合框架的读写
集合框架的修改
集合框架的读写2
集合框架的读写3
Pair
Triple
思考题
package com.wangrui.kotlin
fun main(){
// 创建List集合的方式一:不能添加元素或者删除元素
val intList: List<Int> = listOf(1,2,3)
// 创建List集合的方式二:可以添加元素或者删除元素
val intList2: MutableList<Int> = mutableListOf(1,2,3)
// 创建Map集合的方式一:不能添加元素或者删除元素
// Any等价于Java中的 Object
// to 可以理解为:Key to Value
val map:Map<String,Any> = mapOf("name" to "benny","age" to 20)
// 创建Map集合的方式二:可以添加元素或者删除元素
val map2:Map<String,Any> = mutableMapOf("name" to "benny","age" to 20)
val stringList:MutableList<String> = mutableListOf("98","99","100","num:1","num:2")
// 对集合添加元素、删除元素
for (i in 0..10){
// 添加元素
// stringList += "num:$i" // 等价于 stringList.add("num:$i")
//结果为:[98, 99, 100, num:1, num:2, num:0, num:1, num:2, num:3, num:4, num:5, num:6, num:7, num:8, num:9, num:10]
// 删除元素
stringList -= "num:$i" // 等价于 stringList.remove("num:$i")
//当上面代码注释后,结果为:[98, 99, 100]
}
println(stringList)
// Map集合赋值
stringList[5] = "HelloWorld" //等价于 stringList.set(5,"HelloWorld")
val valueAt5 = stringList[5] // 等价于 String valueAt5 = stringList.get(5)
val map = HashMap<String,Int>()
map["Hello"] = 10
// '[]' 内的值实际上就是Key
println(map["Hello"])
// 解构:val (x,y) = pair
val pair = "Hello" to "Kotlin"
val pair2 = Pair("Hello","Kotlin")
val first = pair.first
val second = pair.second
println(first)
println(second)
// 解构:val (x,y,z) = triple
val triple = Triple("x",2,3.0)
val first = triple.first
val second = triple.second
val third = triple.third
println(first)
println(second)
println(third)
// 作业:
// 一、集合该如何遍历
val intNumber: List<Int> = listOf(1,2,3,4,5,6)
intNumber.forEach{a -> println(a)}
//二、集合的包含关系如何判断?
val intNumber2: List<Int> = listOf(1,2,3,4,5,6)
if (4 in intNumber2){
println("4包含于集合intNumber2")
}
if (400 !in intNumber2){
println("400不包含于集合intNumber2")
}
//三丶Scala 选择自己全新构建了一套集合框架,为什么 Kotlin没有?
}
五丶函数
- 函数的定义
- 函数的类型
- 函数的引用
- 变长参数 【Java】与 【Kotlin】版
- 多返回值
- 默认参数
- 默认参数 — 错误实例【X】
- 解决办法【√】— 通过:具名参数
1、函数的定义
2、函数的类型
3、函数的引用
4、变长参数
【Java】
【Kotlin】
多返回值
默认参数
默认参数 — 错误实例【X】
解决办法【√】— 通过:具名参数
package com.wangrui.kotlin.bennyhuo
fun main(vararg args: String) {
// println(args.contentToString())
// 这时的x 为函数类型,具体为:(Foo, String, Long)->Any
val x:(Foo, String, Long)->Any = Foo::bar
val x0: Function3<Foo, String, Long, Any> = Foo::bar
//三者等价
// (Foo, String, Long)->Any = Foo.(String, Long)->Any = Function3<Foo, String, Long, Any>
// val y: (Foo, String, Long) -> Any = x
val y: Foo.(String,Long) -> Any = x
val z: Function3<Foo, String, Long, Any> = x
//调用yy函数,并传入x函数类型作为函数参数
yy(y)
//拿到 fun foo() { } 的引用
val f: ()->Unit = ::foo
//拿到 fun foo(p0: Int): String { return "" } 的引用
val g: (Int) ->String = ::foo
/**
* 拿到:
class Foo {
fun bar(p0: String, p1: Long): Any{
println("one:$p0 Long:$p1")
return ""
}
}
的引用
*/
val h: (Foo, String, Long)->Any
= Foo::bar
// 变长参数
multiParameters(1, 2, 3, 4)
//利用具名函数,将值准确传给 y: String
defaultParameter(y = "Hello")
//解构表达式
val (a, b, c) = multiReturnValues() //实现 伪多返回值的场景
val r = a + b
val r1 = a + c
}
// p:是一个函数类型,这个函数其实就是 Foo::bar
fun yy(p: (Foo, String, Long) -> Any){
p(Foo(), "Hello", 3L) // Foo()指的是:类的引用,调用对应函数,并进行传参
}
class Foo {
fun bar(p0: String, p1: Long): Any{
println("one:$p0 Long:$p1")
return ""
}
}
fun foo() { }
fun foo(p0: Int): String { return "" }
//利用具名函数,将值准确传给 y: String
fun defaultParameter(x: Int = 5, y: String, z: Long = 0L){
}
// 变长参数
fun multiParameters(vararg ints: Int){
println(ints.contentToString())
}
// 伪多返回值
fun multiReturnValues(): Triple<Int, Long, Double> {
return Triple(1, 3L, 4.0)
}
总结
六丶案例:四则计算器
package com.wangrui.kotlin
/*
input: 3 * 4
*/
fun main(vararg args: String){
if (args.size < 3){
return showHelp()
}
//▲暂时不是很理解 to::plus
val operators = mapOf(
"+" to::plus,
"-" to::minus,
"*" to::times,
"/" to::div
)
val op = args[1]
val opFunc = operators[op]?:return showHelp()
try {
println("Input:${args.joinToString(" ")}")
println("Output:${opFunc(args[0].toInt(),args[2].toInt())}")
} catch (e: Exception) {
println("Invalid Arguments.")
showHelp()
}
}
fun plus(arg0:Int,arg1:Int):Int{
return arg0 + arg1
}
fun minus(arg0:Int,arg1:Int):Int{
return arg0 - arg1
}
fun times(arg0:Int,arg1:Int):Int{
return arg0 * arg1
}
fun div(arg0:Int,arg1:Int):Int{
return arg0 / arg1
}
fun showHelp(){
println("""
Simple Calculator:
Input: 3 * 4
Output:12
""".trimIndent())
}