Java基础语法07-10 - 基本运算符

1.算术运算符：

+，-，*，/，%， ++，--。

A. 二元运算符

+，-，*，/，%

没什么好说的，这最要注意的是，%，取余，在Java中叫模运算，运算时要注意精度问题。

运算时，byte，short 类型运算后的结果为 int类型。

示例：

package operator;

public class Demo01 {
    public static void main(String[] args) {
        int i1 = 10 ;
        int i2 = 20 ;
        int i3 = 30 ;
        int i4 = 40 ;

        System.out.println(i1+i2);
        System.out.println(i2-i3);
        System.out.println(i3*i4);
        System.out.println(i1/i4); //输出结果为0，产生精度问题 10/40 = 0.4
        System.out.println((double)i1/i4); //输出0.25，要强转
    }
}

输出：

示例二：

package operator;

public class Demo02 {
    public static void main(String[] args) {
        byte b1 = 10 ;
        short s1 = 21 ;
        int i1 = 31 ;
        long l1 = 400L ; //Long 类型，加后缀L
        float f1 = 5.1F ; //浮点类型，加后缀F
        double d1 = 3.14 ;
        System.out.println(b1+s1);
        System.out.println(l1-s1);
        System.out.println(l1*f1);
        System.out.println(d1/b1);
        System.out.println(b1%s1); //结果为10，%求余，Java中叫求模运算
        /*
        System.out.println((String) (b1+b1)); //byte 相加，提示cannot cast 'int' to java.lang.String
        System.out.println((String) (s1+s1)); //short 相加，提示cannot cast 'int' to java.lang.String
        System.out.println((String) (i1+i1)); //int 相加 ，提示cannot cast 'int' to java.lang.String
        System.out.println((String) (l1+l1)); //long 相加，提示cannot cast 'long' to java.lang.String
        System.out.println((String) (f1+f1)); //float 相加，提示cannot cast 'float' to java.lang.String
        System.out.println((String) (d1+d1)); //double 相加，提示cannot cast 'double' to java.lang.String
        */
        
        /*
        System.out.println((String) (b1+s1)); // byte short 相加，提示cannot cast 'int' to java.lang.String
        System.out.println((String) (l1+s1)); // short long 相加，提示cannot cast 'long' to java.lang.String
        System.out.println((String) (l1+f1)); // long float 相加，提示cannot cast 'float' to java.lang.String
        System.out.println((String) (d1+b1)); // double byte 相加，提示cannot cast 'double' to java.lang.String
        */
    }
}

可以看出 byte，short 类型参与运算时，会自动转换为 int 类型，其他类型依然按照低到高的原始处理（参考：Java基础语法05 - 数据类型转换）。

B. 自增，自减一元运算符：

++, --

a++ ==> a=a+1;
++a ==> a=a+1;
//两者一样

示例：

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //一元运算符， ++ --
        int a = 3;
        int b = a++ ; //相当于 b = a，a = a + 1
        int c = ++a ; //a = a + 1， 相当于 c = (a = a + 1)

        System.out.println(a); //5， a 自增2次，所以是5
        System.out.println(b); //3， 先赋值，再自增，所以是3
        System.out.println(c); //5，先自增，再赋值，所以是5

    }
}

C. 幂运算

幂运算用到数学工具类 Math类，结果是double类型。

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //数学工具类 Math Math.pow -> 数学求次方
        double d1 = 3;
        double d2 = 2;
        System.out.println(Math.pow(d1,d2)); //3^2 = 9;
    }
}

输出：

9.0

2.赋值运算符：

=

3.关系运算符：

>，<，>=，<=，==，！=，instanceof (判断一个对象是否为一个类的实例)。

返回结果只能是布尔值 true / false 。

示例：

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符 运算结果是布尔值，只能返回 true 或 false。
        int i1 = 10 ;
        int i2 = 20 ;
        float i3 = 10.0F ;
        int i4 = 10 ;
        double i5 = 10.0001 ;
        float i6 = 10.0001F ;
        byte i7 = 10 ;
        System.out.println(i1>i2); //false
        System.out.println(i1<i2); //true
        System.out.println(i1>=i5); //false 10 小于 10.0001F
        System.out.println(i1<=i3); //true 10 等于 10.0F
        System.out.println(i5!=i6); //ture 10.001 与 10.0001F 不相等
        System.out.println(i1==i5); //false 10 不等于 10.0001
        System.out.println(i1==i3); //true 10 与 10.0F相等
        System.out.println(i1>i7); //int 10 不大于 byte 10
    }
}

输出：

false
true
false
true
true
false
true
false

可以看到低容量与高容量类型对比相同的值是一样的。
但double 和float 相同的值，比较的结果不一样，前面说过的精度问题。

4.逻辑运算符：

&&，||，！。

&& 逻辑与运算：两个变量都为真，结果才为true。

|| 逻辑或运算：两个变量只要有一个为真，结果就是true，也就是说只有2个都为false 时才为 false。

！ 非运算：如果变量为真，结果为false，如果变了为假，结果为true。非就是取反的意思。

示例：

package operator;

public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算符
        // &&（and 与），|| （or 或），!（非，取反）
        boolean flag1 = true ;
        boolean flag2 = false ;

        System.out.println("flag1 && flag2: " + (flag1&&flag2) ); // false, and，只有两个为真，结果才为真
        System.out.println("flag1 || flag2: " + (flag1||flag2) );// ture, or, 只有两个为假，结果才粉假
        System.out.println("!(flag1 && flag2): " + !(flag1&&flag2) ); // true, Opposite， 取反操作
    }
}

输出：

flag1 && flag2: false
flag1 || flag2: true
!(flag1 && flag2): true

中间涉及短路运算，也就是说当操作 &&时，第一个为假的时候，直接返回false，&&后面的不执行，代码被直接短路跳过了。
同时理，执行||操作时，第一个为真时，直接返回真，||后面的条件不执行。

短路运算：

示例：

package operator;

public class Demo05 {
    public static void main(String[] args) {
        //短路运算
        int i = 4;
        boolean b1 = i<4 && (++i>4) ; //and,只要第一个为假，结果为假，直接返回false,没有执行 '&&' 后面的i++
        System.out.println(b1); // false
        System.out.println(i);  // 4， i++没被执行
        System.out.println("==========");

        boolean b11 = (i>=4) && (++i>4) ; //and,两个为真，结果才为真
        System.out.println(b11); // true
        System.out.println(i);  // 5
        System.out.println("==========");

        int i2 = 4;
        boolean b2 = i2>3 || (i2++>4) ; // or，只要第一个为真，结果为真，直接返回true，同样没执行 '||' 后面的代码
        System.out.println(b2); //true
        System.out.println(i2); // 4，i2++没被执行
        System.out.println("==========");

        boolean b21 = (i2>4) || (i2++>4) ; //and,两个为假，结果才为假,证明先执行了逻辑运算i2>4，再执行的自增运算i2++
        System.out.println(b21); // false
        System.out.println(i);  // 5
        System.out.println("==========");
    }
}

输出：

false
4
==========
true
5
==========
true
4
==========
false
5
==========

Process finished with exit code 0

也就是说，当执行&&运算时，只有第一个为真，第二个条件才有机会被执行。
当执行||运算时，只有第一个为假，第二个才有机会被执行。

5.位运算符：

&，|，^，~，>>，<<，>>>。

位运算逻辑上与关系运算一样的，只是位运算是跟据位来的，二进制的运算。

&与运算，11为1，其他为0；
| 或运算，00为0，其他为1；
^异或运算，相同为0，不同为1；
~取反，就是0变1，1变0；

示例：

package operator;

public class Demo06 {
    public static void main(String[] args) {
        //位运算
        /*
        A = 0011 1100 ;
        B = 0000 1101 ;
        ---------------------
        A&B = 0000 1100 ; and 11为1，其他为0；
        A|B = 0011 1101 ; or 00为0，其他为1；
        A^B = 0011 0001 ; xor 同为0，不同为1；
        ~B = 1111 0010 ; and 11为1，其他为0；
         */

        //2*8 怎么运算最快？
        //答案是 位运算,直接跟计算机底层打交道，效率高
        //这里要用到的位运算符是： 左移<< 右移>>
        // << *2 左移相当于X2^n，n为移动位数
        // >> /2 右移相当于/2^n
        /*
        0000 0000      0
        0000 0001      1
        0000 0010      2
        0000 0011      3
        0000 0100      4
        0000 1000      8
        0001 0000      16  //2^4
         */
        System.out.println(2<<3); //16
        System.out.println(1<<3); //8
        System.out.println(3<<3); //24
    }
}

输出：

16
8
24

关于异或运算：

异或，是一个数学运算符，英文为 exclusive OR，缩写为 xor，应用于逻辑运算。异或的数学符号为“ ⊕ ”，计算机符号为“ xor ”。

如果a、b两个值不相同，则异或结果为1。如果a、b两个值相同，异或结果为0。

拓展：

异或也叫半加运算，其运算法则相当于不带进位的二进制加法：二进制下用1表示真，0表示假，则异或的运算法则为：0⊕0=0，1⊕0=1，0⊕1=1，1⊕1=0（同为0，异为1），这些法则与加法是相同的，只是不带进位。
异或略称为XOR、EOR、EX-OR

6.条件运算符(三元运算符)：

? ：

x?y:z 如果x为true，则结果为y，如果x为false，结果为z。

示例：

package operator;

public class Demo08 {
    public static void main(String[] args) {
        //三元运算符
        // x?y:z ; 如果X真，结果y；否则结果为Z。
        int score = 90 ;
        String total = (score>60)?"及格":"不及格" ;
        System.out.println(total);

    }
}

输出：

及格

7.扩展赋值运算符：

+=，-=，*=，/+。

a+=b；相当于 a = a+b；其他一样

package operator;

public class Demo07 {
    public static void main(String[] args) {
        int a = 10 ;
        int b = 20 ;
        
       // b+=a ; //30 b = b+a
        b-=a ; //10 b = b-a
        System.out.println(b); //10

        //字符串连接符 +
        // + 旁边出现 String类型，哪里出现String，String两边的+为字符串连接符，其他是正常运算的+（加号）。
        System.out.println("" + a+b); //1010 相当于""+"1010"
        System.out.println(a+b+""); //20 相当于 "20"+""
        System.out.println(a+b+""+a+b); //201010 相当于 "20" + "1010"
    }
}

输出：

文章目录