1.双等于与三等于

fun main(args: Array<String>) {
    val string1 : String = "Hello"
    val string2 : String = String(charArrayOf('H','e','l','l','o'))
    println(string1 == string2)
    println(string1 === string2)
}

上面这段代码的执行结果：

true
false

Process finished with exit code 0

这其实很好理解，双等于相当于java中的equal，如果对比的类实现了equal这个方法，比如String类，实现的equal方法是对比内容，所以例子中为true。如果是其他自定义类呢？因为kotlin中的类都是继承Any这个类，这个类中定义了equal这个方法，如果要实现自己的对比规则就需要重写这个方法。三等于对比的是对象的内存地址，很明显string1和string2的内存地址不是同一个。

class A(var name:String){
    override fun equals(other: Any?): Boolean {
        if(other is A)
            return other.name == this.name;
        return false
    }
}

val a1 : A = A("a")
val a2 : A = A("a")
println(a1 == a2)
println(a1 === a2)


class B()

val b1  :B = B()
val b2  :B = B()
println(b1 == b2)
println(b1 === b2)

执行结果：

true
false
false
false

上面的代码对比就能发现，感觉双等于就是equal的操作符重载，那到底是不是呢？那么我们去看下Any的源码！

public open class Any {
    /**
     * Indicates whether some other object is "equal to" this one. Implementations must fulfil the following
     * requirements:
     *
     * * Reflexive: for any non-null reference value x, x.equals(x) should return true.
     * * Symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
     * * Transitive:  for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true
     * * Consistent:  for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
     *
     * Note that the `==` operator in Kotlin code is translated into a call to [equals] when objects on both sides of the
     * operator are not null.
     */
    public open operator fun equals(other: Any?): Boolean

    /**
     * Returns a hash code value for the object.  The general contract of hashCode is:
     *
     * * Whenever it is invoked on the same object more than once, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified.
     * * If two objects are equal according to the equals() method, then calling the hashCode method on each of the two objects must produce the same integer result.
     */
    public open fun hashCode(): Int

    /**
     * Returns a string representation of the object.
     */
    public open fun toString(): String
}

果然equal方法被operator关键字修饰了。ok，双等于和三等于是怎么会事弄清楚了。

2.字符串相关

val a :Int = 1
val b :Int = 2
val s :String = a.toString() + " + "+ b +" = "+(a+b)
val ss :String = "$a + $b = ${a+b}"
println(s)
println(ss)

上面代码两个输出是一样的，都是“1 + 2 =3”，只不过一种用的是字符串拼接，另一种用的是字符串模版。字符串拼接在java中十分常见，也很方便，但是会产生临时字符串，如果量大了以后会造成内存抖动，对内存十分不友好。而字符串模版的方式就不会有这个影响。

val rawString : String = """ ///////i'am kotlin \n\t\r """

三引号用开定义原始字符串，一切转意字符会被原样输出。
因为字符串的知识点实在太多，有些跟java一样，所以这里就暂时不做展开了。

3.简单的类和对象

fun main(args : Array<String>){
    val man:Man = Man("11","22",33)
    val woman:Woman = Woman(44,"55",66)
}

open class Person constructor(var name:String ,var age:Int){
    init {
        println("Person is init")
    }
}

class Man constructor(var a:String, name:String, age: Int):Person(name,age)

class Woman (var b:Int,name: String,age: Int):Person(name, age)

上面的代码中可以看出了构造器的标准写法和简写法，以及init代码块的回调。这块知识以后还有详细介绍。

4.智能判空

val string1:String = "aaa"
val string2:String? = "bbb"
println(string1.length)
println(string2?.length)
println(string2!!.length)

在kotlin中String和String?可以看作两个类型，String是不可空的字符串类，String?是可为空的字符串类。其实String和String?组合在一起才是一个真正的类。当我们使用这些变量时，如果是不为空的变量正常使用，如果是可为空的变量要加个问号，要是不巧真的是空，那也不会抛出空指针。智能判空其实就是为了让程序有更好的体验，不至于一不小心就崩溃。还有一种双叹号的写法，就是使用者责任制，放弃编译器的空保护，使用时确认变量不会为空。

5.类型转换

val man:Person= Man("11","22",33)
if (man is Man)
        man.a
if (man is Woman)
        man.b

使用3中的例子，用is这个关键字来判断是否属于目标类，跟java中的instanceof一样，但是kotlin比java多做了一步，当if为true，对象实例将被自动转化为目标的类,不需要手动强转的方式，所以man对象并没有b属性，但是编译一样能通过。

val m : Man = man as Man
val w : Woman? = man as? Woman

在java中类型的强制转换无处不在，kotlin当然也支持强转，使用as这个关键字，但是这种用法和java中强转一样都会失败抛出类型转换异常的问题。第二种用法就能很好的解决这个问题，man明显不是Woman类型，那么w这个变量就会是空，并不会抛出异常。

6.区间

val range1 : IntRange = 0..10
val range2 : IntRange = 0 until 10
println(10 in range1)
println(10 in range2)
for (i in range1)
    println(i)
range2.forEach { println(it) }

区间的概念在java中并没有，range1是闭区间[0,10],而range2是半闭区间[0,10),in关键字可以作为contains的操作符重载，用来判断是否包含该元素。区间遍历的方式跟数组集合大同小异，那么他跟数组集合的区别主要是区间内容时连续的。

7.数组

val ia : IntArray = intArrayOf(0,2,4,6,8)
val ca : CharArray = charArrayOf('k','o','t','l','i','n')
val sa : Array<String> = arrayOf("Hello","world")
println(ia.size)
println(ca[0])
sa[1] = "kotlin"
sa.forEach { println(it) }

在kotlin中，基本数据类型的数组系统已经帮我们定义一些类，这个些优化了一些自动拆装箱的工作。其他用法很常规，包括去长度，索引取值赋值，遍历。