一.kotlin相比于java：
java：
1.语法表现力差，例如：java1.8之前不支持lambda表达式，匿名内部的写法繁琐，在函数方面，不支持高洁函数，不支持参数默认值，也不支持函数命名参数。
2.可读性差，难维护 例如：java中的Callback嵌套多层的话，代码可读性就特别差，对维护更加困难
3.并发编程：在java 中，线程的并发以及它复杂的同步机制导致学习成本高。
总结：前期开发效率低，中期线上问题多，后期代码难维护
kotlin：
1.kotlin具有更加简洁的语法跟现代化语法特性，大大提高开发效率，线上奔溃率降低，java中的空指针问题也几乎可以避免
2.兼容性强：kotlin可以跟java混编，大部分旧的项目都是java开发，kotlin强大的兼容性可以让我们渐进的从java迁移到kotlin，不用一次性重写很多代码，从而产生新的问题
3.谷歌宣布kotlin成为官方语言后，现在各大招聘android，都会写着熟悉kotlin的优先，所以koltin我觉得是有非常好的前景的，赶紧入坑。
变量
在java中，如果我们要声明变量，我们必须声明它的类型，后面跟着变量的名称和对应的值，然后以分号结尾。就像这样：
int price = 100;
String msg = "我是msg";
而kotlin则不一样，我们要使用 val 或者是 var这样的关键字作为开头，后面跟“变量名称 -> price ”，接着是变量类型 ->Int 和赋值语句 ，
如下：
var price : Int = 100 ;
在kotlin 中，一般会把末尾的分号省略掉
var price : Int = 100
还有一点我们要注意，在kotlin中，我们应该尽可能的避免使用var ，尽可能多的去使用val。
var 跟 val 的区别
var price = 100 price = 101 //编译通过
val price = 0 price =101 //编译器报错
原因很简单，val声明的变量，我们叫不可变变量，它的值在初始化后就不能再次被修改，它相当于java中的 final 变量。
var声明的变量，我们叫可变变量，它对应java中的普通变量
基础类型
基础类型：包括我们常见的数字类型，布尔类型，字符类型。以及这些类型组成的数组
一切皆对象
在java中，基础类型会分为原始类型和包装类型。比如整型会有对应的int 和 Integer，前者是原始类型，后者是包装类型
int i = 0 ;//原始类型
Integer i = 1 ;//包装类型
java之所以要这么做，是因为原始类型的开销小，性能高，但它不是对象，无法很好的融入到面向对象的系统中。而包装类型的开销大，性能相对较差，但它是对象，可以很好的发挥面向对象的特性。
然而在kotlin语言体系中，是没有原始类型这个概念的，这就意味着，在kotlin里，一切都是对象
实际上，从某种程度上讲，Java 的类型系统并不是完全面向对象的，因为它存在原始类型，而原始类型并不属于对象。而 Kotlin 则不一样，它从语言设计的层面上就规避了这个问题，类型系统则是完全面向对象的。
Val i :Double = 1.toDouble()
可以发现，由于在kotlin中，整型数字“1”被看作对象了，所以我们可以调用它的成员方法toDoubel()，而这样的代码在java是无法实现的。
空安全
既然kotlin 中的一切都是对象，那么对象就有可能为空。也许你会想到写出这样的代码：
val i :Double = null //编译器报错
可事实上，以上的代码是不能通过编译。这是因为kotlin强制开发者在定义变量的时候，指定这个变量是否可能为null 。对于可能为null的变量，我们需要在声明的时候在变量类型后面加一个问号“？”：
val i :Double = null //编译器报错
val j :Double? = null //编译通过
并且kotlin 对可能为空的变量类型做了强制区分，这就意味着，“可能为空的变量”无法赋值给“不可能为空的变量”，当然，反向赋值是没有问题的
var i :Double = 1.0
var j :Double = null
i = j //编译器报错
j = i //编译通过
不过如果你有这种需求的话，也是可以做的：
var i :Double = 1.0
var j : Double = null
If( j != null ) i = j // 编译通过
数字类型
首先，在数字类型上，kotlin 跟 java 几乎是一样的，包括它们对数字“字面量” 的定义方式。
val int = 1 // 整型默认会被推导成“Int” 类型
val long = 12345L // Long类型，我们则需要使用 “L” 后缀
val double = 13.14 // 小数默认会被推导为 “Double ” ，我们不需要使用“D”后缀
val float = 13.14F // Float 类型， 我们需要使用 “F” 后缀
val hexadecimal = OxAF。//使用“Ox” 来代表十六进制字面量
val binary = Ob01010101 //使用“Ob”，来代表二进制字面量
数字类型的转换在 java 是可以隐式转换数字类型，而kotlin更推荐显示转换
例如 int 类型赋值给long类型，编译器会自动为我们做类型转换
int j =100；
long j = i ；
按照java的思维来看，好像是没有问题的，但是你要注意，虽然java编译器不会报错，可它可能会带来问题，因为它们本质不是同一个类型，int long float double 这些类型之间的互相转换是会存在精度问题的，尤其这样的代码掺杂在复杂的逻辑中，在碰到一些边界条件下，即使出现了bug 也很难排查出来
所以在kotlin中 在像这样的隐式转换是被抛弃了。 正确的做法是使用显式调用Int类型的toLong()函数
val i = 100
val j :Long = i.toLong( )
还有比如 toByte()、toShort()、toInt()、toLong()、toFloat()、toDouble()、toChar() 等等。Kotlin 这样设计的优势也是显而易见的，我们代码的可读性更强了，将来也更容易维护了
布尔类型
kotlin 布尔类型的变量 只有两种值 true 和false 布尔类型还支持一些逻辑操作，比如：
“&”代表“与运算”；“|”代表“或运算”；“!”代表“非运算”；“&&”和“||”分别代表它们对应的“短路逻辑运算”。
val i = 1
val j = 2
val k = 3
val isTrue: Boolean = i < j && j < k
字符：Cher
Char 用于表达单个字符 比如'A'. 'B'字符应该用单引号括起来
字符串 ：String
字符串用于表达一连串的字符，和java一样，kotlin的字符串也是不可变的，一般用双引号
kotlin还提供非常简洁的字符串模板：
val name = "kotlin"
print("Hello $name!")
在java中我们需要使用两个“+”进行拼接
print("Hello" + name + "!" )
这样看是不是简洁了许些，在字符串格式更复杂的情况下，更能体现出这个特性的简洁
如果我们需要在字符串当中引用更复杂的变量，则需要使用花括号将变量括起来：
val array = array("java","kotlin")
print("Hello ${ array.get( 1 ) } ! " )
Kotlin 还新增了一个原始字符串 ，用三个引号表示："""
它可以用来存放复杂的多行文本，并且它定义的时候是什么格式，打印也是对应的格式，不需要跟java写一堆的加号和换行符。
val s = """
当我们的字符串有复杂的格式时
原始字符串非常的方便
因为它可以做到所见即所得。 """print(s)
数组
在kotlin中，我们一般会使用 arrayOf()来创建数组
val arrayInt = arrayOf(1,2,3)
val arrayString = arrayOf("apple","pear")
同时kotlin编译器也会根据传入的参数进行类型推导，比如针对这里的arrayInt，由于我们赋值的时候传入的是整数，所以它的类型会被推导为整形数组。
在java中，获取数组的长度，java中应该使用"array.length", 如果是获取List的大小则是使用"list.size".这主要是因为数组不属于java集合。
不过在kotlin中，虽然数组仍然不属于集合，但它的一些操作是跟集合统一的。
val arrayString = arrayOf("apple","pear")
println("Size is ${array.size}")
println("First element is ${array[0]}")
//输出
Size is 2
First element is apple如上面的代码，我们直接使用array.size就能拿到数组的长度
函数声明
我们看一下以下的代码：
/*
关键字 函数名 参数类型 返回值类型
↓ ↓ ↓ ↓ */
fun helloFunction(name: String): String {
return "Hello $name !"
}/* ↑
花括号内为：函数体
*/在这段代码中：
- 使用了fun关键字来定义函数
- 函数名称。使用的是驼峰命名法
- 函数参数是以参数名在前，参数类型在后的写法
- 返回值类型，紧跟参数后面
在上面的代码，你会发现它的函数体只有一行代码，针对这种其实我们可以省略函数体的花括号，直接使用 ‘ = ’ 来连接，如下
fun helloFunction(name:String):String = "Hello $name !"
这种写法，我们称为单一表达式函数。
另外，由于kotlin支持类型推导，我们可以把返回值的类型也省略掉：
fun helloFunction(name:String) = "Hello $name !"
函数调用
如果我们想调用它：
heeloFunction（"kotlin"）
不过，kotlin还提供一些新的特性，那就是命名参数，简单来说，就是它允许我们在调用函数时传入“形参的名字”。
helloFunction(name = "kotlin")
让我们看一下更具体的使用场景：
fun createUser( name: String,
age: Int,
gender: Int,
friendCount: Int,
feedCount: Int,
likeCount: Long,
commentCount: Int) {
//.....省略
}这是一个包含很多参数的函数，在kotlin中，我们一般提倡以纵向的方式排列，这样更符合我们的阅读习惯
但是，如果我们像java那样调用createUser ，代码会非常难以阅读：
createUser（"Tom ",30,1,78,2093,10937,1211）
这里的第一个参数，我们知道肯定是name ，但是到了后面的一堆数字，就容易迷惑。
createUser(
name = "Tom",
age = 30,
gender = 1,
friendCount = 78,
feedCount = 2093,
likeCount = 10937,
commentCount = 3285
)如果我们这样写的话，可读性是不是变得更加强了呢。这里体现出kotlin命名参数的可读性跟易维护性两个优势
除了命名参数这个特性，kotlin还支持参数默认值。
fun createUser(
name: String,
age: Int,
gender: Int = 1,
friendCount: Int = 0,
feedCount: Int = 0,
likeCount: Long = 0L,
commentCount: Int = 0
) {
//..
}我们可以看到，里面的 参数大部分都被赋予了默认值，这样的好处在于，我们在调用时候就可以省很多事情，比如，下面这段代码只需要传3个参数，剩下的4个参数不传，编译器就会自动帮我们填上默认值。
createUser(
name = "Tom",
age = 30,
commentCount = 3285
)流程控制
在kotlin中，流程控制主要有 if ，when，for ，while
if
if主要用于逻辑判断。跟java基本一致
val i = 1
if (i > 0) {
print("Big")
} else {
print("Small")
}输出结果：
Big我们也可以这样写：
val message = if (i > 0) "Big" else "Small"
print(message)另外，由于kotlin明确规定类型分为 “可空类型” 跟“不可空类型”，因此，我们会经常遇到可空的变量，并且要判断它们是否为空：
fun getLength(text: String?): Int {
return if (text != null) text.length else 0
}在这个例子中，我们把if当成表达式，如果text不为空，就返回它的长度，如果为空，则返回0
在kotlin中，类型这样的逻辑判断出现的很频繁，因此，kotlin针对这种情况提供一种简写，叫做Elvis表达式。
fun getLength(text: String?): Int {
return text?.length ?: 0
}when
when语句，一般我们的逻辑只有两个分支时候，我们直接用if/else，而大于两个逻辑分支，我们使用when
val i :Int =1
when( i ){
1 -> print("1")
2 -> print ("2")
else -> print("i 不是1也不是2")
}when语句有点像java里面的 switch case语句，不过kotlin的when更加强大，它也可以作为表达式，为变量赋值：
val i :Int =1
val message = when( i ){
1 -> "一"
2 -> "二"
else -> print("i 不是1也不是2")
}
println（message）循环迭代：while 与 for
首先while循环，它在使用上跟java没有什么区别，都是用于重复执行某些代码
var i = 0
while (i <= 2) {
println(i)
i++
}var j = 0
do {
println(j)
j++
} while (j <= 2)输出结果：
0
1
2
0
1
2for
但是对于for语句，kotlin跟java的用法就不一样了。
kotlin的for语句更多用于“迭代” 如下代码就代表迭代array这个数组里的所有元素，程序会依次打印出 “1，2，3”。
val array = arrayOf(1, 2, 3)
for (i in array) {
println(i)
}
除了迭代数组跟集合外，kotlin还支持迭代一个区间。
首先，我们要定义一个区间，可以使用“..”来连接数组的区间的两端，比如“1..3”就代表从1到3的封闭间，左闭右闭
val oneToThree = 1..3 //代表[1,3]
接着，我们可以使用for语句，对这个闭区间范围进行迭代：
for (i in oneToThree) {
println(i)
}输出结果：
1
2
3甚至，我们可以逆序迭代一个区间，比如：
for (i in 6 downTo 0 step 2) {
println(i)
}输出结果：
6
4
2
0以上代码的含义就是逆序迭代一个区间，从6到0，每次的迭代的步长是2。需要注意的是，逆序区间我们不能使用“6..0”来定义。而是使用downTo