一、位操作：

shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与  &
or(bits) – 或   ||
xor(bits) – 异或
inv() – 反向

    val a = 5
    val b = a shl 2 //左移2位，5*2*2=20
    println(b)  //20

二、位运算符 :

三、Kotlin的位运算符只能对Int和Long两种数据类型起作用。

四、位操作和位运算实例

通过位运算来保证头尾不超过数组范围，通过位操作来扩容（数组长度保持为2的整数倍，方便进行位运算）

//如ArrayDeque通过位与运算(等价于java中的'&')，保证头尾不超过数组边界
class SimpleIntArrayDeque {
    private var elements: Array<Int?> = arrayOfNulls(16) //扩容数组
    private var head: Int = 0 //头
    private var tail: Int = elements.size //尾，tail-1是当前最后一位数据
    fun addFirst(value: Int) {
        if (value == null)
            throw NullPointerException()
        //当head-1为-1时，实际上是11111111&00111111，结果是00111111，也就是物理数组的尾部15；
        head = (head - 1) and (elements.size - 1)
        elements[head] = value
        if (head == tail)
            doubleCapacity()
    fun addLast(value: Int) {
        if (value == null)
            throw NullPointerException()
        elements[tail] = value
        //当tail+1为16时，实际上是01000000&00111111，结果是00000000，也就是物理数组的头部0；
        tail = (tail + 1) and (elements.size - 1)
        if (tail == head)
            doubleCapacity()
    fun pollFirst(): Int? {
        val h = head
        val result = elements[h]
        if (result != null) {
            elements[h] = null
            head = (h + 1) and (elements.size - 1)
        return result
    fun pollLast(): Int? {
        val t = (tail - 1) and (elements.size - 1)
        val result = elements[t]
        if (result != null) {
            elements[t] = null
            tail = t
        return result
    //扩容：插入数据前，判断插入后将头尾相等（即插入后数组将填满），则立即扩容
    private fun doubleCapacity() {
        val p = head
        val n = elements.size
        val r = n - p
        var newCapacity = n shl 1  //扩容2倍
        if (newCapacity < 0)
            throw IllegalArgumentException("Sorry, deque too big")
        var newElements: Array<Int?> = arrayOfNulls(newCapacity)
        //从头部开始拷贝,拷贝头部以后的所有内容，并把头部位置重置为0
        System.arraycopy(elements, p, newElements, 0, r)
         * 从0开始拷贝，拷贝头部之前的内容，并把拷贝内容接上刚才拷贝的位置，
         * 使得原来的数组放到新数组的前半部分
        System.arraycopy(elements, 0, newElements, r, p)
        //释放旧的数组内存
        Arrays.fill(elements, null)
        elements = newElements
        head = 0
        tail = n
    fun size(): Int {  //插入前判断，若插入后占满则立即扩容，因此size不会大于数组长度减一
        return (tail - head) and (elements.size - 1)
    fun isEmpty(): Boolean {
        return head == tail
    fun peekFirst(): Int? {
        return elements[head]
    fun peekLast(): Int? {
        return elements[(tail -1) and (elements.size - 1)]
fun getBit(number:Int,bitPosition:Int): Int {
//    return (number shr bitPosition).and(1);
    return number shr bitPosition and 1;
fun setBi(number:Int,bitPosition:Int): Int {
                                    运算符计算机程序中最小的程序单位成为表达式，每个表达式都可以由两部分组成，即操作数和运算符。操作数可以是变量、常量、类、数组、方法等，甚至是其他表达式。而运算符则用于支出表达式中单个或者多个操作数参与运算的规则，表达式通过运算之后产生的值依赖于表达式中包含的运算符的优先级和结核性。Kotlin语言包含了Java语言中的所有运算符的特性，并结合C语言的优点，增加自定义运算符的逻辑。这些运算符之中，主要
                                    虽然Kotlin也提供了与Java功能完全相同的位运算符，但是这些位运算符都不是以特殊字符给出的，而是以infix函数的形式给出的。因此，程序只能用函数名来执行这些位运算符。
一、位运算符
Kotlin支持的位运算符同样有如下7个。
private var name: String? = null
private var member: Int= 1000
private val lamube:(a:Int,b:Int)->Int={x,y ->x+y}
private var b: Double= 1.0001
private var c: Float= 1.000f
pri...
Kotlin是一门静态语言，支持多种平台，包括移动端、服务端以及浏览器端，此外，Kotlin还是一门融合了面向对象与函数式编程的语言，支持泛型、安全的空判断，并且Kotlin与Java可以做到完全的交互。
Kotlin特点
代码量少且代码末尾没有分号。
	被调用的方法需放到上边。
	Kotlin是空安全的：在编译时期就处理了各种null的情况，避免了执行时异常。
	它可扩展函数：我们也...
                                    Kotlin是一种在Java虚拟机上运行的静态类型编程语言，被称为之为Android世界的Swift，Kotlin可以编译成Java字节码，也可以编译成JavaScript，方便在没有JVM的设备上运行。在Google I/O 2017中，Google 宣布 Kotlin 成为 Android 官方开发语言，足见Kotlin将来会成为android开发的主流语言。
                                    如果我们定义了个  的操作符重载函数, 那么就可以在该类的实例上使用  运算符, 这就是 规定了很多这种规定, 但这些规定程序员都可以不需要知道, 只要依靠  的智能提示就行了定义一个成员的  操作符重载函数
可以看出使用的是修饰符  定义一个操作符重载函数根据约定概念对应了运算符的 对应的可重载的函数还有:不会导致  的优先级低于 
操作符左右两边的类型可以不一样
需要注意: 操作符重载函数的左右两边顺序不可以调换, 上面定义的函数  类型为左,  类型为右, 所以  是不可以的, 如果需要则
由于数据在计算机中的表示，最终以二进制的形式存在，所以有时候使用二进制，可以更直观地解决问题。
首先，十进制才是我们比较熟悉的，在java当中，声明int类型变量时 比如当我们声明
int a = 12;
这个时候a表示十进制的12，
如果我们要声明八进制，只要在前面加个0
int a = 012;
这个时候a表示十进制的10，
而如果我们要声明十六进制，只要在前面加个0x
int a = 0x12;
这个时候a表示十进制的18
二 JAVA
与十进制的加减乘除不同，jav