1、定义包
包的声明应处于源文件顶部
package com.kotlin.flong.base
import java.util.*
目录与包的结构无需匹配：源代码可以在文件系统的任意位置。
2、 定义函数
- 1、带有两个
Int参数、返回 Int 的函数：
//计算a+b
fun sum(a: Int,b :Int) : Int{
return a+b;
}
- 2、将表达式作为函数体、返回值类型自动推断的函数：
//无return关键字的加法
fun sum1(a: Int,b : Int) = a + b;
- 3、函数返回无意义的值,
$是占位符进行处理
//函数返回无意义的值,`Unit`相当于void,$是占位符进行处理
fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}
- 4 Unit 返回类型可以省略：$是占位符进行处理
//无Unit
fun printSum1(a: Int, b: Int) {
println("sum of $a and $b is ${a + b}")
}
3、 定义变量
- 定义只读局部变量使用关键字
val定义。只能为其赋值一次。
//一次赋值（只读）的局部变量:
fun test1(){
val a: Int = 1 // 初始化值
val b = 2 // 类型推断出 `Int` 类型
val c: Int // 如果没有初始值类型不能省略
c = 3 // 明确赋值
println(c)
}
4、占位符模板
- replace和$使用
//replace和$使用
fun replace(){
var a = "中国人"
val s1 = "我是 $a" //占位符模板
println(s1);
//将是改变成is
val s2 = "${s1.replace("是", "is")}, but now is $a"
println(s2);
}
5、使用条件表达式，求最大值max
- 1、无return返回的求最大值，
//找最大值
fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
- 2、不使用return
fun max1(a : Int ,b : Int) = if(a>b) a else b;
6、使用类型检测及自动类型转换
注意：这里的
is相当于java的instanceof关键字
//is的使用,?允许返回null，Any表示任何类型
//当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引⽤可为空
fun isStr(obj : Any) : Int ?{
// `obj` 在 `&&` 右边⾃动转换成 `String` 类型
if (obj is String && obj.length > 0) {
return obj.length
}
return null
}
- 或者
fun getStringLength(obj: Any): Int? {
if (obj !is String) return null
// `obj` 在这一分支自动转换为 `String`
return obj.length
}
7、String字符串对比
注意：比较字符串的内存地址，相当于Java的str1==str2，输出false
//字符串对比
fun biaojiaoStr1(){
var str1 = "abc"
var str2 = String(charArrayOf('a','b','c'))
//比较字符串的值，输出true
println(str1.equals(str2))
//比较字符串的值，输出true
println(str1==str2)
//比较字符串的内存地址，相当于Java的str1==str2，输出false
println(str1===str2)
}
8、使用可空值及 null 检测
- 当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空，如果 str 的内容不是数字返回 null：
fun parseInt(str: String): Int? {
// ……
}
*使用返回可空值的函数:
fun printProduct(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)
// 直接使用 `x * y` 会导致编译错误，因为他们可能为 null
if (x != null && y != null) {
// 在空检测后，x 与 y 会自动转换为非空值（non-nullable）
println(x * y)
}
else {
println("either '$arg1' or '$arg2' is not a number")
}
}
- 或者
// ……
if (x == null) {
println("Wrong number format in arg1: '$arg1'")
return
}
if (y == null) {
println("Wrong number format in arg2: '$arg2'")
return
}
// 在空检测后，x 与 y 会自动转换为非空值
println(x * y)
9、for 循环的使用
- for 循环的使用
val items = listOf("苹果", "香蕉", "橙子")
for (item in items) {
println(item)
}
//或者
val items = listOf("苹果", "香蕉", "橙子")
for (index in items.indices) {
println("item at $index is ${items[index]}")
}
10 使用 while 循环
val items = listOf("apple", "banana", "kiwifruit")
var index = 0
while (index < items.size) {
println("item at $index is ${items[index]}")
index++
}
11、使用 when 表达式
fun describe(obj: Any): String =
when (obj) {
1 -> "One"
"Hello" -> "Greeting"
is Long -> "Long"
!is String -> "Not a string"
else -> "Unknown"
}
12、使用区间（range）
- 使用 in 运算符来检测某个数字是否在指定区间内
val x = 10
val y = 9
if (x in 1..y+1) {
println("fits in range")
}
- 检测某个数字是否在指定区间外
val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
println("-1 is out of range")
}
if (list.size !in list.indices) {
println("list size is out of valid list indices range, too")
}
- 区间迭代:
for (x in 1..5) {
print(x)
}
- 或数列迭代：
for (x in 1..10 step 2) {
print(x)
}
println()
for (x in 9 downTo 0 step 3) {
print(x)
}
13、使用集合
- 对集合进行迭代:
for (item in items) {
println(item)
}
- 使用 in 运算符来判断集合内是否包含某实例
when {
"orange" in items -> println("juicy")
"apple" in items -> println("apple is fine too")
}
- 使用 lambda 表达式来过滤（filter）与映射（map）集合：
val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
fruits
.filter { it.startsWith("a") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { println(it) }
14、创建基本类及其实例
注意：不需要“new”关键字
val rectangle = Rectangle(5.0, 2.0) // 不需要“new”关键字
val triangle = Triangle(3.0, 4.0, 5.0)
15、split 分隔符的使用
- split支持多个特殊进行切割,kotlin的split比java的split强
fun split(){
var str = "苹果,香蕉-橙子"
//支持多个特殊进行切割,以,和-进行分割
var strs = str.split(",","-")
for(s in strs){
println(s)
}
}
- 输出的结果为
苹果
香蕉
橙子
16、substring的使用
//substring的使用
fun subStr(){
val path = "/Users/ljl/kotlin/chapter.doc";
//获取前6个字符
println(path.substring(0,6))
//使用范围获取前6个字符
println(path.substring(0..5))
//把第一个r之前的字符串截取
println(path.substringBefore('r'))
//把最后一个r之前的字符串截取
println(path.substringBeforeLast('r'))
//把第一个r之后的字符串截取
println(path.substringAfter("r"))
//把最后一个r之后的字符串截取
println(path.substringAfterLast("r"))
}
17、元祖使用
//元祖使用
fun pair(){
//定义一个二元元组
var pair = Pair<String,Int>("我是寅务",29)
var pair1 : Pair<String,Int> = "我是寅务" to 29
println(pair.first + "," +pair.second)
println(pair1.first + "," + pair1.second)
//定义一个三元元组
var triple = Triple<String,Int,String>("我是寅务",29,"岁")
println(triple.first + "," +triple.second + "," + triple.third)
}
18、?与!!的使用区别
- ? 可空变量类型
- ? 表示可以为空，不加表示不能为空
- ?. 空安全调用符，这种做法先显眼就是为了判断非空值如同 if(age !=null)
- !! 非空判断
- !!表示告诉kotlin编辑器,此值不要检查了，password一定不为空， 这种值处理如果不确定的话显眼不安全 ，不建议使用
fun testNull(){
// ? 可空变量类型
val age : Int? = null
// !! 非空判断
var userName : String = null !!
// ? 表示可以为空，不加表示不能为空
var passWord : String? = null
// ?. 空安全调用符，这种做法先显眼就是为了判断非空值如同 if(age !=null) age.toI
println(age?.toInt())
//?： elvis操作符(猫王）,age?.toInt()表示if(age!=null) age.toInt else 返回 默认就给10
var ageInt : Int = age?.toInt() ?: 10
println(ageInt)
//!!表示告诉kotlin编辑器,此值不要检查了，password一定不为空,
// 这种值处理如果不确定的话显眼不安全 ，不建议使用
passWord!!.toInt()
}
19、注释
- 正如 Java 与 JavaScript，Kotlin 支持行注释及块注释,与 Java 不同的是，Kotlin 的块注释可以嵌套
// 这是一个行注释
/* 这是一个多行的 块注释。 */
20、函数的参数默认
//函数的参数默认
fun defVal(age:Int,username:String = "liangjl"){
println("$username,$age")
}
21、vararg 可变参数
vararg是可变参数,相当于java的三个点：String ... strs但是java的可变参数必须要在方法的最后一个参数
fun varargs(vararg a : Int ):Int{
var result =0
a.forEach {
result += it
}
return result;
}
- vararg 使用
println(varargs(10,20,30))
- Java 的可变参数代码
public static void TestArgs(String userName,String ... args){
// 省略
}