三、编程基础(四)Java运算符

今天的博客主题

      基础篇 --》编程基础 --》Java运算符

---

先看下Java都提供了那些符号

1、分隔符
    .（点） ,（逗号） () （小括号）[] （中括号）{}（大括号） ;（分号）

2、算术运算符
    +（加） -（减） *（乘） /（除） %（取余，模）
    ++ 本身自增1，在前的时候，先自增，再赋值，在后的时候，先赋值，再自增
    -- 本身自减1，在前的时候，先自减，再赋值，在后的时候，先赋值，再自减

3、关系运算符
    >（大于） <（小于） >=（大于等于） <=（小于等于） !=（不等于） ==（等等于）

4、逻辑运算符
    &&（与）  ||（或）  !（非）

5、字符串连接符
    +

6、赋值运算符
    =（等于） +=（加等） -=（减等） *=（乘等） /=（除等） %=（模等于）

7、三目运算符(三元运算符、条件运算符)
    ? : 

8、位运算符

&（位与）、|（位或）、~（位非）、^（位异或）、>>（右移）、<<（左移）、>>>（0填充的右移）

认识了Java提供的这些运算符之后，逐个讲解。

 

分隔符

.（点） ,（逗号） () （小括号）[] （中括号）{}（大括号） ;（分号）

这个就不用细细的说了，都是一些比较常用的分隔符号

算术运算符

+（加） -（减） *（乘） /（除） %（取余，模）

++ 本身自增1，在前的时候，先自增，再赋值，在后的时候，先赋值，再自增

-- 本身自减1，在前的时候，先自减，再赋值，在后的时候，先赋值，再自减

例：

//算术运算符
public class TestCas {
    public static void main(String[] args) {
        int i1 = 6;
        int i2 = 8;
        int i3 = 7;
        int i4 = 9;
        //加法运算(+)
        System.out.println("i1 + i2 = " + (i1 + i2) );

        //减法运算(-)
        System.out.println("i1 - i2 = " + (i1 - i2) );

        //乘法运算(*)
        System.out.println("i1 * i2 = " + (i1 * i2) );

        //除法运算(/)
        System.out.println("i1 / i2 = " + (i1 / i2) );

        //取模运算（也叫取余数）(%)
        System.out.println("i1 % i2 = " + (i1 % i2) );

        //自增运算符（比较特殊，一个操作数就能做）(++)
        System.out.println("i1 ++ = " + (i1++) );
        System.out.println("++ i3 = " + (++i3) );

        //自减运算符（比较特殊，一个操作数就能做）(--)
        System.out.println("i2 -- = " + (i2--) );
        System.out.println("-- i4 = " + (--i4) );

        //重点说下自增(++) 自减(--)
        //自增(i1++) 自减(i1--)如果在后面的话，就先给当前变量赋值，然后在进行计算
        //自增(++i1) 自减(--i1)如果在前面的话，就先进行计算，给当前变量赋值
    }
}

输出结果：
    i1 + i2 = 14
    i1 - i2 = -2
    i1 * i2 = 48
    i1 / i2 = 0
    i1 % i2 = 6
    i1 ++ = 6
    ++ i3 = 8
    i2 -- = 8
    -- i4 = 8

运算符比较简单，就是一些简单的计算。比较重要难理解的就是自增和自减了。

关系运算符

>（大于） <（小于） >=（大于等于） <=（小于等于） !=（不等于） ==（等等于）

//关系运算符
public class TestCas {
    public static void main(String[] args) {
        int i1 = 6;
        int i2 = 8;
        //左边大于右边(>) 
        System.out.println("i1 > i2 = " + (i1 > i2) );

        //左边小于右边(<)
        System.out.println("i1 < i2 = " + (i1 < i2) );

        //左边大于等于右边(>=)
        System.out.println("i1 >= i2 = " + (i1 >= i2) );

        //左边小于等于右边(<=)
        System.out.println("i1 <= i2 = " + (i1 <= i2) );

        //左边不等于右边(!=)
        System.out.println("i1 != i2 = " + (i1 != i2) );

        //左边等等于右边(==)
        System.out.println("i1 == i2 = " + (i1 == i2) );
    }
}

输出结果：
    i1 > i2 = false
    i1 < i2 = true
    i1 >= i2 = false
    i1 <= i2 = true
    i1 != i2 = true
    i1 == i2 = false

关系运算符就是我们小学就学到的，没那么复杂。但是记住关系运算符返回值类型是boolean类型的。

逻辑运算符

&&（与）  ||（或）  !（非）

//逻辑运算符
public class TestCas {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;
        //与（并且）(&&) 在&&符号左边与右边的操作数或表达式必须都为真，才为真
        System.out.println("b1 && b2 = " + (b1 && b2));

        //或（或者）(||) 在||符号左边与右边的操作数或表达式只要有一个为真，就为真
        System.out.println("b1 || b2 = " + (b1 || b2));

        //非（反值）(!) 取最终表达式的相反值，假如最后结果为false，在表达式前加!那就变成了ture
        System.out.println("b1 ! b2 = " + !(b1 && b2));
    }
}

运行结果：
    b1 && b2 = false
    b1 || b2 = true
    b1 ! b2 = true

字符串连接符

+

当+前后只要有一个是字符串时，就拼接字符串。
当+前后都是数字的时候，实行加法运算。
这个符号和之前的运算符符号一样，当不一样的操作数参与最后的结果意义完全不一样。

//逻辑运算符
public class TestCas {
    public static void main(String[] args) {
        //当前后都是数字的时候做加法运算
        System.out.println(6 + 8);

        //当前后有一个是字符串时，就拼接字符串
        System.out.println(6 + "8");
    }
}

运行结果：
    14
    68

赋值运算符

=（等于） +=（加等） -=（减等） *=（乘等） /=（除等） %=（模等于）

//赋值运算符
public class TestCas {
    public static void main(String[] args) {
        int i1 = 5;
        int i2 = 10;
        int i3 = i1 + i2;
        //等于(=)，简单的赋值操作符
        System.out.println("i3 = i1 + i2 = " + i3);

        //加等于(+=)，A += B 等价于 A = A + B
        int i4 = 6;
        i4 += i1;
        System.out.println("i4 = += i1 = " + i4);

        //减等于(-=)，A -= B 等价于 A = A - B
        int i5 = 6;
        i5 -= i1;
        System.out.println("i5 = -= i1 = " + i5);

        //乘等于(*=)，A *= B 等价于 A = A * B
        int i6 = 6;
        i6 *= i1;
        System.out.println("i6 = *= i1 = " + i6);

        //除等于(/=)，A /= B等价于 A = A / B
        int i7 = 6;
        i7 /= i1;
        System.out.println("i7 = /= i1 = " + i7);

        //模等于(%=)，A %= B等价于 A = A % B
        int i8 = 6;
        i8 %= i1;
        System.out.println("i8 = %= i1 = " + i8);
    }
}

运行结果：
    i3 = i1 + i2 = 15
    i4 = += i1 = 11
    i5 = -= i1 = 1
    i6 = *= i1 = 30
    i7 = /= i1 = 1
    i8 = %= i1 = 1

三目运算符(三元运算符、条件运算符)

? : 

//三目运算符
public class TestCas {
    
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;

        //如果b1为真，那么i1就是100，否则就是99
        int i1 = b1 ? 100 : 99;
        System.out.println("i1 = " + i1);

        //如果b2为真，那么i2就是100，否则就是99
        int i2 = b2 ? 100 : 99;
        System.out.println("i2 = " + i2);

		//套入表达式，意思就是如果1+1大于2，那么i3就是100，否则就是99
        int i3 = (1+1) > 2 ? 100 : 99;
        System.out.println("i2 = " + i2);
    }
}

运行结果：
    i1 = 100
    i2 = 99

位运算符

&（位与）、|（位或）、~（位非）、^（位异或）、>>（右移）、<<（左移）、>>>（0填充的右移）

位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。
位运算符的目的是为了节约内存开销和加快计算效率
一般的Java项目开发当中没有见到过这种运算符，比如一些底层源码或者算法会见到位运算符。
位运算符应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

//位运算符
public class TestCla {
    
    public static void main(String[] args) {
        //与（&）两个整数二进制对应的位码，如果都为1就是1，否则为0
        int i1 = 19;// 0001 0011
        int i2 = 84;// 0101 0100
                    // 0001 0000
        System.out.println("十进制数 " + i1 + " ==> 二进制:" +                 
                  Integer.toBinaryString(i1));
        System.out.println("十进制数 " + i2 + " ==> 二进制:" + 
                  Integer.toBinaryString(i2));
        System.out.println("那么 i1 & i2 = " + (i1 & i2));

        //或（|）两个整数二进制对应的位码，如果都为0就是0，否则为1
        int i3 = 19;// 0001 0011
        int i4 = 84;// 0101 0100
                    // 0101 0111
        System.out.println("十进制数 " + i3 + " ==> 二进制:" + 
                  Integer.toBinaryString(i3));
        System.out.println("十进制数 " + i4 + " ==> 二进制:" + 
                  Integer.toBinaryString(i4));
        System.out.println("那么 i3 | i4 = " + (i3 | i4));

        //异或（^）两个整数二进制对应的位码，如果相同就是0，否则就是1
        int i5 = 19;// 0001 0011
        int i6 = 84;// 0101 0100
                    // 0100 0111
        System.out.println("十进制数 " + i5 + " ==> 二进制:" + 
                  Integer.toBinaryString(i5));
        System.out.println("十进制数 " + i6 + " ==> 二进制:" + 
                  Integer.toBinaryString(i6));
        System.out.println("那么 i3 ^ i4 = " + (i3 ^ i4));

        //非（~）该整数二进制对应的位码，取相反值
        int i7 = 19;// 0001 0011
                    // 1110 1100
        System.out.println("十进制数 " + i7 + " ==> 二进制:" + 
                  Integer.toBinaryString(i7));
        System.out.println("那么 ~i7 = " + ~i7);

        //位左移（<<）该整数为1的位数向左移动两个位置，空余位置补0
        int i8 = 19;// 0001 0011
                    // 0100 1100
        System.out.println("十进制数 " + i8 + " ==> 二进制:" + 
                  Integer.toBinaryString(i8));
        System.out.println("那么 i8 << 2 = " + (i8 << 2));

        //位右移（>>）该整数为1的位数向右移动两个位置，空余位置补0
        int i9 = 19;// 0001 0011
                    // 0000 0100
        System.out.println("十进制数 " + i9 + " ==> 二进制:" + 
                  Integer.toBinaryString(i9));
        System.out.println("那么 i9 >> 2 = " + (i9 >> 2));

        //位右移补零（>>>）该整数为1的位数向右移动两个位置，空余位置补0
        int i10 = 64;// 0001 0011
                     // 0001 0000
        System.out.println("十进制数 " + i10 + " ==> 二进制:" + 
                  Integer.toBinaryString(i10));
        System.out.println("那么 i10 >> 3 = " + (i10 >>> 2));
    }
}

运行结果
    十进制数 19 ==> 二进制:10011
    十进制数 84 ==> 二进制:1010100
    那么 i1 & i2 = 16

    十进制数 19 ==> 二进制:10011
    十进制数 84 ==> 二进制:1010100
    那么 i3 | i4 = 87

    十进制数 19 ==> 二进制:10011
    十进制数 84 ==> 二进制:1010100
    那么 i3 ^ i4 = 71

    十进制数 19 ==> 二进制:10011
    那么 ~i7 = -20

    十进制数 19 ==> 二进制:10011
    那么 i8 << 2 = 76

    十进制数 19 ==> 二进制:10011
    那么 i9 >> 2 = 4

    十进制数 64 ==> 二进制:1000000
    那么 i10 >> 3 = 16

运算符优先级(由先到后)

分隔符 --》算术 --》 关系 --》 逻辑 --》 三目 --》 赋值
    int i = (3 > (5 + 6)) && 71 < 9 ? 4 : 8;

---

第一次贴代码好紧张

其实Java运算符与生活当中的运算符一样的。只不过是根据需求来编写对应的逻辑代码而已。

---

敏而好学  不耻下问