java 默认参数列表_命名参数,默认参数,位置参数,函数简化,嵌套函数

1.函数简化

fun plus(args1:Int,args2:Int):Int {

return args1+args2

}

fun plus(args1:Int,args2:Int):Int = args1+args2

2.命名参数,参数默认值,位置参数

/**

* 命名参数,位置参数调用的时候有个主意事项,位置参数必须放在命名参数的前面

* 如果写成(name="huhu",20,"hehe"),那么后两个参数就会报错

*Mixing named and positioned arguments is not allowed

*/

namedParams("huhu", age = 20, id = "hehe")

3.嵌套函数

可以在函数内部声明一个函数,这个函数不可以被外部函数之外的地方使用

4.字符串模板和原生字符串

val name = "world"

// 👇 用 '$' 符号加参数的方式

println("Hi $name")

println("Hi ${args.length})

fun testString() {

var strings = """

wo hsi yige zho fa.?jn

dkjfkajdkf adfa

jdkfjak

"""

println(strings)

}

5.数组和集合的操作符

forEach():遍历每一个元素

fun testArraySysmol() {

var strArray1 = intArrayOf(1,2,3,4)

strArray1.forEach { i -> println(i) }

}

filter:对每个元素进行过滤操作,如果条件满足则留下,不满足则剔除,返回一个集合类型的数据

fun testArraySysmol() {

var strArray1 = intArrayOf(1,2,3,4)

//注意:这里数组类型使用.filter()之后,返回值为List类型

val filter: List = strArray1.filter { i -> i != 1 }

filter.forEach { i -> println(i) }

}

map:遍历每一个元素并执行给定的表达式,返回一个List集合

fun testArraySysmol() {

var strArray1 = intArrayOf(1,2,3,4)

var mapResult:List = strArray1.map { i -> i+2 }

mapResult.forEach { i -> println(i) }

}

flatMap:遍历每一个元素,并未每个元素创建一个新的集合,最后合并成为一个集合

fun testArraySysmol() {

var strArray1 = intArrayOf(1,2,3,4)

var flatMapResult:List = strArray1.flatMap { i -> listOf("${i+2}","a") }

flatMapResult.forEach { i -> print(i) }

}

Range:区间,范围

fun rangeTest() {

//表示1到1000,包括1000

val rangeNum:IntRange = 1..1000

//表示1到1000,但不包括1000

val rangeNum:IntRange = 1 until 1000

for (i in rangeNum) println(i)

//step : 设置步长 1,3,5,7,9

for (i in rangeNum step 2) println(i)

//downTo:递减区间

for (i in 4 downTo 1) println(i)

}

Sequence:惰性加载集合

一旦满足遍历退出的条件，就可以省略后续不必要的遍历过程。

像 List 这种实现 Iterable 接口的集合类，每调用一次函数就会生成一个新的 Iterable，下一个函数再基于新的 Iterable 执行，每次函数调用产生的临时 Iterable 会导致额外的内存消耗，而 Sequence 在整个流程中只有一个。

fun listTest() {

val listResult = listOf(1,2,3,4)

var result2 = listResult.map { i->

print("Map $i ,")

i*2

}

.filter { i ->

print("Filter $i ,")

i%3 == 0

}

//list不管下面执行不执行,上面的代码都会立即执行

println(result2.first())

}

fun squenceTest() {

var squenceResult = sequenceOf(1,2,3,4)

var result2:Sequence = squenceResult.map { i ->

print("Map $i ,")

i*2

}

.filter { i ->

print("Filter $i ,")

i%3 == 0

}

//在下面的这句println执行前,上面的print()是不会调用的,也就是说sequence只是指定流程,而并不立即执行

println(result2.first())

}

条件控制

fun whenTest(num:Int) {

when(num) {

// 也可以这样写

// 0,1 -> println("我是0,或者1")

0 -> println("我是0")

1 -> println("我是1")

2 -> println("我是2")

else -> print("我是特殊情况")

}

}

in

fun whenTest(num:Int) {

when(num) {

in 0..10 -> println("我在里面")

in listOf(11,22,33,44,55) -> println("我在集合中")

else -> print("我是特殊情况")

}

}

is :进行特定类型的检测

when后面省略参数,每一个分支条件都可以是一个布尔表达式：

when {

str1.contains("a") -> print("字符串 str1 包含 a")

str2.length == 3 -> print("字符串 str2 的长度为 3")

}

For

fun testFor() {

//循环集合

var listData = listOf("mike","marry","jonse")

for (item in listData) println(item)

//循环一个100次呢

for (item in 1..100) print("$item ,")

}

try..catch

fun testTryCatch() {

try {

val i = 5

val j = 0

i/j

}catch (e:Exception) {

println("我异常了")

}finally {

println("我是必须要执行的")

}

}

和java的亮点不同:

1.java中如果抛出一个异常,那么调用的地方一定要进行处理,否则报错

kotlin中是不会报错的,但在运行时可能报错

2.Kotlin 中 try-catch 语句也可以是一个表达式，允许代码块的最后一行作为返回值：

val a: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }

?.和?:

var str: String? = null

fun testnullsafe() {

var length:Int? = str?.length

var length2:Int = str?.length?:-1

}

第二种用法:

fun validate(user: User) {

val id = user.id ?: return // 👈 验证 user.id 是否为空，为空时 return

}

== 与 ===

== ：可以对基本数据类型以及 String 等类型进行内容比较，相当于 Java 中的 equals

=== ：对引用的内存地址进行比较，相当于 Java 中的 ==