Operator 操作符

※ 操作符Operator

一般情况下，不用去刻意记住操作符的优先级，当不能确定操作符的执行顺序时，可以使用圆括号来显示指定运算顺序。
1）赋值操作符：

 =   :   int x=0,i=1,j=1;
 *=  :   a*=b 等价于 a=a*b
 /=  :   a/=b 等价于 a=a/b;
 %=  :   a%=b 等价于 a=a%b;
 +=
 -=
 ...

2）比较操作符

 >   :   大于
 >=  :   大于等于
 <   :   小于
 <=  :   小于等于

以上操作符只适用于整数类型和浮点数类型；

int a=1,b=1;
     double d=1.0;
     boolean result1 = a>b;         //result1的值为false;
     boolean result2 = a<b;         //result2的值为false;
     boolean result3 = a>=d;        //result3的值为true;
     boolean result4 = a<=b;        //result4的值为true;              

instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。该操作符左边是一个引用类型，右边是一个类
名或接口名。形式如下：

             obj instanceof ClassName
             或者
             obj instanceof InterfaceName

3）相等操作符

==  :   是否等于
!=  :   是否不等于

既可以是基本类型，也可以是引用类型：

 a. 基本类型：

    int a=1,b=1; 
    float c=1.0f;
    double d=1.0;

    System.out.println(a==b);        //输出true;
    System.out.println(a==c);        //输出true;
    System.out.println(a==d);        //输出true;
    System.out.println(c==d);        //输出true;

 b. 引用类型：

    这两个引用变量必须都引用同一个对象，结果才为true.

    Student s1 = new Student("zs",25,100);
    Student s2 = new Student("zs",25,100);
    Student s3 = s1;

    System.out.println(s1 == s2);    //输出false;
    System.out.println(s1 == s3);    //输出true;
    System.out.println(s2 == s3);    //输出false;

4）数学运算操作符
+ : 数据类型值相加或字符串连接;

 a. 数据类型值相加；

    int    a=1+2;                      //a值为3;
    double b=1+2;                      //b值为3.0;   
    double b=1+2.0;                    //c值为3.0;

 b. 字符串连接；

    System.out.println(1+2+"a");          //输出3a
    System.out.println(1+2.0+"a");        //输出3.0a
    System.out.println(1+2.0+"a"+true);   //输出3.0atrue
    System.out.println("a"+1+2);          //输出a12
    System.out.println(1+"a"+2);          //输出1a2

/ : 整除, 如操作数均为整数，运算结果为商的整数部分

 int a1=12/5;                              //a1变量的取值为2
 int a2=13/5;                              //a2变量的取值为2
 int a3=-12/5;                             //a3变量的取值为-2
 int a4=-13/5;                             //a4变量的取值为-2
 int a5=1/5;                               //a5变量的取值为0
 double a6=12/5;                           //a6变量的取值为2.0
 double a7=12/-5.0;                        //a7变量的取值为-2.4   

% : 取模操作符, 如操作数均为整数，运算结果为商的整数部分

 int a1=1%5;                               //a1变量的取值为1
 int a2=13%5;                              //a2变量的取值为3
 double a3=1%5;                            //a3变量的取值为1.0
 double a4=12%5.1;                         //a4变量的取值为1.8000000000000007

5）移位操作符
“>>” : 算术右移位运算，也称做带符号右移位运算。(除以2^n，n代表移动的位数)

 int a1 = 12 >> 1;                          //a1变量的取值为6;
 0000 1100    12
 -----------
  000 0110    >>1
 -----------
 0000 0110    补位 因为是正数所以补0  结果为6

 int a2 = 128 >> 2;                         //a2变量的取值为32;
 int a3 = 129 >> 2;                         //a3变量的取值为32;                 
 int a5 = -12 >> 1;                         //a4变量的取值为-6; 
0000 1100    12
---------
1111 0011    取反
---------
1111 0100    +1  这个就是-12的二进制形式
----------
 111 1010    >>1

1111 1010    补位 因为是负数所以补1  这个负数就是最终结果
---------
1111 1001    -1
---------
0000 0110    取反 结果为6 所以上面的最终结果是 -6

 int a6 = -12 >> 2;                         //a4变量的取值为-3; 

0000 1100     12
---------
1111 0011     取反
---------
1111 0100     +1  这个就是-12的二进制形式
---------- 
  11 1101     >>2

1111 1101     补位 因为是负数所以补1  这个负数就是最终结果
---------
1111 1100     -1
---------
0000 0011     取反 结果为3 所以上面的最终结果是 -3

注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一位符号位，由于12是正整数，因此增加的符号位为0;
b. 对-12右移俩位的过程为：舍弃二进制数的最后俩位，在二进制数的开头增加俩位符号位，由于-12是负整数,因此增加的符号位为1;

“>>>” : 逻辑右移位运算，也称为不带符号右移位运算。

 int a1 = 12 >>> 1;                          //a1变量的取值为6;
 int a2 = -12 >>> 2;                         //a2变量的取值为1073741821;                   

注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一个0;
b. 对-12右移二位的过程为：舍弃二进制数的最后二位，在二进制数的开头增加二个0;

“<<” : 左移位运算，也称为不带符号左移位运算。

 int a1 = 12 << 1;                          //a1变量的取值为24;
 int a2 = -12 << 2;                         //a2变量的取值为-48;                   
 int a3 = 128 << 2;                         //a3变量的取值为512;
 int a4 = 129 << 2;                         //a4变量的取值为516;    

注：a. 对12左移一位的过程为：舍弃二进制数的开头一位，在二进制数的尾部增加一个0;
b. 对-12左移二位的过程为：舍弃二进制数的开头二位，在二进制数的尾部增加二个0;

6）位运算操作符

 &   :   与运算，对两个操作元的每个二进制位进行与运算，运算规则为：1&1->1, 1&0->0, 0&1->0, 0&0->0;   
 |   :   或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1|1->1, 1|0->1, 0|1->1, 0|0->0;
 ^   :   异或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1^1->0, 0^0->0，1^0->1, 0^1->1,; 相同为0 不同位1  运算特点: a^0=a; a^a=0;
 ~   :   取反运算, ~1->0, ~0->1;

两值互换
a=a^b;
b=a^b;
a=a^b;

7）逻辑操作符

 短路操作符，如果能根据操作左边的布尔表达式就能推算出整个表达式的布尔值，将不执行操作符右边
 的布尔表达式；

 &&  :   左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式。

exc:
  3>4&&4>2 ==>false(先执行了左边，判断)
  3>4&4>2  ==>false(左右都执行,再判断)

 ||  :   左边的布尔表达式的值为true, 整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。  

exc:同&&

8）条件操作符
三目运算
布尔表达式 ? 表达式1 : 表达式2
前后类型必须一样，宇布尔表达式相同类型
int无法直接转换成String，只能通过在后面+空字符串转换为String
String型数字转换为int：
String nn=”33”;
int a=Integer.parseInt(nn);
转换为Long类型
Long b=Long.parseLong(nn);

如果布尔表达式的值为true, 就返回表达式1的值， 否则返回表达式2的值。

int score = 61;
String result = score>=60?”及格”:”不及格”;

※ 在三参表达式中表达式类型转换规则：
1）对于整数类型和浮点数型：小类型向大类型转
2）char和int类型转成char
3）char和其他类型都转换成其他类型