Java基础知识串讲之运算符

/*    
   注意事项：
   A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
   B:/获取的是除法操作的商，%获取的是除法操作的余数
*/

public class OperatorDemo {
    public static void main(String[] args) {
        //定义变量
        int x = 3;  //把3赋值给int类型的变量x
        int y = 4;
        System.out.println(x+y);//7
        System.out.println(x-y);//-1
        System.out.println(x*y);//12
        System.out.println(x/y);//0 //整数相除只能得到整数

        //我就想得到小数，该怎么办呢?
        //只需要把操作的数据中任意的一个数据变为浮点数
        System.out.println(x*1.0/y);//0.75

        //%的应用
        System.out.println(x%y);//3   //得到的是余数
    }
}

/*
   ++,--运算符的使用：
      单独使用：
          放在操作数的前面和后面效果一样。
      参与运算使用：
          放在操作数的前面，先自增或者自减，然后再参与运算。
          放在操作数的后面，先参与运算，再自增或者自减。

      作用：就是对变量进行自增1或者自减1。
 */
public class OperatorDemo2 {
    public static void main(String[] args) {
        //定义两个变量
        int x = 3;
        int y = 4;
        System.out.println("x:"+x+",y:"+y);//x:3,y:4

        //单独使用
        ++x;
        --y;
        //x++;
        //y--;
        System.out.println("x:"+x+",y:"+y);//x:4,y:3

        //常量是不可以这样做的
        //System.out.println(10++);

        System.out.println("-------------------");
        //参与运算使用
        int a = 3;
        int b = 4;

        int c = ++a;
        int d = --b;

        System.out.println("a:"+a); // 4
        System.out.println("b:"+b); // 3
        System.out.println("c:"+c); // 4
        System.out.println("d:"+d); // 3
    }
}

/*
   +的用法：
   A:加法
   B:正号
   C:字符串连接符
*/
public class OperatorDemo3 {
    public static void main(String[] args) {
        //加法
        System.out.println(3+4);//7

        //正号
        System.out.println(+4);//4

        System.out.println('a');
        System.out.println('a'+1); //这里是加法  输出98

        //字符串连接符
        System.out.println("hello"+'a'+1);//helloa1
        System.out.println('a'+1+"hello");//98hello
    }
}

/*
   赋值运算符：
   基本的赋值运算符：=
   把=右边的数据赋值给左边。

   扩展的赋值运算符：+=,-=,*=,/=,%=
   += 把左边和右边做加法，然后赋值给左边。
*/
public class OperatorDemo4 {
    public static void main(String[] args) {
        //定义一个变量
        int x = 10;

        //其他用法
        int a,b; 
        a = b = 10;
        System.out.println(a); //10
        System.out.println(b);//10
        System.out.println("-----------");

        //定义一个变量
        int y = 10;

        y += 20;

        System.out.println(y);//30

    }
}

/*
   面试题：
   short s=1;s = s+1; 

   short s=1;s+=1;
   上面两个代码有没有问题，如果有，那里有问题。

   为什么第二个没有问题呢?
   扩展的赋值运算符其实隐含了一个强制类型转换。

   s += 1;
   不是等价于 s = s + 1;
   而是等价于 s = (s的数据类型)(s + 1);
*/
public class OperatorTest1 {
    public static void main(String[] args) {
        //short s = 1;
        //s = s + 1;//这样写的话编译的时候直接不能通过
        //System.out.println(s);

        short s = 1;
        s += 1; 
        System.out.println(s);//2
    }
}

/*
   特点：
      无论你的操作是简单还是复杂，结果是boolean类型。

    注意事项：
      "=="不能写成"="。
*/
public class OperatorDemo5 {
    public static void main(String[] args) {
        int x = 3;
        int y = 4;
        int z = 3;

        System.out.println(x == y);//false
        System.out.println(x == z);//true
        System.out.println((x+y) == (x+z));//false
        System.out.println("------------");

        System.out.println(x != y);//true
        System.out.println(x > y);//false
        System.out.println(x >= y);//false
        System.out.println(x < y);//true
        System.out.println(x <= y);//true
        System.out.println("------------");

        int a = 10;
        int b = 20;

        boolean flag = (a == b);
        boolean flag = (a = b); //这个是有问题的，不兼容的类型
        System.out.println(flag);

        int c = (a = b); //把b赋值给a，然后把a留下来
        System.out.println(c);//20
    }
}

/*
   逻辑运算符：
   &,|,^,!
   &&,||

   特点：
   逻辑运算符一般用于连接boolean类型的表达式或者值。

   表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
   算术表达式：a + b
   比较表达式：a == b

   结论：
   &逻辑与:有false则false。
   |逻辑或:有true则true。
   ^逻辑异或:相同为false，不同为true。
   举例：情侣关系。男男,男女,女男,女女
   !逻辑非:非false则true，非true则false。
   特点：偶数个不改变本身。

   &&和&的区别? 同理||和|的区别?
   A:最终结果一样。
   B:&&具有短路效果。左边是false，右边不执行。
*/
public class OperatorDemo6 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        //&逻辑与
        System.out.println((a > b) & (a > c)); //false & false = false
        System.out.println((a > b) & (a < c)); //false & true = false
        System.out.println((a < b) & (a > c)); //true & false = false
        System.out.println((a < b) & (a < c)); //true & true = true
        System.out.println("---------------");

        //|逻辑或
        System.out.println((a > b) | (a > c)); //false | false = false
        System.out.println((a > b) | (a < c)); //false | true = true
        System.out.println((a < b) | (a > c)); //true | false = true
        System.out.println((a < b) | (a < c)); //true | true = true
        System.out.println("---------------");

        //^逻辑异或
        System.out.println((a > b) ^ (a > c)); //false ^ false = false
        System.out.println((a > b) ^ (a < c)); //false ^ true = true
        System.out.println((a < b) ^ (a > c)); //true ^ false = true
        System.out.println((a < b) ^ (a < c)); //true ^ true = false
        System.out.println("---------------");

        //!逻辑非
        System.out.println(!(a > b)); //!false = true
        System.out.println(!(a < b)); //!true = false
        System.out.println(!!(a > b)); //!!false = false
        System.out.println(!!!(a > b)); //!!false = true

        //&&双与
        System.out.println((a > b) && (a > c)); //false && false = false
        System.out.println((a > b) && (a < c)); //false && true = false
        System.out.println((a < b) && (a > c)); //true && false = false
        System.out.println((a < b) && (a < c)); //true && true = true
        System.out.println("----------------");

        int x = 3;
        int y = 4;

        boolean b1 = ((++x == 3) && (y++ == 4));
        System.out.println("x:"+x);//x:4
        System.out.println("y:"+y);//y:4
        System.out.println(b1);//false
    }
}

/*
   位运算符：
   &,|,^,~
   <<,>>,>>>

   注意：
   要做位运算，首先要把数据转换为二进制。
*/
public class OperatorDemo7 {
    public static void main(String[] args) {
        //&,|,^,~

        int a = 3;
        int b = 4;

        System.out.println(3 & 4);//0
        System.out.println(3 | 4);//7
        System.out.println(3 ^ 4);//7
        System.out.println(~3);//-4

        //^的特点：一个数据对另一个数据位异或两次，该数本身不变。
        System.out.println(a ^ b ^ b); //3
        System.out.println(a ^ b ^ a); //4
    }
    /*
       分析：因为是位运算，所以我们必须先把数据换算成二进制。 
       二进制数在内存中是以补码的形式存放的

       3的二进制：11
       00000000 00000000 00000000 00000011
       4的二进制：100
       00000000 00000000 00000000 00000100

       &位与运算：有0则0。
       00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
       -----------------------------------
       00000000 00000000 00000000 00000000
       结果是：0

       |位或运算：有1则1。
       00000000 00000000 00000000 00000011
       |00000000 00000000 00000000 00000100
       -----------------------------------
       00000000 00000000 00000000 00000111
       结果是：7

       ^位异或运算：相同则0，不同则1。
       00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
       -----------------------------------
       00000000 00000000 00000000 00000111
       结果是：7

       ~按位取反运算符：0变1，1变0
       00000000 00000000 00000000 00000011
       ~11111111 11111111 11111111 11111100 (此处取除的是补码)

       补码：11111111 11111111 11111111 11111100
       反码：11111111 11111111 11111111 11111011
       原码：10000000 00000000 00000000 00000100
       结果是：-4

       顺便看一下负数的补码和反码
       负数的补码是：符号位不变，其余各位求反，末位加1 
       反码是：符号位为1，其余各位求反，但末位不加1 
*/
}

public class OperatorDemo8 {
    public static void main(String[] args) {
        //<< 把<<左边的数据乘以2的移动次幂
        System.out.println(3 << 2); //3*2^2 = 3*4 = 12;

        //>> 把>>左边的数据除以2的移动次幂
        System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
        System.out.println(24 >>> 2);//6

        System.out.println(-24 >> 2); //-6
        System.out.println(-24 >>> 2);//1073741818
    }
    /*
       计算出3的二进制：11
       00000000 00000000 00000000 00000011
       (00)000000 00000000 00000000 0000001100

       >>的移动：   
       计算出24的二进制：11000
       原码：10000000 00000000 00000000 00011000
       反码：11111111 11111111 11111111 11100111
       补码：11111111 11111111 11111111 11101000

       11111111 11111111 11111111 11101000
       1111111111 11111111 11111111 111010(00) 补码

       补码：1111111111 11111111 11111111 111010
       反码：1111111111 11111111 11111111 111001
       原码：1000000000 00000000 00000000 000110

       结果：-6

       >>>的移动：
       计算出24的二进制：11000
       原码：10000000 00000000 00000000 00011000
       反码：11111111 11111111 11111111 11100111
       补码：11111111 11111111 11111111 11101000

       11111111 11111111 11111111 11101000
       0011111111 11111111 11111111 111010(00)

       结果：
    */
}

/*
   面试题：
       请自己实现两个整数变量的交换，用不同的方式实现
*/
public class OperatorTest2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println("a:"+a+",b:"+b);

        //方式1：使用第三方变量
        /*
           int c = a;
           a = b;
           b = c;
           System.out.println("a:"+a+",b:"+b);
           System.out.println("------------");
        */

        //方式2：用位异或实现
        //左边：a,b,a
        //右边：a ^ b
        /*
           a = a ^ b;
           b = a ^ b; //a ^ b ^ b = a
           a = a ^ b; //a ^ b ^ a = b
           System.out.println("a:"+a+",b:"+b);
        */

        //方式3：用变量相加的做法
        /*
           a = a + b; //a=30
           b = a - b; //b=10
           a = a - b; //a=20
           System.out.println("a:"+a+",b:"+b);
        */

        //方式4：
        b = (a+b) - (a=b); //b=30-20=10,a=20
        System.out.println("a:"+a+",b:"+b);
    }
}

public class OperatorDemo9 {
    public static void main(String[] args) {
        int x = 100;
        int y = 200;

        int z = ((x > y)? x: y);

        //报错
        //int z = ((x = y)? x : y);//比较表达式:结果是一个boolean类型。

        System.out.println("z:"+z);//z:200
    }
}