用Kotlin简化代码

自从谷歌在IO大会上将kotlin指定为Android的一级语言，kotlin的人气是刷刷刷的往上飙啊，既然如此，让我们来看看kotlin有什么好处，谷歌为啥要把它作为Android的一级语言呢

1. 100%兼容java

这个是最重要的一点了，由于kotlin也是运行在 JVM上，而且连编译出来的字节码文件都是一样的，甚至直接就用了jdk，直接使用java的库，所以这样看来，kotlin和java是100%兼容的。

你可以在java中调用kotlin文件，也可以在kotlin中使用java文件

2. 类型的自动判断

其实并不是没有了类型，只是帮你自动判断了,便捷了很多

//这就是一个Int了
var a = 1
//这就是一个String了
var b = "string"
//如果你想要给他们赋值，还是要注意类型的
a = b //这可是会报错的

当然，如果你觉得不爽的话，给他们一个类型也是可以的，不过这样就很多余了

val a: Int = 1

还有更智能的呢

if(a is User)
{
    a = b.getUser()
}

你要是在java里面这么写还不得给编译器抱怨死，不给他一个强制类型转换肯定是不行的，而在kotlin里面，编译器显然要聪明很多，发现你前面判断过了，就给你直接赋值了

3. 自动拆装箱

这也算是填了java的一个坑吧，在kotlin中你再也不需要去考虑到底是用int还是Integer了，因为在kotlin中全部都用Int，至于判断全部交给它自己去判断了

4. 数据类（data class）

对于我们经常创建的那些pojo，kotlin也对他们做了语法上的支持，那就是data class。

在data class中封装了很多东西，比如get/set、tostring、hashCode等方法，以后定义pojo就简单了很多

data class User(val name: String, val age: Int)

当然这里面还是有点坑的，因为kotlin中默认class都是final的，而且data默认是没有空的构造的，这就导致我们写程序时候出现了很多奇怪的错误

不过还好，官方出了noarg和allopen两个插件帮我们解决了这个问题

5. 扩展方法

在kotlin中我们可以给我们的任意类扩展方法，看一下例子就明白了

fun main(args: Array<String>)
{
    println(2.pow2()) //4.0
}

fun Int.pow2() = Math.pow(this.toDouble(), 2.0)

在这里我们给Int类扩展了一个二次方方法，我们甚至还可以重载运算符

fun main(args: Array<String>)
{
    val point = Point(2.3,4.5)
    println(-point)  //Point(x=-2.3, y=-4.5)
}

data class Point(var x: Double, var y: Double)
{
    operator fun unaryMinus() = Point(-x, -y)
}

6. 字符串拼接

在kotlin中，拼接字符串再也不像以前那样一堆加号一个个拼，实在太累了，看看kotlin是怎么做的

val a = "你好"
val point = Point(2.3,4.5)
println("$a,我的坐标是x=${point.x},y=${point.y}")
//你好,我的坐标是x=2.3,y=4.5

这样是不是方便了很多

7. 选择判断

1. if表达式

kotlin中的if else也是有返回值的

Java:

if (a>b){
   max=a;
   }else{
       max=b;
   }

Kotlin:

val max = if(a > b) a else b

这样写也是可以的

val max = if (a > b) {
    println("a=$a")
       a
   } else {
       println("b=$b")
       b //默认最后一行是返回值
   }

2. when

Java:

switch(a)
{
  case 1:
    System.out.println(a);
    break;
  case 2:
    System.out.println(a);
    break;
  case 3:
    System.out.println(a);
    break;
  default:
    System.out.println(a);
}

Kotlin:

when(a)
{
  1->println(a)
  1,2->println(a)
  //还可以这样
  in 3..33->println(a)
  !in 200..500->println(a)
  //甚至可以这样
  Math.max(7,9)->println(a)
  //只要你能想到的，都可以试试，无论是函数还是字符串、Any什么的
  else->println(a)
}

还可以不要判断条件，这样默认判断boolean

when
{
  x>10->println(1)
  x<10->println(2)
  else->print(10)
}

7. lambda表达式

在kotlin中大量的使用了lambda表达式，这使得代码简化了很多

//其中view就是it
btn.setOnClickListener {
            val text = it.getText().toString()
            log.i(this, text)
        }
//如果看不惯，可以改成这个样 
btn.setOnClickListener {view ->
            val text = view.getText().toString()
            log.i(this, text)
        }

还可以用::来引用一个方法

val array = arrayListOf<String>("a","b","c")
array.forEach ( ::println )

这样就可以把所有的元素打印出来了

下面就是kotlin中最惊艳的一部分了

8. Null安全

null曾经被戏称为“十亿美金的错误”，不过也确实，null虽然好用，但是导致很多错误的元凶往往都是他

在Kotlin中，编译器是可以识别你的引用是否是null，进而提醒你。

默认的，kotlin中所有的对象都是不为null的，如果需要你可以在对象后加上一个?表示此对象可以为null，但这是不被提倡的

data class hello(var name: String?)

对于一个可空对象，你也可以使用!!来强制使他不报错，但是建议除非万不得已不要使用

val len = a!!.length

对于Java中的强制类型转换，在Kotlin中变为了安全转型,在无法转型时不会报ClassCastException，而是直接返回null

val a = b as String

安全调用(?.)

Java:

int len = null;
if(a != null)
  len = a.length();

Kotlin:

var len =a?.length()

甚至这样都可以

//只要有一个为null就返回null
d = a?.b?.c?.length()

Elvis 操作符(?:)

Java:

int len;
if(a != null)
  len = a.length();
else
  len = 0;

Kotlin:

val len = a?.length ?: 0

9. 操作符

kotlin中内置了很多的操作符，这大大减轻了我们的工作负担，让我们来看几个

forEach

val list1 = listOf(1..34, 4..7)
val list2 = listOf(2,4,6,23,87)

//这个之前也提到过，很多语言都已经有了，可以把集合遍历
//可以结合lambda表达式，对元素进行操作
list2.forEach { print("$it ") }
list1.forEach {it.forEach { print("$it ") }}
//forEach并没有返回值，所以这样的操作其实是无效的
list2.forEach{it*2}

map

//map(遍历，返回list)
val newList = (1..30).map { it * 2 + 3 }
newList.forEach(::println)

flatMap

//flatMap(将多重集合平铺，返回list)
val newList2 = list1.flatMap { it }
newList2.forEach(::println)

reduce

//reduce(遍历并对每一项进行操作，并将值赋给acc进行累计，函数返回值为acc)
val newList3 = list2.reduce { acc, i -> i+acc }
println(newList3)

fold

//fold(有初始值的reduce，还可以进行字符串操作等)
println(list2.fold(5){acc, i -> i+acc })
println(list2.fold(StringBuffer()){acc, i -> acc.append("$i,") })

filter和takeWhile

//filter(lambda表达式返回为false时过滤)
println(list2.filter { it%2==1 })

//takeWhile(lambda表达式返回false时结束)
println(list2.takeWhile { it%2==0 })

let、apply、run

//let(默认当前对象为it，返回值为最后一行)
println(list2.let {
    it.toString()
    it[1]
})

//apply(在函数内可以直接调用该对象的方法，返回该对象)
println(list2.apply{
    toString()
    get(1)
})

//run(在函数内可以直接调用该对象的方法，返回最后一行)
println(list2.run {
    toString()
    get(1)
})

可以看到这三个函数差距不大，他们最大的用处就是和 ?. 一起进行非空判断后的操作，这样代码写起来很简洁

use

//use(将自动把对象进行close，try，catch等操作)
BufferedReader(FileReader("hello.txt")).use {
    var line : String?
    while(true)
    {
        line = it.readLine() ?: break
        println(line)
    }
}
//简化(readText()直接读取文件)
println(BufferedReader(FileReader("hello.txt")).use { it.readText() })

总结

这些并不是kotlin的全部，我只是将我觉得不错的点拿出来说一说，还有更多的秘密等着你去挖掘呢

当然，kotlin现在作为一门新兴语言，还有很多缺点和不成熟的地方，不过每一门新语言刚出来都是这样，最后还是靠着大家的力量和智慧把他们都一一解决，当年java刚出来那么多人不看好，可最后事实却证明了一切

总的来说，kotlin就是集合了很多语言的优点为一体的一门语言，说的难听一点就是东抄一点西抄一点，然后组合起来。但是这又有什么呢，对于一门语言来说，集百家之长是很正常的事，只要好用就行了嘛

———————————————————————————————

我看见网上关于kotlin和java很多人在对喷，我也想说几句。

kotlin和java的关系就与object c和swift的关系，就像是一个升级版和简化版，但是这么多年了，大家看见了oc没人用了么，更何况java比oc的应用场合多了去了，所以java会被淘汰我是不相信的，不过kotlin也确实是一个趋势，以后使用kotlin肯定是有优势的

大家都是从java一路走来的，对java有感情很正常，但我想这不是拒绝kotlin的理由吧，作为一个搞IT行业的，始终向前看应该是最基本的吧，更何况现在谷歌将kotlin作为一级语言，spring5也对kotlin进行了大量支持，既然大家都很看好他，我们又有什么理由拒绝呢？

至于在喷kotlin是个糖盒的我就更不明白了，有糖吃不好么？作为一门面向对象的语言，用语言层次给我们支持不好么，难道大家都要去用汇编写程序么？

我觉得在这个快节奏的时代，能够提高生产力的语言更是值得推广，如果我们始终抱着守旧的思想，那恐怕在这个有着前所未有的发展速度的时代，我们很快就会被淘汰