【Java概念】运算符（3）

一、运算符

【各种运算符的特性】：

算术运算符：+（正）、-（负）、++、–、+（加）、-（减）、*、/（除）、%（取余）
关系运算符：==、!=、>、<、>=、<=
逻辑运算符：&（与）、|（或）、!（非）、∧（异或）、&&（条件与）、||（条件或）
位运算符：~（非）、&（与）、|（或）、^（异或）、<<（左移位）、>>（右移位）、>>>（无符号右移位）
赋值运算符：= 、+=等
条件运算符：表达式1 ? 表达式2 : 表达式3
括号运算符：()、[]
字符串连接运算符：+
点运算符：.
对象运算符：instanceof
new运算符：

【运算符的运算级别】：

1> .()
2> ++ –
3> new
4> *、/、%
5> + -
6> >>、<<、>>>
7> > < >= <=
8> == !=
9> &
10> ^
11> !
12> &&
13> ||
14> ?:
15> = += -= *= /= %= ^=
16> &= <<= >>=

/**
 * 【运算符的运算级别】：
 */
@Test
public void  t7(){
    /*
     * 此句的执行过程：根据运算符级别，==级别 高于?:级别，因此先执行true==true?false:true ==>false
     */
    boolean boo = true?false:true == true?false:true;
    System.out.println(boo);
}

算术运算符:

/**
* 算术运算符：+（正）、-（负）、++、--、+（加）、-（减）、*、/（除）、%（取余） 
 */
@Test
public void t1(){
    int i = 1;
    System.out.println(("i : " + i));
    System.out.println(("++i : " + ++i)); // Pre-increment
    System.out.println(("i++ : " + i++)); // Post-increment
    System.out.println(("i : " + i));
    System.out.println(("--i : " + --i)); // Pre-decrement
    System.out.println(("i-- : " + i--)); // Post-decrement
    System.out.println(("i : " + i));
    i = i+++i;
    System.out.println(i);

}

位运算符：

/**
* 位运算符：~（非）、&（与）、|（或）、^（异或）、<<（左移位）、>>（右移位）、>>>（无符号右移位）
 */
@Test
public void t2(){
    /* 
     * ~（非）运算符：
     * ~运算符执行原理：9的带符号二进制字节码为：[0 1001] ，每位取反得到：[1 0110] ，
     * 带符号为[10110]对应十进制为：11001 --> 11001+1 -->11010 --> -10 。
     */
    int a = ~9;  
    System.out.println("~9 = "+a);//-10

    /*
     * &（与）运算符：
     * &运算符执行原理：若两个输入位都是1，则按位AND 运算符（&）在输出位里生成一个1；否则生成0。
     * -8在java内存中的存储的反码为：111000，-22在java内存中的存储的反码为：101010，
     * 111000 & 101010 = 111000 =-24
     */
    int i = -8;
    int j = -22;
    System.out.println(Integer.toBinaryString(i));
    System.out.println(Integer.toBinaryString(j));
    a = i & j; 
    System.out.println(i+" & "+ j +" = "+a);//-24

    /*
     * |（或）运算符：
     * |（或）运算符执行原理：若两个输入位里至少有一个是1，则按位OR 运算符（|）在输出位里生成一个1；
     * 只有在两个输入位都是0 的情况下，它才会生成一个0。
     * -8在java内存中的存储的反码为：111000，-22在java内存中的存储的反码为：101010，
     * 111000 | 101010 =100110 = -6 
     */
    a = i | j ;
    System.out.println(i+" | "+j+" = "+a);//-6 

    /*
     * ^（异或）运算符：
     * ^（异或）运算符执行原理：若两个输入位的某一个是1，但不全都是1，那么按位XOR（^，异或）在输出位里生成一个1，否则为0。
     * -8在java内存中的存储的反码为：111000，-22在java内存中的存储的反码为：101010，
     * 111000 ^ 101010 = 010010 = 18
     */
    a = i ^ j;
    System.out.println(i+" ^ "+j+" = "+a);//18

    /*
     * <<（左移位）运算符：
     * <<（左移位）运算符执行原理：能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。
     * 1的二进制字节码为 [0001] ，整体左移两位并且底位补零，变为：00[0100]，因此0100对应十进制为：4
     */
    a = 1<<2;
    System.out.println("1<<2 = "+a);//4
    a = -2<<2;
    System.out.println("-2<<2 = "+a);//-2 = 1010 = 1101+1 = 1110 ->11[1000] =-8

    /*
     * >>（右移位）运算符：
     * >>（右移位）运算符执行原理：符号位不变 ，最右边的位丢弃，左边补符号位。
     * 1的二进制字节码为 [0001] ，整体右移两位并且高位补零，变为：[0000]01，因此0000对应十进制为：0
     */
    a = 1>>2;
    System.out.println("1>>2 = "+a);//0
    /**左移1位，相当于乘以2  ；右移1位相当于除以2*/

    /*
     * >>>（无符号右移位）运算符：
     * >>>（无符号右移位）运算符执行原理：它使用了“零扩展”：无论正负，都在高位插入0。
     * 4=0100 ->[0000]100 = 0
     */
    a = 4>>>3;
    System.out.println("4>>>3 = "+a);//0

}

赋值运算符：

/**
* 赋值运算符：= 、+=、-=、*=、/= 、%=、<<=、>>=、>>>=等等
 */
@Test
public void t3(){
    byte a = 23;
    a = -12;
    System.out.println("a = -12 :"+a);
    a +=1;
    System.out.println("a +=1 :"+a);
    a -=2;
    System.out.println("a -=2 :"+a);
    a *=2;
    System.out.println("a *=2 :"+a);
    a /=2;
    System.out.println("a /=2 :"+a);
    a %=2;
    System.out.println("a %=2 :"+a);
    a +=200;//精度损失
    System.out.println("a +=200 :"+a);//-57
    a <<=2;
    System.out.println("a <<=2 :"+a);

    //面试题
    int c = 10;
    c += c -= c *= c; //赋值号左侧的c一直都是初始值10，右侧是相应表达式的结果
    System.out.println("c="+c);
}

关系运算符：

/**
 * 关系运算符：==、!=、>、<、>=、<= 
 */
@Test
public void t4(){
    /*
     * 关于关系运算符的说明：
     * 关系运算符生成的是一个“布尔”（Boolean）结果。它们评价的是运算对象值之间的关系。
     * 若关系是真实的，关系表达式会生成true（真）；若关系不真实，则生成false（假）。
     */
    /*
     * ==、!= 运算符：是判断运算对象的值是否相等。
     */
    Integer integer1 = new Integer(29);
    Integer integer2 = new Integer(29);
    System.out.println(integer1==integer2);//false---两个运算对象所对应的引用地址是不同的(栈地址不同)
    System.out.println(integer1!=integer2);//true
    System.out.println(integer1.equals(integer2));//true ---堆内存中的内容是相同的
}

逻辑运算符：

/**
 * 逻辑运算符：&（与）、|（或）、!（非）、∧（异或）、&&（条件与）、||（条件或） 
 */
@Test
public void t5(){
    boolean boo= true ^ false;
    System.out.println(boo);
    boo = false & false;
    System.out.println(boo);
    boo = true & true;
    System.out.println(boo);
    boo = !true;
    System.out.println(boo);
    boo = true && true;
    System.out.println(boo);
    /*
     * &&（条件与）、||（条件或） 具有短路功能
     */
    //逻辑运算中的短路: 
    // 1) 与运算时，如果前面一个表达式的结果为false，则后一个表达式不会运行
    // 2) 或运算时，如果前面一个表达式的结果为true，则后一个表达式也不会运行
}

对象运算符：

/**
* 对象运算符：instanceof
 */
@Test
public void t6(){
    /*
     * 对象运算符：instanceof 
     * 对象运算符：instanceof 执行原理：判断某个对象是否属于某个类类型
     */
    String str = "hello";
    boolean boo = str instanceof Object;
    System.out.println(boo);

}