Kotlin 全部基础
Posted 黄毛火烧雪下
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Kotlin 全部基础相关的知识，希望对你有一定的参考价值。
IDEA
Kotlin 提供了很多便利，简化了java很多模式化代码。有人说可读性相对较差，习惯之后，会觉得Java不好读。比如：中文思维会觉得英语很难理解，相反而至。每个都要敲代码，磨刀不误砍柴工。泛型如果用好还是有难度的。kt 会越来月流行，不是因为它很强大，而是谷歌在推kotlin，没办法。就说AS 和 eslipse 哪个会一定更好用，并没有。越来越多是kotlin的支持，人世有代谢往来成古今江山留胜迹,我辈复登临。kotlin比java更灵活，移动端不需要那么多并发量。kotlin更像js代码。蹭java 的热度，有有自己的语言，有话语权。移动端开发和前端开发将会有越来越多共同的技术，提升开发效率，降低成本，大势所趋，界面用户体验上的逻辑。新技术出来，天然的抵触，不断的调整心态，新的技术去了解，动向，kotlin 大势所趋，必须学。IT行业，不断有年轻人进入的行业，我们要追随年轻人的脚步。在算法中，函数编程用的比较多。kotlin最大的好处就是支持kotlin和java混编。
直接上项目，用到的知识点只是40%，
1.SHIFT 两下，show kotlin Bytecode
2.kotlin可以使用特殊字符命名函数名，使用反引号括住函数名避免冲突
print(ere("jjj"))
private fun `ere`(name: String, age: Int = 2)
print(name + age)
3.匿名函数(函数式编程很流行，应用很广泛)
val total:Int="Mississippo".count()
val totals:Int="Mississippo".count letter -> letter == 's'
print(total) 11
print(totals) 4
匿名函数不需要return关键字返回数据，会自动返回最后一行语句的结果
//变量的类型是个匿名函数，无参，返回值是String
val result: () -> String
result =
val name = "aaaaa"
"$name"
//声明的时候赋值
val result: () -> String =
val name = "aaaaa"
"$name"
val result: (Int) -> String = age ->
val name = "aaaaa"
"$name $age"
val result: (Int) -> String =
val name = "aaaaa"
"$name $it"
//类型推断
val result = age:Int ->
val name = "aaaaa"
"$name $age"
print(result(5)) aaaaa 5
4.IDEA 设置Kotlin 自动类型推断后的类型
5.定义参数是函数的函数
//eg2
showOnBoard("苹果") goodsName: String, hour: Int ->
"$goodsName$hour"
fun showOnBoard(goodsName: String, getDiscountWords: (String, Int) -> String)
val hour = (1..24).shuffled().last()
print(getDiscountWords(goodsName, hour))
6.函数内联即预编译指令，宏定义==宏替换
val getDiscountWords = goodsName: String, hour: Int ->
"$goodsName$hour"
showOnBoard("苹果", getDiscountWords)
inline fun showOnBoard(goodsName: String, getDiscountWords: (String, Int) -> String)
val hour = (1..24).shuffled().last()
print(getDiscountWords(goodsName, hour))
7.函数引用(lambda可替换)
showOnBoard("苹果", ::getDiscountWords)
fun getDiscountWords(goodsName: String, hour: Int): String
return "$goodsName$hour"
fun showOnBoard(goodsName: String, getDiscountWords: (String, Int) -> String)
val hour = (1..24).shuffled().last()
print(getDiscountWords(goodsName, hour))
8.函数类型作为返回类型
//eg1
getFullName("aa", result =
print(it)
)
getFullName("aa")
print(it)
fun getFullName(name: String, result: (count: Int) -> Unit)
result.invoke(name.count())
9.kotlin传递函数=java传递接口
public class aaa
public static void main(String[] args)
getFullName("aa", new Result()
@Override
public void getResult(int count)
System.out.println(count);
);
public interface Result
void getResult(int count);
public static void getFullName(String name,Result result)
result.getResult(name.length());
10.kotlin中lambda就是闭包，作用域、函数式编程风格
11.字符串操作
substring
const val NAME = "Jimmy's friend"
var index = NAME.indexOf('\\'')
// var str = NAME.substring(0, index)
var str = NAME.substring(0 until index)
print(str) Jimmy
split 返回list集合数据，list集合支持 解构语法特性 ，其常用简化变量的赋值
const val NAME = "Jimmy,Jim,Bob"
val str =NAME.split(",")
var (one:String,two:String,three:String) =NAME.split(",")
println(str) [Jimmy, Jim, Bob]
println("$one $two $three") Jimmy Jim Bob
//跳过某个值，不会赋值，提高代码运行效率
val list = mutableListOf<String>("aa", "bb", "cc")
val (one: String, _: String, three: String) = list
print("$one $three") aa cc
replace 比java更加强大
const val NAME = "The people's republic China."
fun main()
val str=NAME.replace(Regex("[ae]"))
when (it.value)
"a"->"8"
"e"->"6"
else -> it.value
println(str) Th6 p6opl6's r6public Chin8.
字符串比较 (内存分配) , == 检查两个字符串中的字符是否匹配，（相当于java中的equals）; === 检查两个变量是否指向内存堆上同一对象相当于java中的==）
val str1="aa"
val str2="aa"
println(str1==str2) true
println(str1===str2) true
val str1="Aa"
val str2="aa".capitalize()
println(str1==str2) true
println(str1===str2) false
double 转int，double 格式化
//保留两位小数 ，四舍五入
val aa = 200.28212
print( "%.2f".format(aa))
12.标准函数 apply let run(可执行引用函数，链式调用) with(一般不用) alse takeIf
let
fun formatGreeting(guestName: String?): String
return guestName?.let "Welcome,$it" ?: "What's your name?"
print(formatGreeting(null)) What's your name?
run(可执行引用函数，链式调用)
var file = File("D://demo//111//readme.txt")
val result = file.run readText().contains("great")
print(result) true
fun isLong(name: String) = name.length >= 10
fun showMessage(isLong: Boolean): String
return if (isLong)
"Name is too long"
else
"Please rename"
"D://demo//111//readme.txt".run(::isLong).run(::showMessage).run(::print)
run 和with 传参方式不一样
val result = "aaaaaa".run length > 3
val result = with("aaaaaa")
length > 3
alse （我也）返回接收者对象
var fileContents: List<String>
File("D://demo//111//readme.txt")
.also println(it.name)
.also fileContents = it.readLines()
println(fileContents)
readme.txt
[great good]
takeif 如果需要判断某个条件是否满足，再决定是否可以赋值变量或者执行某项任务
val result= File("D://demo//111//readme.txt")
.takeIf it.exists() && it.canRead()
?.readText()
println(result) great good
//不存在
val result= File("E://demo//111//readme.txt")
.takeIf it.exists() && it.canRead()
?.readText()
println(result) null
13.list set
list 通过安全索引函数 获取元素
val list = listOf<String>("aa", "bb", "cc")
println(list.getOrElse(3) "unknow" ) unknow
println(list.getOrNull(3) ?: "unknow") unknow
mutable 函数
val list = mutableListOf<String>("aa", "bb", "cc")
//运算符重载
// list.add("dd")
list += "dd"
//list.remove("dd")
list -= "dd"
//如果此值符合条件，则移除
list.removeIf it.contains("aa")
//可变和不变相互转换
list.toList().toMutableList()
list 索引遍历
list.forEachIndexed index, s ->
set 不可重复，elementAt，其余的都和list用户一致
val set = setOf<String>("aa", "bb")
print(set.elementAt(0))
list 转set 去除重复元素 去重
val list = listOf<String>("aa", "bb","bb")
//print(list.toSet().toList())
//快捷函数
print(list.distinct())
数组类型提供各种array 是引用类型，最终编译成java基本数据类型
map，其它操作写法和list大概一致，to 相当于Pair() 函数
val map = mapOf("aa" to 20, "bb" to 30)
mapOf(Pair("aa", 20), Pair("bb", 30))
println(map["aa"]) 20
println(map.getValue("aa")) 20
println(map.getOrElse("cc")"qq") qq
println(map.getOrDefault("cc",0)) 0
map 遍历
val map = mapOf("aa" to 20, "bb" to 30)
map.forEach
println("$it.key,$it.value")
map.forEach (key: String, value: Int) ->
println("$key,$value")
map 添加元素 getOrPut
val map = mutableMapOf("aa" to 20, "bb" to 30)
map += "cc" to 40
map["cc"] = 40
//如果没有则增加
map.getOrPut("dd") 50
println(map)
14.kotlin class 类自动生成get/set方法
field 覆盖get、set
class Player
var name: String = "j a ck"
get() = field.capitalize()
set(value)
//去掉前后空格
field=value.trim()
fun main()
var p=Player()
println(p.name)
p.name=" tom "
println(p.name)
15.初始化
主构造函数
import kotlin.math.absoluteValue
class Player(_name: String, _age: Int)
//临时变量只用一次的用下划线
//get和set紧跟属性,private说明name只读不可以改变
var name = _name
get() = field.capitalize()
private set(value)
field = value.trim()
var age = _age
get() = field.absoluteValue
set(value)
field = field.absoluteValue
fun main()
val p=Player("Tom", 30)
在主构造函数里定义属性
class Player(_name: String, var age: Int)
//临时变量只用一次的用下划线
//get和set紧跟属性,private说明name只读不可以改变
var name = _name
get() = field.capitalize()
private set(value)
field = value.trim()
fun main()
val p=Player("Tom", 30)
次构造函数 constructor
class Player(_name: String, var age: Int)
//临时变量只用一次的用下划线
//get和set紧跟属性,private说明name只读不可以改变
var name = _name
get() = field.capitalize()
private set(value)
field = value.trim()
constructor(name:String):this(name,100)
this.name=name.toUpperCase()
初始化块 init
init
require(age>10)"age must be positive"
val p=Player("Tom",9)
初始化顺序
1.著构造函数离声明的属性
2.类级别的属性赋值
3.init初始化块里的属性赋值和函数调用
4.此构造函数里的属性赋值和函数调用
延迟初始化 lateinit，用它的时候再初始化
fun main()
var user = User()
// user.ready()
user.battle()
class User
lateinit var equipment: String
fun ready()
equipment = "knife"
fun battle()
//健壮的语言
if (::equipment.isInitialized)
println(equipment)
惰性初始化 by lazy 延迟记载
fun main()
var user = User()
Thread.sleep(3000)
user.config
class User
//懒汉式
val config by lazy loadConfig()
//饿汉式，一上来就记载
//val config =loadConfig()
private fun loadConfig(): String
println("loading...")
return "xxx"
初始化陷阱1-按照顺序来编译，顺序不能写反
class User
val blood = 100
init
val bloodBonus = blood.times(4)
初始化陷阱2-按照顺序来编译，顺序不能写反
class User
val name: String
private fun firstLetter() = name[0]
init
//一下两个顺序不能反
name = "Jack"
println(firstLetter())
16.继承
如果继承类，就要用open来修饰；如果子类需要覆盖父类函数，也需要open来修饰
open class Product(val name:String)
open fun load()="Nothing.."
class AA:Product("aa")
override fun load()="xxxxx......"
fun main()
val p:Product=AA()
println(p.load())
//类型检测 is
println(p is Product)
智能类型转换 as，转一次则后面可以直接使用
Any 超类，任意类型 都是Any类 ，Kotlin的跨平台比java更好
object 关键字
单例对象：防止浪费资源；方便管理状态，因为只有一份。
//单例对象
object ApplicationConfig
//打印同一个对象
print(ApplicationConfig)
print(ApplicationConfig)
伴生对象 companion
open class configMap
companion object
private const val PATH="xxxx"
fun load()=File(PATH).readBytes()
fun main()
//比javastatic更加人性化，不调用，则不执行
ConfigMap.load()
嵌套类
class Player2
class Equipment(var name:String)
fun show=println("equipmeng:$ name")
fun main()
Player2.Equipment("knife").show()
数据类 data 专门存数据的类 ,提供 toString / copy(new了新对象，陷阱：不用次构造) / 解构语法
data class Coordinate(var x:Int,var y:Int)
val isInBounds= x>0
fun main()
//比较属性的值
println(Coordinate(10,20)==Coordinate(10,20)) true
解构声明
//必须以下写法
class PlayerScore(val experience:Int,val level:Int)
operator fun component1()=experience
operator fun component1()=level
fun main()
val(x,y)=PlayerScore(10,20)
print("$x $y")
//数据类支持解构语法
data class PlayerScore(val experience:Int,val level:Int)
fun main()
val(x,y)=PlayerScore(10,20)
print("$x $y")
运算符重载
data class PlayerScore(val x:Int,val y:Int)
operator fun plus(other:PlayerScore)=PlayerScore(x+other.x,y+other.y)
fun main()
val a=PlayerScore(10,20)
val b=PlayerScore(10,20)
println(a+b)
枚举类 特殊类 可以定义函数
enum class Direction(private val score:PlayerScore)
EAST(PlayerScore(1,2)),
WEST(PlayerScore(3,2);
fun updateScore(two:PlayerScore)=PlayerScore(two.x+score.x , two.y+score.y)
fun main()
print(Direction.EAST) EAST
print(Direction.EAST.updateScore(PlayerScore(10,10))) PlayerScore(x=11,12)
代数数据类型 ADT 条件固定，else省略
enum class Direction
EAST,
WEST;
class DD(var a:Direction)
fun check():String
retrun when(a)
Direction.EAST ->"东"
Direction.WEST ->"西"
密封类 sealed 里面包含很多类,遇到太复杂的枚举(某个状态需要又个属性 )，则衍生出密封类
enum class Direction
object EAST:Direction(),
class WEST( val str:String):Direction();
class DD(var a:Direction)
fun check():String
retrun when(a)
is Direction.EAST ->"东"
is Direction.WEST ->"西$t(his.a as WEST).str"
17.接口（一般提供功能，90%只提供函数声明）
interface 默认open,实现使用overrided，默认实现
interface Movable
val maxSpeed:Int
get()=(1..500).shuffled().last()
var wheels:Int
fun move(movable:Movable):String
class Car(name:String,override var wheels:Int=4):Movable
override var maxSpeed:Int
get()=super.maxSpeed
set(value)
override fun move以上是关于Kotlin 全部基础的主要内容，如果未能解决你的问题，请参考以下文章
Kotlin函数式编程 ③ ( 早集合与惰性集合 | 惰性集合-序列 | generateSequence 序列创建函数 | 序列代码示例 | take 扩展函数分析 )
Kotlin函数式编程 ③ ( 早集合与惰性集合 | 惰性集合-序列 | generateSequence 序列创建函数 | 序列代码示例 | take 扩展函数分析 )
在不调用属性的情况下获取休眠惰性关系 n+1 - Kotlin