Java和kotlin的与，或，异或，移位运算_kotlin或运算

一基础

由于数据在计算机中的表示，最终以二进制的形式存在，所以有时候使用二进制，可以更直观地解决问题。
首先，十进制才是我们比较熟悉的，在java当中，声明int类型变量时 比如当我们声明

int a = 12;
1

这个时候a表示十进制的12，

如果我们要声明八进制，只要在前面加个0

int a = 012;
1

这个时候a表示十进制的10，
而如果我们要声明十六进制，只要在前面加个0x

int a = 0x12;
1

这个时候a表示十进制的18

二 JAVA

1按位与&

与十进制的加减乘除不同，java的与或非运算，都是看成是在二进制上直接进行运算
接着来看与操作符

  @Test
    public void testAnd(){
        int a = 2;     //0000 0010
        int b = 3;     //0000 0011
        int c = a & b; //0000 0010
        System.out.println("testAnd->a:" + a + ",b:" + b + ",c:" + c);
    }
1
2
3
4
5
6
7

运行后打印的结果是

testAnd0->a:2,b:3,c:2
1

java与操作:会直接在两个操作数中的相同位数中，进行对比运算，都为1，结果才为1，否则结果为0

(2)按位或 |

为了更方便观看与理解，接下来的例子我用十六进制举例
按位或只要有一个为1，结果就为1。

@Test
    public void testOr(){
        int a = 0x00000010;
        int b = 0x00000011;
        int c = a | b; // c = 0x00000011
        System.out.println("testAnd1->a:" + a + ",b:" + b + ",c:" + c);
    }
1
2
3
4
5
6
7

运算后打印的结果是

testOr->a:16,b:17,c:17
1

（3）按位异或 ^

两个相应位为“异”（值不同），则该位结果为1，否则为0

 @Test
    public void testXor(){
        int a = 0x00000010;
        int b = 0x00000011;
        int c = a ^ b; // c = 0x00000001
        System.out.println("testXor->a:" + a + ",b:" + b + ",c:" + c);
    }
1
2
3
4
5
6
7

运算后打印的结果是

testXor->a:16,b:17,c:1
1

（4）左移 <<

@Test
    public void testLeft(){
        int a0 = 0x00000001;
        int b0 = a0 << 1;  
        System.out.println("testLeft->a0:" + a0 + ",b0:" + b0);

        int a1 = 0x00000001;
        int b1 = a0 << 2;  
        System.out.println("testLeft->a1:" + a1+ ",b1:" + b1);

        int a2 = 0x00110111;
        int b2 = a2 << 1;  //b2 = 0x01101110
        int c = 0x01101110;
        System.out.println("testLeft->a2:" + a2 + ",b2:" + b2 + ",c:" + c);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运算后打印的结果是

testLeft->a0:1,b0:2
testLeft->a1:1,b1:4
testLeft->a2:1114385,b2:2228770,c:17830160
1
2
3

简单理解就是位移几位就往左移动几位，不过可以看到b2 = 0x01101110是错误的，首先这里是十六进制，移位运算时，需要先进行二进制转换,如下才是正确的

 @Test
    public void testLeft2(){
        int a2 = 0x00110111; // a2 的二进制为 0001 0001 0000 0001 0001 0001
        int b2 = a2 << 1;    // b2 的二进制为 0010 0010 0000 0010 0010 0010
        System.out.println("testLeft2->a2:" + a2 + ",b2:" + b2);
    }
1
2
3
4
5
6

运算后的打印结果是

testLeft2->a2:1114385,b2:2228770
1

关于左移和右移运算，详细可以看这篇文章
Java中的移位运算符

三 Kotlin

(1)按位与 and

与JAAVA不同，Kotlin的与或非运算需要使用中缀函数

@Test
    fun testAnd(){
        val a = 2
        val b = 3
        val c = a and b
        println("testAnd->a:${a},b:${b},c:${c}")
    }
1
2
3
4
5
6
7

运算结果:

testAnd->a:2,b:3,c:2
1

他们的规则是一样的

/** Performs a bitwise AND operation between the two values. */
    public infix fun and(other: Int): Int
1
2

(2)按位或 or

@Test
    fun testOr(){
        val a = 0x0010
        val b = 0x0011
        val c = a or b
        println("testOr->a:${a},b:${b},c:${c}")
    }
1
2
3
4
5
6
7

运算结果

testOr->a:16,b:17,c:17
1

(3)按位异或 xor

@Test
    fun testXor(){
        val a = 0x0010
        val b = 0x0011
        val c = a xor b
        println("testXor->a:${a},b:${b},c:${c}")
    }
1
2
3
4
5
6
7

运算结果

testXor->a:16,b:17,c:1
1

（4）左移位 shl

@Test
    fun testLeft(){
        val a = 0x00110111
        val b = a shl 1
        println("testLeft->a:${a},b:${b}")
    }
1
2
3
4
5
6

运算结果

testLeft->a:1114385,b:2228770
1

shl方法

/** Shifts this value left by the [bitCount] number of bits. */
    public infix fun shl(bitCount: Int): Int
1
2

(5)右移位 shr

@Test
    fun testRight(){
        val a = 0x00110111
        val b = a shr 1
        println("testRight->a:${a},b:${b}")
    }
1
2
3
4
5
6

运算结果

testRight->a:1114385,b:557192
1