Java基础3(运算符)

常用运算符

在java运算过程中,无论是什么运算,都应该遵循以下三种形式:

  1. 当有多种类型的数据混合运算时,系统首先自动将所有数据转换成取值范围最大的那种数据类型,然后再进行计算。

  2. byte,short,char之间不会相互转换,他们三者在计算时首先转换为int类型,然后在运算。

  3. 有可能会发生溢出现象(封闭式运算)

两个整数运算时,可以能会出现溢出情况,即超出整数范围的运算。正数溢出,会变成负数;负数溢出,会变成正数。我们也称之为封闭式运算。

* reg:int a=2147483647
*     int b =2
*   int c=a+b;//-2147483647

对于java运算符,我们可以细分成以下运算符:

  • 算术运算

  • 关系运算(比较运算)

  • 逻辑运算

  • 赋值运算

  • 位运算

  • 三元运算(三目运算,条件运算)

 算术运算符

+  -  *  /  %

以上几个运算的注意事项:
1. %:取模运算符,即求余数,  5 % 3 = 2
2. /:整型与整型的计算结果,还是整型。最终除如果得到一个浮点型的结果,那么这个浮点型的数字 会自动的转成整型数字,浮点型转整型,舍去小数点后面所有的内容,直接保留整数部分。

难点:    ++  --
自增、自减运算符,对一个变量进行自增1、自减1。
自增、自减运算符,可以放在变量的前面,也可以放在变量的后面。

放变量前:先对这个变量进行自增、自减操作,然后再使用这个变量的值。 
放变量后:先使用这个变量的值,然后再对这个变量进行自增、自减操作。

        //自增自减
        //与某一个变量一起使用,不再与其他变量做运算时简单明了 本身自动加一或减一
        int y = 1;
        y++;
        System.out.println(y);//2
        int y2 = 10;
        y2--;
        System.out.println(y2);//9


         //1.自增自减符号在前时
        //变量本身先自增或者自减     然后新值赋给整体
         //2.自增自减符号在后时
        //变量把值赋给整体(表达式) 然后本身自增自减
        int q1 = 10 ;
        int q2 = q1++;//表达式
        System.out.println(q1);//11
        System.out.println(q2);//10

        int q3 = 100 ;
        int q4 = --q3;
        System.out.println(q3);//99
        System.out.println(q4);//99


        int c1 = 50;
        c1 = c1++;
        System.out.println(c1);//50
        //先计算等号右边的整个式子,最后计算等号运算符。
        //c1把值赋给(c1++)表达式的值是50
        //表达式里的c1变成51,表达式的值通过等号再次赋给c1,50把51覆盖
        int c2 = 50;

        //   51        51
        c2 = (++c2) + (c2--);
        System.out.println(c2);//102

        int k = 1;
        int h = 2;
        int j = 3;
        //    k=2   h=3     j=2     k=1      j=3     h=2
        //  k++=1  ++h=3    --j=2   k--=2    ++j=3   h--=3
        //h=1+3+2-2+3+3=10
        h = k++ + ++h + --j - k-- + ++j + h--;
        System.out.println(k);//1
        System.out.println(j);//3
        System.out.println(h);//10

赋值运算符

=
是一个赋值运算符,将等号右边的值给左边的变量进行赋值。 

+=  -=  *=  /=  %=
将一个变量,在现有值的基础上,对一个数字进行运算
   a += 3;    // a = a + 3;
   a -= 3;     // a = a - 3;
   a *= 3;     // a = a * 3;
   a /= 3;     // a = a / 3;
   a %= 3;   // a = a % 3;

char c = 'a';
System.out.println(c += 2); // 结果是c,并不是99

byte n = 127;
n++; // n += 1   n = n + 1
System.out.println(n);      // 结果是-128

int a = 10;
System.out.println(a = 100);    // 结果是赋值完成后的变量值100

 关系运算符

对两个数据进行大小比较的运算 

>  <  >=  <=  ==  !=

关系运算的结果一定是  boolean 类型

 逻辑运算符

对两个boolean类型的变量或者表达式,进行的运算 
 &          |          !         ^
 &:与,两真即为真,有任意一个为假,结果就是假。 
 |:或,两假即为假,有任意一个为真,结果就是真。 
 !:非,非真即假,非假即真。
 ^:异或,两个相同为假,两个不同为真。

        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        boolean result = a>b & c>d;
        System.out.println(result);//F
        boolean result1 = a>b & c>d;
        System.out.println(result1);//F
        boolean result2 = a<b & c>d;
        System.out.println(result2);//F
        boolean result3 = a<b & c<d;
        System.out.println(result3);//T

        boolean result4 = a<b | c<d;
        System.out.println(result4);//T
        boolean result5 = a<b | c>d;
        System.out.println(result5);//T
        boolean result6 = a>b | c>d;
        System.out.println(result6);//F

        boolean result11=!(a < b);
        System.out.println(result9);
        boolean result12=!(a > b);
        System.out.println(result10);

&&:短路与       ||:短路或
短路操作:如果在进行逻辑运算的时候,前半部分的内容可以决定最终的结果,则后半部分不参与运算。 
以后在使用逻辑运算的时候,如果没有特殊的需求,尽量使用短路操作。

         //&&:第一个条件是假的,第二个就不执行
       boolean result7 = a > b && c++ > d;
       System.out.println(result7);//false
       System.out.println(c);//c还是3 未执行第二个条件
        //如果第一个条件是真的,不能确定答案 要执行第二个条件
        boolean result8 = a < b && c < d;
        System.out.println(result8);
        System.out.println(c);//c变成4

        //&&:第一个条件是真的,第二个就不执行
        boolean result9 = a < b || c > d++;
        System.out.println(result9);//true
        System.out.println(d);//d=4 未执行第二个条件
        //如果第一个条件是假的,不能确定答案 要执行第二个条件
        boolean result10 = a > b || c < d++;
        System.out.println(result10);//
        System.out.println(d);//d=5

 ^  异或 同位上的1或0进行运算       相同为0 不同为1
  也可以理解为:0表示没有 假的
                           1表示有,真的


        int x1 = 2 ;//00000000 00000000 00000000 00000010
        int x2 = 3;//00000000 00000000 00000000 00000011
        int x3 = 2^3;
        System.out.println(x3);//00000000 00000000 00000000 00000001

        int x4 = -3;//11111111 11111111 11111111 11111101
        int x5 = 3;
        int x6 = x4^x5;//11111111 11111111 11111111 11111110
        System.out.println(x6);

 位运算符

类似于逻辑运算,将两个整型数字的补码的每一位进行类似逻辑运算的操作。 1相当于true, 0相当于 false。

&         |          ^          ~ 

注意事项:
~按位取反,是将一个数字的补码的每一位进行取反,包括符号位。

eg:

        int a =10;//00001010
        int b =5; //00000101;
        //有0是0  全1为1
        System.out.println(a&b);//00000000  --->0
        //有1为1 全0为0
        System.out.println(a|b);//00001111  --->15
        //^  相同为0 不同为1
        System.out.println(a^b);//00001111  --->15
        //~  按位取反
        System.out.println(~a);//11110101 取反加一带符号---> 00001010+1 --->-11
        System.out.println(~b);//11111010 --->00000101+1--->-6

<<   >>    >>>
位移运算符,也叫作移位运算符。
将一个数字的补码的每一位向左或者向右移动指定的位数。

>> : 有符号右移,左侧补符号位。

>>>: 无符号右移,左侧补0。
1、左移运算符,每向左移动一位,相当于乘一个2
2、右移运算符,每向右移动一位,相当于除一个2,但是如果除的结果是浮点型数字,最后的结果是向下取整。

        byte x=10;//00001010
        System.out.println(x >> 1);//00000101 --->5
        byte y = 65;//01000001
        System.out.println(y>>3);//00001000 --->8
        System.out.println(y<<1);//10000010 --->128+2=130
        byte y1 =-65;//10111111
        System.out.println((byte)(y1>>1));//1101 1111--->0010 0000+1---->-33
        System.out.println((byte)(y1>>>1));//0101 1111---->1010 0000--->-128+32---> -33

注意:

1、位异或:定理:一个数字和另外一个数字异或两次,肯定得到自己。
2、如何高效率的计算  2 * 8 解:  2 << 3

 三目运算(三元运算,条件运算)

语法:
boolean变量或者boolean结果的表达式?值1:值2 
规则:
如果问号前面的boolean是true,整体的结果是值1;  
如果问号前面的boolean是false,整体的结果是值2;

eg:

int a = 10, b = 20;
先判断a和b的大小关系,
如果a > b成立,取a的值给max赋值, 如果a > b不成立,取b的值给max赋值
int max = a > b ? a : b;

        int x =10;
        int y =20;
        //使用三目运算符得到较大值
        int max =x > y? x:y;
        System.out.println(max);

        int m = 1;
        int n = 2;
        int q = 3;
        //第一个思路:先拿两个变量m,n比较,用结果再和q比较
        int r1 = m>n?m:n;
        int r2 = r1>q?r1:q;
        System.out.println(r2);

        //第二个思路:
        int r3=m>n?(m>q?m:q):(n>q?n:q);
        System.out.println(r3);

 运算符的优先级

运算符的简单分类:

运算符根据操作数的不同,可以分为:一元运算符、二元运算符、三元运算符。

一元运算符:只能操作一个操作数, ++ -- ! ~ + - (此时的+和-代表的是正负) 
二元运算符:只能操作两个操作数,
三元运算符:只能操作三个操作数,三目运算符。

运算符的优先级:

1. 一元运算符  > 二元运算符  > 三元运算符
2. 算术运算:乘除模  > 加减
3. 逻辑运算:与  > 或
4. 赋值运算符的优先级是最低的
5. 小括号的优先级是最高的

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值