Java 总结第一弹

Java 基础 (三)

3.运算符

运算符包括：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符以及三元运算符

3.1 算术运算符

算术运算符：加(+)、减(-) 、乘(*) 、整除(/) 、取余(%) 、自增(++) 、自减(–)

public class Test{
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        System.out.println(a + b);	// 15
        System.out.println(a - b);	// 5
        System.out.println(a * b);	// 50
        System.out.println(a / b);	// 整除 2
        System.out.println(a % b);	// 取余 0
        
        float c = 3.0f;
        double d = 3.0;
        System.out.println(a / c); // 3.3333333
        System.out.println(a / d); // 3.3333333333333335
        System.out.println(a % c); // 1.0
        System.out.println(a % d); // 1.0
        
        System.out.println(10.0 / 0.0); // Infinity --> 无穷大
		System.out.println(0.0 / 0.0); 	// NaN --> Not a Number
        
        System.out.println(10 / 0);
        // Exception in thread "main" java.lang.ArithmeticException: / by zero
        
        int x = 10;
        System.out.println(x++); //10 (11)  先赋值，再计算
        System.out.println(++x); //12  先计算，再赋值
        System.out.println(x--); //12 (11)  先赋值，再计算
        System.out.println(--x); //10  先计算，再赋值
    }
}
/**
 *
 *	注意：
 *		整除需要看被除数的数据类型:
 *			1.如果被除数是整数，那整除出来的上就是整数
 *			2.如果被除数是浮点数类型，那整除出来的就是浮点数
 *		当浮点数除以 0 的时候，结果为 Infinity 或者 NaN
 *		当整数除以 0 的时候（10 / 0），会抛出异常:
 *			Exception in thread "main" java.lang.ArithmeticException: / by zero
 *		自增自减:
 *			++/-- 看其在变量前后：在前先计算后赋值，在后先赋值后计算
 *
 */

3.2 关系运算符

关系运算符：用来比较两个操作数，返回比较结果 true / false

包含：等于(==) 、不等于(!=) 、大于(>) 、大于等于(>=) 、小于(<) 、小于等于(<=)

public class Test{
    public static void main(String[] args) {
        int a = 10, b = 20;
        System.out.println(a == b); // false
        System.out.println(a != b); // true
        System.out.println(a > b); // false
        System.out.println(a < b); // true
        System.out.println(a >= b); // false
        System.out.println(a <= b); // true
    }
}

3.3 逻辑运算符

逻辑运算符：判断关系表达式的运算符

包含：短路与(&&) 、短路或(||) 、逻辑与(&) 、逻辑或(|) 、逻辑非(!)

public class Test{
    public static void main(String[] args) {
        int a = 10;
        int b = 4;
        // 短路或: 一个成立，后面的不运行了
        if (a > 0 || (b++) > 4){                    
            System.out.println("a > 0 | (b++) > 4");
            // 判断后面的b++是否被执行
            System.out.println(b);    
        }
        //逻辑或: 所有的都运行
        if (a > 0 | (b++) > 4){
            System.out.println("a > 0 | (b++) > 4后b的值为：");
            // 判断后面的b++是否被执行
            System.out.println(b);
        }
        /*
         *	a > 0 | (b++) > 4后b的值为：
         *	4
         *
         *	a > 0 | (b++) > 4后b的值为：
         *	5
         *
         *	a > 0成立时 | 后面的也执行了,而 || 就没有执行
         */
        
        //短路与: 一个成立，后面的不运行了
        if (a > 100 && (b++) <5){
            System.out.println("a < 100 && (b++) <5后b的值为：");
            // 判断后面的b++是否被执行
        	System.out.println(b);
        }
        //逻辑与: 所有的都运行
        if (a > 100 & (b++) <5){
            System.out.println("a < 100 & (b++) <5后b的值为：");
            // 判断后面的b++是否被执行
        	System.out.println(b);
        }
        
        /*
         *	a < 100 && (b++) <5后b的值为：
         *	4
         *
         *	a < 100 && (b++) <5后b的值为：
         *	5
         *
         *	a > 100条件不成立 & 后面的也执行了,而 && 就没有执行
         */
        
        boolean bool = false;
        System.out.println(!bool); // 变为true
        System.out.println(!!bool); // 又变回false

    }
}

3.4 位运算符

位运算符：将整数转换为二进制之后进行位运算，得到的结果转换回来

包含：与(&) 、或(|) 、非(!) 、异或(^) 、左移(<<) 、右移(>>) 、无符号右移(>>>)

/**
 *
 *	与(&): 同1为1
 *	或(|): 同0为0
 *	非(!): 相异为1
 *	异或(^): 按位取反 (正数变负数，负数变正数)
 *		1.满足交换律: a ^ b = b ^ a
 *		2.a ^ a = 0 因为两个相同的数字，换算成补码后，每个二进制位上的数也都相同
 *		3.0 ^ a = a
 *		4.(a ^ -1) + 1 = a的相反数 --> 用于求一个数的绝对值
 *		5.1 ^ a 的结果是: a的二进制位上的数字按位取反
 *
 */
public class Test {
    public static void main(String[] args) {
        // Integer.toBinaryString() 将某一个整数类型转换为其对应的二进制
        int a = 60; // 0000 0000 0011 1100
        int b = 13; // 0000 0000 0000 1101
        int c = a & b; // 0000 0000 0000 1100 --> 12 
        c = a | b; // 0000 0000 0011 1101 --> 61 
        c = a ^ b; // 0000 0000 0011 0001 --> 49 
        c = ~a; // 1111 1111 1100 0011 --> -195
        
        // HashMap 在计算哈希值
        static final int hash(Object key) {
            int h;
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        }
        
        // 对于一个整数n的补码,每进行一次 n & (n - 1) 运算，会消去最右边的1
        // 用于计算该数中的1的个数
        int count = 0;
        while(n != 0){
             count++;
             n = n & (n - 1);
         }
        System.out.println( "该数二进制表示形式(补码)中，包含的1个数为：" + count);
    }
}

/**
 *
 *	左移(<<): 左移时,空出的位置补0,不管正负数
 *	右移(>>): 右移时,空出的位置补符号位(0为正，1为负)
 *	无符号右移(>>>): 无符号右移时,不管正负数都是用0填充
 *	注意: 
 *		1.右移的值为负数时, 除以2的N次方的结果之上还要减去1
 *		2.对于任何一个byte、short或者int类型的数据而言，带符号右移31位之后，得到的必然是0或者是-1
 *			如果是正数,带符号右移31位之后产生的二进制串必然全部是0,转换成对应的十进制数就是0
 *			对于负数而言,带符号右移31位之后产生的二进制串必然全部是1,转换成十进制数就是-1
 *		3.对于long类型的数据而言，带符号右移63位之后，得到的也必然是0或者是-1
 *		4.通过右移所得到的结果是0还是-1，判断出这个数是正数还是负数
 *
 */

public class Test {
    public static void main(String[] args) {
        // 左移
        System.out.println(10 << 2); // 10 << 2 --> 10 * 2^2 --> 10 * 4 --> 40  
        System.out.println(10 << 3); // 10 << 3 --> 10 * 2^3 --> 10 * 8 --> 80  
        
        // 右移
        System.out.println(10 >> 2); // 10 >> 2 --> 10 / 2^2 --> 10 / 4 --> 2
        System.out.println(20 >> 2); // 20 >> 2 --> 20 / 2^2 --> 20 / 4 --> 5
        
        // 判断整型为正数还是负数
        int flag = n >> 31;
        if (flag == 0) {
            System.out.println("该数为正数");
        } else {
             System.out.println("该数是负数");
        }
    }
}

3.5 赋值运算符

赋值运算符：把操作符右侧的值赋值给左侧的变量

包含：赋值(=) 、加等于(+=) 、减等于(-=) 、乘等于(*=) 、除等于(/=) 、模等于(%=)

/**
 *
 *	赋值(=) a = 5;
 *	加等于(+=) a += 5; --> a = a + 5;
 *	减等于(-=) a -= 5; --> a = a - 5;
 *	乘等于(*=) a *= 5; --> a = a * 5;
 *	除等于(/=) a /= 5; --> a = a / 5;
 *	模等于(%=)	a %= 5; --> a = a % 5;
 *	注意: 赋值运算符在使用时要注意前后的数据类型
 */

3.6 三元运算符

三元运算符：替代 if-else的一行代码，完成条件判断的要求

public class Test {
    public static void main(String[] args) {
        int a = 2;
        int b = 5;
        // 如果 ? 前面的条件为 true，则结果为 : 前的值，否则为 : 后的值
        int min = (a < b) ? a : b;
        System.out.println(min);
    }
}

有任何错误请指正，谢谢您的阅读，希望对您有所帮助。