Java运算符

最新推荐文章于 2022-09-15 21:39:00 发布

VirtualLemon

最新推荐文章于 2022-09-15 21:39:00 发布

阅读量165

点赞数

分类专栏： JavaSE基础文章标签： Java基础

本文链接：https://blog.csdn.net/lemon0202/article/details/90042077

版权

JavaSE基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java运算符

运算符其实就是执行各类变量/常量之间运算的一种符号

运算符分为以下几种：

算术运算符

假设下面的A是11，B是10(均为int类型) 下面的+ - * 都用普通数学思维方式想想即可，也很通俗啊…
至于’ / ‘和’ % ‘’: Java里叫除和取余，按照普通数学的思路 10➗3=3…1 这里的商就是使用 ‘/’ 运算符的结果，而余数1 那就是使用 ’ % ’ 运算符的结果了。

运算符对运算符的描述栗子
+ A+B A+B=21
- A-B A-B=1
* A✖B A*B=110
/ A➗B A/B=1
% A%B A%B=1
++ A++ A++或++A=12(*)
– B– B–或--B=9(*)
上方带(*)的是有区别的(各位看官请看代码呢):

具体代码如下:
```
public class Calculate {
    public static void main(String[] args) {
        int A = 11;
        int B = 10;
        System.out.println("A+B的值是:" + (A + B));
        System.out.println("A-B的值是:" + (A - B));
        System.out.println("A/B的值是:" + (A / B));
        System.out.println("A%B的值是:" + (A % B));
        System.out.println("A++的值是:" + (A++));
        System.out.println("--A的值是:" + (--A));
        System.out.println("B--的值是:" + (B--));
        System.out.println("--B的值是:" + (--B));
    }
}
```
输出结果如下:
```
A+B的值是:21 ①
A-B的值是:1 ②
A/B的值是:1 ③
A%B的值是:1 ④
A++的值是:11 ⑥
--A的值是:11 ⑦
B--的值是:10 ⑧
--B的值是:8 ⑨
```
按照上述思路①②③④这几个栗子都好理解，区别就在于A++ 它喵的是先自己＋1，但是这个时候它不把这个+1之后的值给自己，而是当下一次再用它的时候，自己就获得这个值，所以⑥只是表象，你暂时看到的只是11(表面上它没有什么变化),可看⑦的时候是不是也懵圈，怎么–A是11呢？？？回到上一个题，A++本应该按照普通思路变成12，可是它没有变，而是等到⑦的时候，这个时候在–A之前，这个地方的A变成了12(这么说算是方便大家理解吧，并不官方，dalao 们轻喷)，而–A是先减后用，因此它是12 -1之后立马把这个值赋给自己，不是++A那样等到下一次。因此–A的值是11了。按照这个思路，⑧⑨顺利成章往上套，自增运算符在前面的就马上+或者- 自增运算符在后面的就等到下一次用它它再发生变化咯(这里不用产生太多疑惑，记着就行了，我其实也曾经是懵的，随着时间推移也好理解了)。 oh对了，常量是没法用自增或者自减的例子(2–) ??? 2自减干哈呢？你倒不如直接写1对吧哈哈！

运算符	对运算符的描述	栗子
+	A+B	A+B=21
-	A-B	A-B=1
*	A✖B	A*B=110
/	A➗B	A/B=1
%	A%B	A%B=1
++	A++	A++或++A=12(*)
–	B–	B–或--B=9(*)

关系运算符

运算符它返回的是boolean类型，也就是真(true)或者假(false)
这类运算符"常常"作为if(放这里)的一个判断逻辑

运算符	怎么讲？	栗子
==	A等于B	A==B(false)
!=	A不等于B	A!=B(true)
>	A大于B	A>B(true)
<	A小于B	A<B(false)
>=	A大于等于B	A>=B(true)
<=	A小于等于B	A<=B(false)

具体代码如下:

  public class judge {
      public static void main(String[] args) {
          int A = 11;
          int B = 10;
          System.out.println("a == b = " + (A == B));
          System.out.println("a != b = " + (A != B));
          System.out.println("a > b = " + (A > B));
          System.out.println("a < b = " + (A < B));
          System.out.println("b >= a = " + (A >= B));
          System.out.println("b <= a = " + (A <= B));
      }
  }

输出结果如下:

  a == b  = false
  a != b  = true
  a > b  = true
  a < b  = false
  b >= a  = true
  b <= a  = false

上面的这个判断都很简单啊，普通思维就够了.

位运算符

位运算符作用在所有的位上，按位运算，假设A依然是11，B依然是10，那么他们二进制就分别是下面酱紫:

A=1011
B=1010
##### 操作符:  &  |  ^   <<  >>  >>>
------------
A & B = 1010   相对应的位置，两个数都是1，则计算结果才是1，否则是0
A | B = 1011     相对应的位置,两个数之中有一个是1,结果都是1,如果两个都是0,那么结果就是0
A ^ B = 0001  相对应的位置，两个数相同，则结果为0，否则为1
A << 2 =101100    按位左移,向左把各个位置的数挪过去(这里是挪2位) ,挪过去右边不足的0来补上
A>>2 = 10     	按位右移,向右把各个位置的数挪过去 ，也就是10了

具体代码如下:

public class Test {
    public static void main(String[] args) {
        int A = 11;
        int B = 10;
        int C = A & B;
        int D = A | B;
        int E = A ^ B;
        int G = A << 2;
        int H = A >> 2;
        System.out.println("A&B是:" + C);
        System.out.println("A&B的二进制表示是:"+Integer.toBinaryString(C));

        System.out.println("A|B是:" + D);
        System.out.println("A|B的二进制表示是:"+Integer.toBinaryString(D));

        System.out.println("A^B是:" +E);
        System.out.println("A^B的二进制表示是:"+Integer.toBinaryString(E));

        System.out.println("A<<2是:" + G);
        System.out.println("A<<2的二进制表示是:"+Integer.toBinaryString(G));

        System.out.println("A>>2是:" + H);
        System.out.println("A>>2的二进制表示是:"+Integer.toBinaryString(H));
    }
}

输出结果如下:

A&B是:10
A&B的二进制表示是:1010
A|B是:11
A|B的二进制表示是:1011
A^B是:1
A^B的二进制表示是:1
A<<2是:44
A<<2的二进制表示是:101100
A>>2是:2
A>>2的二进制表示是:10

逻辑运算符

这里介绍三种逻辑运算符分别是&& || ！

假设布尔变量A为真(true)，变量B为假(false)

操作符	这是描述	栗子
&&	‘与’ 运算符，只有A和B都为 ‘真’ 时条件为真	A&&B=false
\| \|	‘或’ 运算符,A和B其中一个为 ‘真’ 时条件为真，否则为假	A\| \|B =true
！	'非’运算符,即为反转逻辑状态，true->false false->true	!(A&&B)=true

具体代码如下:

public class Test {
    public static void main(String[] args) {
        boolean A = true;
        boolean B = false;
        System.out.println("A && B = " + (A && B));
        System.out.println("A || B = " + (A || B));
        System.out.println("!(A && b) = " + !(A && B));
    }
}

输出代码如下:

A && B = false
A || B = true
!(A && b) = true

PS:当使用与逻辑运算符时，如果两个数都是true，结果才是true，但是当得到第一个操作为false时，结果就一定是false，这时候就不会再判断第二个操作了。

赋值运算符

操作符	这是描述	栗子
=	赋值运算符,将=右边的值赋给左边的变量	C=A+B
+=	加和赋值运算符,将左边的数和右边的数相加后赋值给左边的数	C += A
-=	减和赋值运算符,将左边的数和右边的数相减后赋值给左边的数	C -= A
*=	乘和赋值运算符,将左边的数和右边的数相乘后赋值给左边的数	C *= A
/=	除和赋值运算符,将左边的数和右边的数相除后赋值给左边的数	C /= A
(%)=	取模和赋值运算符,将左边的数和右边的数取模后赋值给左边的数	C%= A
<<=	左移位赋值运算符	C<<= 2
>>=	右移位赋值运算符	C>>= 2
&=	按位与赋值运算符	C&= 2
^=	按位异或赋值操作符	C^ = 2
\| =	按位或赋值操作符	C \| = 2

具体代码如下:

public class Test {
    public static void main(String[] Args) {
        int A = 11;
        int B = 10;
        int C = 12;
        C = A + B;
        System.out.println("C = A + B =" + C );
        C += A ;
        System.out.println("C += A 同等于C = C + A =" + C );
        C -= A ;
        System.out.println("C -= A 同等于C = C - A =" + C );
        C *= A ;
        System.out.println("C *= A 同等于C = C * A  =" + C );

        A = 11;
        C = 12;

        C /= A ;
        System.out.println("C /= A 同等于C = C / A  =" + C );

        A = 11;
        C = 12;

        C %= A ;
        System.out.println("C %= A 同等于C = C % A =" + C );
        C <<= 2 ;
        System.out.println("C <<= 2 同等于C = C << 2 =" + C );
        C >>= 2 ;
        System.out.println("C >>= 2 同等于C = C >> 2 =" + C );
        C &= 2 ;
        System.out.println("C &= 2 同等于C = C & 2 =" + C );
        C ^= 2 ;
        System.out.println("C ^= 2 同等于C = C ^ 2 =" + C );
        C |= 2 ;
        System.out.println("C |= 2 同等于C = C | 2 =" + C );
    }
}

输出结果如下:

C = A + B =21
C += A 同等于C = C + A =32
C -= A 同等于C = C - A =21
C *= A 同等于C = C * A  =231
C /= A 同等于C = C / A  =1
C %= A 同等于C = C % A =1
C <<= 2 同等于C = C << 2 =4
C >>= 2 同等于C = C >> 2 =1
C &= 2 同等于C = C & 2 =0
C ^= 2 同等于C = C ^ 2 =2
C |= 2 同等于C = C | 2 =2

条件运算符(也被叫做三元运算符) 这个运算符有3个操作数，并且需要判断布尔表达式的值。决定哪个值赋给哪个变量

具体代码如下:

变量 x = (表达式) ? value if true : value if false
    
public class Demo1 {
    public static void main(String[] Args) {
        int A = 10;
        int B = 20;
        // 如果 A大于 10 成立，则A为20，否则为30
        A = A > 10 ? 20 : 30;
        System.out.println("A的值是: " + A);

        // 如果 A 小于 10 成立，则B为15，否则为20
        B = A < 10 ? 15 : 20;
        System.out.println("B的值是: " + B);
    }
}

输出结果如下:

A的值是: 30
B的值是: 20

其他运算符

instance of运算符

( Object reference variable ) instanceof (class/interface type)

*如果运算符左侧变量所表示的对象，是操作符右侧类或接口(class/interface)的一个所属对象，那么结果为真。

下面是个栗子

String name = "周哈哈";
boolean result = name instanceof String; // 因为 name 是 String 类型的，所以是真

Java运算符优先级

普通数学里有先乘除后加减的说法，计算机里同样有类似说法。但是一般不必太过于强硬组合先后顺序，毕竟()是个神奇的括号啊！

以下是摘自百度的一些内容，希望对你有所帮助

优先级从上到下依次递减，最上面具有最高的优先级。

运算符	结合性
[ ] . ( ) (方法调用)	从左向右
! ~ ++ – +(一元运算) -(一元运算)	从右向左
* / %	从左向右
+ -	从左向右
<< >> >>>	从左向右
< <= > >= instanceof	从左向右
== !=	从左向右
&	从左向右
^	从左向右
\|	从左向右
&&	从左向右
\|\|	从左向右
?:	从右向左
=	从右向左

PS: +=和+的区别：

假如 short a=11; a=a+1; 这一段看来可能毫无违和感，甚至没毛病，但是当你打出来的时候就会发现编译器报错了。正确的应该是下面酱紫

short a=11;
a=(short) (a+1);
//或者下面这个
a+=1;

因为计算的时候默认是以int类型计算的那么意思就是你想把一个大水杯(int)的水装进小水杯(short)里这怎么放得下勒。因此编译器会报错

所以更加推荐使用 a+=1 这样的写法，编译器会隐式进行类型转换，所以就不用强制类型转换了。

以上是Java运算符的内容，如有错误之处，敬请指正，毕竟我只是个弟弟，学习分享经验罢了…

VirtualLemon

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java运算符

Java运算符运算符其实就是执行各类变量/常量之间运算的一种符号运算符分为以下几种：算术运算符假设下面的A是11，B是10(均为int类型) 下面的+ - * 都用普通数学思维方式想想即可，也很通俗啊…至于’ / ‘和’ % ‘’: Java里叫除和取余，按照普通数学的思路 10➗3=3…1 这里的商就是使用 ‘/’ 运算符的结果，而余数1 那就是使用 ’ % ’ 运算符的结...
复制链接

扫一扫