Map

通常我们对一个数组操作

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
val list= listOf(1,23,12,3,145)
val newList=ArrayList<Int>()
list.forEach{
val newElement=it*2+3
newList.add(newElement)
}
newList.forEach(::println)
}

使用map后

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
val list = listOf(1, 23, 12, 3, 145)
val newList = list.map { it * 2 + 3 }
newList.forEach(::println)
}

结果都是一样的

5
49
27
9
293

转换double也可以这么写

val newList2 = list.map (Int::toDouble)
newList2.forEach(::println)

flatMap

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
//int range的集合
val list= listOf(1..20,2..5,100..322)
//想变成[1,2,3,4,...20,2,3,4,5,100,101...321,322]、
val flatList=list.flatMap {
it
}
flatList.forEach(::println)

}

效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
100
.....................

 

如果想拼接字符串No.并打印呢。需要嵌套一层map

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
//int range的集合
val list= listOf(1..20,2..5,100..322)

val flatList=list.flatMap { inRange->
inRange.map {intElement->
"No.$intElement"
}
}
flatList.forEach(::println)

}
No.1
No.2
No.3
No.4
No.5
No.6
No.7
No.8
No.9
No.10
No.11
No.12
No.13
..................

reduce

求和或者是求阶乘

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
//int range的集合
val list = listOf(1..20, 2..5, 100..322)

val flatList = list.flatMap { inRange ->

inRange

}

println(flatList.reduce { acc, i -> acc + i })

}

结果

47277

不信的话可以算小的

val list = listOf(1..100)

结果是5050

阶乘算法

可能会遇到得bug

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
//int range的集合

(0..6).map ( ::factorial).forEach(::println)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

输出

1
1
2
6
24
120
720

Process finished with exit code 0

对阶乘再求和

 

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).reduce { acc, i -> acc + i }
println(res)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

结果

874

fold

可以用来计算

package com.yzdzy.kotlin.chapter5

fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).fold(5){acc, i ->

acc+i

}
println(res)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

结果:879 比上面多了5

可以用来拼接字符串 acc和i都变成了String格式

package com.yzdzy.kotlin.chapter5

import java.lang.StringBuilder

fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).fold(StringBuilder()){ acc, i ->

acc.append(i).append(",")

}
println(res)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

结果:1,1,2,6,24,120,720,

当然 真的想拼接字符串不需要这么复杂

只用

println((0..6).joinToString(","))

便可以得到

0,1,2,3,4,5,6

foldRight

倒叙使用

package com.yzdzy.kotlin.chapter5

import java.lang.StringBuilder

fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
val res = (0..6).map(::factorial).foldRight(StringBuilder()) { i, acc ->
acc.append(i).append(",")
}
println(res)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

720,120,24,6,2,1,1,

filter 只保留奇数

package com.yzdzy.kotlin.chapter5

import java.lang.StringBuilder

fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
var res = (0..6).map(::factorial)
val res2 = res.filter { it % 2 == 1 }
println(res2)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

[1,1]

只要奇数位置的阶乘

package com.yzdzy.kotlin.chapter5

import java.lang.StringBuilder

fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
var res = (0..6).map(::factorial)
val res2 = res.filterIndexed { index, j -> index % 2 == 1 }
println(res2)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

[1, 6, 120]

takeWhile 遇到第一个指定的条件不符合否则退出。比如遇到偶数退出 奇数执行

 

package com.yzdzy.kotlin.chapter5

import java.lang.StringBuilder

fun main(args: Array<String>) {
//int range的集合
//阶乘再想加
var res = (0..6).map(::factorial)
val res2 = res.takeWhile { it % 2 == 1 }
println(res2)

}

fun factorial(n: Int): Int {
if (n == 0) return 1
val res = (1..n).reduce { acc, i -> acc * i }
return res
}

[1,1]

let 可以省略?得写法

通常

package com.yzdzy.kotlin.chapter5

import java.lang.StringBuilder

class Person(val name: String, val age: Int) {
}

fun main(args: Array<String>) {
val person = finderPerson()
println(person?.name)
println(person?.age)


}

fun finderPerson(): Person? {
return null
}
package com.yzdzy.kotlin.chapter5


class PersonA(val name: String, val age: Int) {}

fun main(args: Array<String>) {
finderPerson()?.let { person ->
println(person.name)
println(person.age)
}


}

fun finderPerson(): PersonA? {
return PersonA("a", 1)
}

打印 a 1

为空也不会报错什么都不会输出

package com.yzdzy.kotlin.chapter5


class PersonA(val name: String, val age: Int) {}

fun main(args: Array<String>) {
finderPerson()?.let { person ->
println(person.name)
println(person.age)
}


}

fun finderPerson(): PersonA? {
return null
}

apply

更加省略参数。。。

package com.yzdzy.kotlin.chapter5


class PersonA(val name: String, val age: Int) {
fun work() {
println("$name is working")
}
}

fun main(args: Array<String>) {
finderPerson()?.apply {
work()
println(age)
}


}

fun finderPerson(): PersonA? {
return PersonA("小米",2)
}

 

小米 is working
2

with 他是把内容包括起来

package com.yzdzy.kotlin.chapter5

import java.io.BufferedReader
import java.io.FileReader


class PersonA(val name: String, val age: Int) {
fun work() {
println("$name is working")
}
}

fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt"))
with(br){
var line:String?
while (true){
line=readLine()?:break
println(line)
}
close()
}


}

fun finderPerson(): PersonA {
return PersonA("小米", 2)
}

close()是BufferedReader 得方法

就"hello.txt" 是在主工程目录下 而非当前java 目录下内容随便写 打印结果也是和他一样得

hwasda
adsjasd

实际的读取文件可不用这么麻烦啊。可以直接使用

fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt")).readText()
println(br)


}

还可以

val br = BufferedReader(FileReader("hello.txt")).readLines()
println(br)
[hwasda, adsjasd]

use

在上面的案列当中 我们开启br后要关闭br 非常不方便

 

with(br){
var line:String?
while (true){
line=readLine()?:break
println(line)
}
close()
}

修改代码 加上了it 别忘了。。

fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt"))
br.use {
var line: String?
while (true) {
line = it.readLine() ?: break
println(line)
}
close()
}


}

看使用到colose()得地方直接爆红   不给图了。

感兴趣的小伙伴可以点进去use源码看下

【28】kotlin 高阶函数forEach,map,flatmap,fold,reduce,filter,takeWhile,let,apply,with,use_拼接字符串

因为br是closeable得方法 所以可以使用use 而且不用id啊哦用use 它会自动帮我关闭

fun main(args: Array<String>) {
val br = BufferedReader(FileReader("hello.txt"))
br.use {
var line: String?
while (true) {
line = it.readLine() ?: break
println(line)
}
}


}