Java基础知识串讲之运算符

今天给大家分享Java运算符知识点的总结。

算术运算符

+,-,*,/,%,++,--

1、+的用法

a:加法。

b:正号。

c:字符串连接符。

2、/和%的区别

数据做除法操作的时候,/取得是商,%取得是余数。

3、++和--的用法

a:他们的作用是自增或者自减。

b:使用

单独使用

放在操作数据的前面和后面效果一样。

a++或者++a效果一样。

参与操作使用

放在操作数的前面:先自增或者自减,再参与操作。

int a = 10;

int b = ++a;

放在操作数的后面:先参与操作,再自增或者自减。

int a = 10;

int b = a++;

/*    
   注意事项:
   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
    }
}

赋值运算符

1、=,+=,-=,*=,/=,%=等。

2、=叫做赋值运算符,也是最基本的赋值运算符

int x = 10; 把10赋值给int类型的变量x。

3、扩展的赋值运算符的特点

隐含了自动强制转换。

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

   扩展的赋值运算符:+=,-=,*=,/=,%=
   += 把左边和右边做加法,然后赋值给左边。
*/
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;

请问上面的代码哪个有问题?

/*
   面试题:
   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
    }
}

比较运算符

1、==,!=,>,>=,<,<=。

2、无论运算符两端简单还是复杂最终结果是boolean类型。

3、千万不要把==写成了=。

/*
   特点:
      无论你的操作是简单还是复杂,结果是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
    }
}

逻辑运算符

1、&,|,^,!,&&,||。

2、逻辑运算符用于连接boolean类型的式子。

3、结论

&:有false则false。

|:有true则true。

^:相同则false,不同则true。

!:非true则false,非false则true。

&&:结果和&是一样的,只不过有短路效果。左边是false,右边不执 行。

||:结果和|是一样的,只不过有短路效果。左边是true,右边不执行。

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

   特点:
   逻辑运算符一般用于连接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
    }
}

位运算符

在Java中存在着这样一类操作符,是针对二进制进行操作的。它们各自是&、|、^、~、>>、<<、>>>几个位操作符。不管是初始值是依照何种进制,都会换算成二进制进行位操作。

<<:左移 左边最高位丢弃,右边补齐0。

>>:右移 最高位是0,左边补齐0;最高为是1,左边补齐1。

>>>:无符号右移 无论最高位是0还是1,左边补齐0。

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

   注意:
   要做位运算,首先要把数据转换为二进制。
*/
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 
*/
}

面试题:

请用最有效率的方式写出计算2乘以8的结果?

2 * 8

2 << 3

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);
    }
}

三元运算符

1、格式

比较表达式?表达式1:表达式2;

2、执行流程:

首先计算比较表达式的值,看是true还是false。

如果是true,表达式1就是结果。

如果是false,表达式2就是结果。

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
    }
}

原文发布于微信公众号 - Java大联盟(javaunion)

原文发表时间:2018-04-13

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券