JavaSE_day05_运算符丶进制

运算符

运算符是用来计算数据的符号。数据可以是常量，也可以是变量。被运算符操作的数我们称为操作数。Java中常见的运算符有下面几类

• 算术运算符
• 赋值运算符
• 比较运算符又称之为关系运算符
• 逻辑运算符
• 三元运算符

算术运算符

       ​

我们在使用算术运算符时，记得要注意下列事项：

• 加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
• 除法“/”当两边为整数时，取整数部分，舍余数。当其中一边为浮点型时，按正常规则相除。
• “%”为整除取余符号，小数取余没有意义。如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。结果符号与被被模数相同。如：5%-2=1。5是被模数，-2是模数。
• 整数做被除数，0不能做除数，否则报错。

代码演示

/*
运算符：进行特定操作的符号。例如：+
表达式：用运算符连起来的式子叫做表达式。例如：20 + 5。又例如：a + b

四则运算：
加：+
减：-
乘：*
除：/

取模（取余数）：%

首先计算得到表达式的结果，然后再打印输出这个结果。

除法公式：
被除数 / 除数 = 商 ... 余数

对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，不看余数。
只有对于整数的除法来说，取模运算符才有余数的意义。

注意事项：
    1. 一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。
*/
public class Demo04Operator {
    public static void main(String[] args) {
        // 两个常量之间可以进行数学运算
        System.out.println(20 + 30);//50

        // 两个变量之间也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a - b); // -10

        // 变量和常量之间可以混合使用
        System.out.println(a * 10); // 200

        int x = -10;
        int y = 3;
        int z = 63;

        int result1 = x % y;
        System.out.println(result1); // 余数，模，-1

        int result2 = z % x;
        System.out.println(result2);//3
        // int + double --> double + double --> double
        
        double result3 = x + 2.5;
        System.out.println(result3); // -7.5

        //除号：/
        int num1 = 12;
        int num2 = 5;

        int number = num1 / num2;
        System.out.println(number);//2

        int number1 = num1 / num2 * num2;
        System.out.println(number1);//10

        double number2 = num1 / num2;
        System.out.println(number2);//2.0
    }
}

四则运算当中的加号“+”有常见的三种用法：

• 对于数值来说，那就是加法。
• 对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
• 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。任何数据类型和字符串进行连接的时候，结果都会变成字符串

public class Demo05Plus {
    public static void main(String[] args) {
        // 数据类型 变量名称 = 数据值;
        String str1 = "Hello";
        System.out.println(str1); // Hello

        //对于字符串String来说，加号代表字符串连接操作。
        System.out.println("Hello" + "World"); // HelloWorld

        String str2 = "Java";
        // String + int --> String
        System.out.println(str2 + 20); // Java20

        // 优先级问题，如果希望哪段代码先执行可以使用小括号
        System.out.println(str2 + (20 + 30)); // Java50
    }
}

自增自减运算符(属于算术运算符)

​

详解自增自减运算符

• 基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
• 使用格式：写在变量名称之前，或者写在变量名称之后。例如：++i，也可以i++

使用方式：

• 单独使用：不和其他任何操作混合，自己独立成为一个步骤。
• 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。

使用区别：

• 在单独使用的时候，前++和后++没有任何区别。也就是：++i;和i++;是完全一样的。
• 前++和后++不会改变本身变量的数据类型

在混合的时候，有重大区别

• 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。     【先加后用】
• 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。 【先用后加】

代码演示

public class Demo02Operator {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        ++num1; // 单独使用，前++
        System.out.println(num1); // 11
        num1++; // 单独使用，后++
        System.out.println(num1); // 12
 
        // 与打印操作混合的时候
        int num2 = 20;
        // 混合使用，先++，变量立刻马上变成21，然后打印结果21
        System.out.println(++num2); // 21
        System.out.println(num2); // 21
 
        int num3 = 30;
        // 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
        System.out.println(num3++); // 30
        System.out.println(num3); // 31
 
        int num4 = 40;
        // 和赋值操作混合
        int result1 = --num4; // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量
        System.out.println(result1); // 39
        System.out.println(num4); // 39
 
        int num5 = 50;
        // 混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
        int result2 = num5--;
        System.out.println(result2); // 50
        System.out.println(num5); // 49
 
        int x = 10;
        int y = 20;
        // 11 + 20 = 31
        int result3 = ++x + y--;
        System.out.println(result3); // 31
        System.out.println(x); // 11
        System.out.println(y); // 19
 
        // 30++; // 错误写法！常量不可以使用++或者--

        byte i = 127;
        i ++;
        System.out.println(i);//-128
    }
}

注意事项：

• 只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。

赋值运算符

• 基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。
• 复合赋值运算符：+=, -=, *=, /=, %=

                     ​

注意事项：

• 只有变量才能使用赋值运算符，常量不能进行赋值。
• 扩展赋值运算符： +=, -=, *=, /=, %=，扩展的赋值运算符隐含了强制类型转换。不改变原来的数据类型也就是说 byte b=100; b +=1000;b 变量最初是 byte 类型，最后的运算结果还是一个 byte类型。这是一条固定的语法规则，大家记住就行了，以后在使用扩展类赋值运算符的时候要谨慎，不小心就会精度损失的
• 不建议使用连续赋值，阅读性不好。

代码演示

/*
赋值运算符分为：

基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
    int a = 30;

复合赋值运算符：
    +=        a += 3        相当于        a = a + 3
    -=        b -= 4        相当于        b = b - 4
    *=        c *= 5        相当于        c = c * 5
    /=        d /= 6        相当于        d = d / 6
    %=        e %= 7        相当于        e = e % 7

注意事项：
    1. 只有变量才能使用赋值运算符，常量不能进行赋值。
    2. 复合赋值运算符其中隐含了一个强制类型转换。
*/
public class Demo07Operator {
    public static void main(String[] args) {
        int a = 10;
        // 按照公式进行翻译：a = a + 5
        // a = 10 + 5;
        // a = 15;
        // a本来是10，现在重新赋值得到15
        a += 5;
        System.out.println(a); // 15

        int x = 10;
        // x = x % 3;
        // x = 10 % 3;
        // x = 1;
        // x本来是10，现在重新赋值得到1
        x %= 3;
        System.out.println(x); // 1

        // 50 = 30; // 常量不能进行赋值，不能写在赋值运算符的左边。错误写法！
        byte num = 30;

        // num = num + 5;
        // num = byte + int
        // num = int + int
        // num = int
        // num = (byte) int
        num += 5;
        System.out.println(num); // 35
    }
}

比较运算符

比较运算符，又叫关系运算符，它是用来判断两个操作数的大小关系及是否相等关系的，结果是布尔值true或者false。

        ​

注意事项：

• 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false。如果进行多次判断，不能连着写。
• 数学当中的写法，例如：1 < x < 3程序当中【不允许】这种写法。
• 比较运算符“==”不能误写成“=” 。

代码演示

/*
运算符之三：比较运算符
==  !=  >  <  >= <=  instanceof

结论：
1.比较运算符的结果是boolean类型
2.区分 ==  和  = 
*/
public class Demo08Operator {
    public static void main(String[] args) {
            int i = 10;
        int j = 20;
 
        System.out.println(i == j);//false
        System.out.println(i = j);//20
 
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b2 == b1);//false
        System.out.println(b2 = b1);//true
        int x = 2;
        // System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写。
    }
}

逻辑运算符

逻辑运算符主要包括逻辑与（&），逻辑或（|），逻辑异或（^），短路与（&&），短路或（||）。所有逻辑运算符的特点是操作数都是布尔类型，并且最终的运算结果也是布尔类型。逻辑运算符的基本运算规则如下表所示：

         ​

注意事项：

• 逻辑运算符两边要求都是布尔类型，并且最终的运算结果也是布尔类型。
• 逻 辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写 成x>3 & x<6 。如果有多个条件，可以连续写。两个条件：条件A && 条件B 丶多个条件：条件A && 条件B && 条件C
• 异或( ^ )与或 ( | )的不同之处是：当左右都为true时，结果为false。

“&”和“&&”的区别：

• 单&时，左边无论真假，右边都进行运算；
• 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。(效率较高)
• 相同点1：& 与  && 的运算结果相同
• 相同点2：当符号左边是true时，二者都会执行符号右边的运算

“|”和“||”的区别：

• 逻辑或|，无论左边真假，右边都要执行。
• 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。(效率较高)
• 相同点1：| 与  || 的运算结果相同
• 相同点2：当符号左边是false时，二者都会执行符号右边的运算

异或( ^ )与或( | )的不同之处是：

• 当左右都为相同时，结果为true。 理解：异或，追求的是“异”!

代码演示

public class Demo05Operator {
    public static void main(String[] args) {
        System.out.println(5 > 3 & 5 > 4); //true
        System.out.println(5 > 100 | 5 > 4); //true
        System.out.println(!(5 > 3)); //false
        System.out.println(!(5 < 3)); //true
        System.out.println(true & true); //true
        System.out.println(true & false); //false
        System.out.println(true | false); //true
        //取反
        System.out.println(!false); //true
        System.out.println(!true); //false
        //2边相同则结果是false
        System.out.println(true ^ false); //true
        System.out.println(true ^ true); //false
        System.out.println(false ^ false); //false
        //重点研究逻辑与（&）和短路与（&&）的区别
        int x = 100;
        int y = 98;
        int z = 99;
        System.out.println(x > y & x > z); //true
        System.out.println(x > y && x > z); //true
        /*
         * 通过测试得出，逻辑与（&）和短路与（&&）最终运行
         * 结果相同那么它们有什么区别呢？请看以下代码。
         */
        int m = 99;
        int n = 100;
        System.out.println(m > n & m > n++); //false
        /*
         * 逻辑与（&）运算符只有当两边的操作数都是 true 的时候，* 结果才是 true，只要有一个是 false，结果必然是 false。
         * 以上程序逻辑左边的表达式(m > n)显然结果是 false， * 通过左边的表达式已经可以得出结果是false 了，右边的
         * 表达式没有执行的必要，那我们来看一下右边的表达式
         * 有没有执行，只要输出 n 就可以了断定。
         */
        System.out.println("n = " + n); //101
        /*
         * 以上程序的运行结果是 101，足以说明 n++已经执行了。
         * 也说明了逻辑与运算符无论左边表达式结果是true 还
         * 是 false，右边表达式一定会执行。
         */
        //那我们来看一下短路与（&&）是怎样的？
        int k = 99;
        int f = 100;
        System.out.println(k > f && k > f++); //false
        System.out.println("f = " + f); //100
        /*
         * 通过以上测试得出 f++并没有执行，因为左边表达式(k > f)
         * 为 false，右边的表达式就不再执行了，这种现象被称为短路
         * 现象。也就是说对于短路与来说，左边的表达式只要为 false，
         * 就会发生短路，右边表达式不再执行了。
         */
    }
}

位运算符

位运算符的基本运算规则如下表所示：

​

       ​

代码举例：

/*
运算符之五：位运算符 （了解）

结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
   >> :在一定范围内，每向右移1位，相当于 / 2

面试题：最高效方式的计算2 * 8 ？  2 << 3  或 8 << 1
*/
class BitTest {
    public static void main(String[] args) {
        int i = 21;
        System.out.println("i << 2 :" + (i << 2)); //i << 2 :84
        System.out.println("i << 3 :" + (i << 3)); //i << 3 :168
        System.out.println("i << 27 :" + (i << 27));  //i << 27 :-1476395008

        int m = 12;
        int n = 5;
        // 先转化为二进制数，之后0当中false,1当做true 依次运算
        System.out.println("m & n :" + (m & n)); //m & n :4
        System.out.println("m | n :" + (m | n)); //m | n :13
        System.out.println("m ^ n :" + (m ^ n)); // m ^ n :9

        //练习：交换两个变量的值
        int num1 = 10;
        int num2 = 20;
        System.out.println("num1 = " + num1 + ",num2 = " + num2); //num1 = 10,num2 = 20

        //方式一：定义临时变量的方式
        //推荐的方式
        int temp = num1;
        num1 = num2;
        num2 = temp;

        //方式二：好处：不用定义临时变量
        //弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
        //num1 = num1 + num2;
        //num2 = num1 - num2;
        //num1 = num1 - num2;

        //方式三：使用位运算符
        //有局限性：只能适用于数值类型
        //num1 = num1 ^ num2;
        //num2 = num1 ^ num2;
        //num1 = num1 ^ num2;

        System.out.println("num1 = " + num1 + ",num2 = " + num2); //num1 = 20,num2 = 10

    }
}

三元运算符

格式：

• 数据类型 变量名 = 布尔类型表达式？结果1：结果2

计算方式：

• 布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
• 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

代码演示

/*
运算符之六：三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  如果表达式为true，则执行表达式1。
  如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用

3.
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。

4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
public class Demo10Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
        // 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一
        int max = a > b ? a : b; // 最大值的变量
        System.out.println("最大值：" + max); // 最大值：20

        // int result = 3 > 4 ? 2.5 : 10; // 错误写法！
        // 正确写法！
        System.out.println(a > b ? a : b);// 20
        // a > b ? a : b; // 错误写法！

        //获取三个数的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;

        int max1 = (n1 > n2)? n1 : n2;
        int max2 = (max1 > n3)? max1 : n3;
        System.out.println("三个数中的最大值为：" + max2);//三个数中的最大值为：30

        //三元运算符可以嵌套，不建议这么做。不利于阅读,
        int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
        System.out.println("三个数中的最大值为：" + max3);//三个数中的最大值为：30

    }
}

注意事项：

• 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
• 三元运算符的结果必须被使用。

运算符优先级

下图是每种运算符的优先级，按照运算先后顺序排序（优先级相同的情况下，按照从左到右的顺序依次运算）

                           ​

进制

所有数字在计算机底层都以二进制形式存在。

对于整数，有四种表示方式：

• 二进制(binary)：0,1 ，满2进1.以0b或0B开头。
• 十进制(decimal)：0-9 ，满10进1。
• 八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
• 十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。 如：0x21AF +1= 0X21B0

代码演示，进制的基本使用：

class BinaryTest {
    public static void main(String[] args) {
        //二进制(binary)：0,1 ，满2进1.以0b或0B开头。
        int num1 = 0b110;
        //十进制(decimal)：0-9 ，满10进1。
        int num2 = 110;
        //八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
        int num3 = 0127;
        //十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
        int num4 = 0x110A;
 
        System.out.println("num1 = " + num1);//num1 = 6
        System.out.println("num2 = " + num2);//num2 = 110
        System.out.println("num3 = " + num3);//num3 = 87
        System.out.println("num4 = " + num4);//num4 = 4362
 
    }
}

二进制

• Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位； 当是long类型时，二进制默认占64位，第64位是符号位

二进制的整数有如下三种形式：

• 原码：直接将一个数值换成二进制数。最高位是符号位
• 负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
• 负数的补码：其反码加1。

计算机以二进制补码的形式保存所有的整数。

• 正数的原码、反码、补码都相同
• 负数的补码是其反码+1

为什么要使用原码、反码、补码表示形式呢？

• 计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是 人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正 数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有 减法, 这样计算机运算的设计就更简单了。