Java学习：运算符-EW帮帮网

可以运算的符号。常见的比如算数运算符、赋值运算符等等。

7.1 运算符基本概念

7.2 赋值运算符

= 注意一个等号是赋值。

int num = 10; // 唯一注意的是：赋值运算符是自右向左进行运算的  优先级最低

7.3 算数运算符

在整个Java中用来进行算数运算的。常见的运算的符号： + - * / % ++ --

/**
 * 算数运算符
 */
public class OperatorTest01 {
    public static void main(String[] args) {

        //1： 测试使用+号
        int num = +5; // 正数
        System.out.println(num);


        num = 4+4; // 加法
        System.out.println(num);

        // "" 原样输出  "hehe"=>String字符串   123=>int
        System.out.println("num的值是："+num); // 连接符号
        /**
         *  ------->
         * 1+"+"+1+"="+1+1
         * "1+"+1+"="+1+1
         * "1+1" +"="+1+1
         * "1+1="+1+1
         * "1+1=1" +1
         * "1+1=11"
         */
        System.out.println(1+"+"+1+"="+(1+1));

        // 测试使用-号
        num = -5; //负号

        num = 10-3; // -法运算

        // 测试取余
        System.out.println("10%3 = "+ (10%3));

        System.out.println("====================================================");

        /**
         *  ++ 和 --:
         *  1:都是单目运算符
         *  2:如果++ 和 -- 是单独一条语句的时候 前加  前减和后加 后减效果是一样的 都是自增1或者是自减1
         */
        int i = 10;
        --i; // 单目
        System.out.println("执行完++之后的结果："+i);


        int j = 5; //声明变量

        int res = j--; // 将后加的结果赋值给res变量

        // 查看j的结果和res的结果
        System.out.println("j:"+j + "==== res:"+res);


        int n = 6;
        int m = 12;

        res = n++ - ++m + --m + --n - m--;
        System.out.println("res:"+res+"，n:"+n+"，m="+m);

    }
}

+号：链接符号，当加号左右两边存在字符串的时候，此时加号表达的是连接符号的作用，会将左右两边的操作数组成一个新的字符串，继续运算。

++和--：

1>、如果它们是单独一条语句的时候，前加前减和后加后减效果是一样的，都是自增1或者是自减1；

2>、如果不是单独一条语句：

a：前加、前减先自增、自减然后运算

b: 后加、后减先运算，然后自增、自减

7.4 扩展运算符

算数运算符+赋值运算符或者是位运算符+赋值运算符

/**
 * 测试扩展运算符
 */
public class OperatorTest02 {
    public static void main(String[] args) {

        //1： 声明两个变量 计算两个变量之和
        int zhangScore = 10;
        int liScore = 20;


        int sum = 0;

        sum += zhangScore; //  <=> sum = sum+zhangScore;
        sum = sum+liScore;

        System.out.println(sum);


        // 声明一个int类型的变量
        int n = 10;
        byte m = 0;


        m += n;

        System.out.println(m);


    }
}

优势：

1>、编译效率高

2>、提升程序开发效率

3>、自动强制类型转换

劣势：

1>、阅读体验差

7.5 关系运算符

/**
 *  relation
 */
public class OperatorTest03 {
    public static void main(String[] args) {

        // 关系运算符 > < >= <= == != instanceof

        // > < >= <= 不能作用在boolean类型和引用类型上的
        System.out.println(4>5);
        System.out.println(5>=5);

        System.out.println('A' > 'B');

        //System.out.println(true > false);
        // System.out.println("abc" > "bcd");

        // == !=
        System.out.println(4==5);
        System.out.println(5!=5);
        System.out.println(true != false);

        System.out.println("abc" == "bcd");


        // instanceof 只能比较引用类型
        System.out.println("abcd" instanceof String);

    }
}

1：关系运算符得到的结果是boolean类型的值；

2：> < >= <= 只能比较基本数据类型中除了boolean以外的类型

3：== != 可以比较基本数据类型和引用类型

4: instanceof 只能比较引用类型判定某个值是否从属于某个引用类型

7.6 逻辑运算符

逻辑运算符左右两边的操作数都是boolean的值。

/**
 * 测试逻辑运算符
 *   & |  ^  即时逻辑运算符 也是位运算符。
 */
public class OperatorTest04 {
    public static void main(String[] args) {


        System.out.println("======逻辑与 & 且=======");
        System.out.println(true & true);
        System.out.println(true & false);
        System.out.println(false & true);
        System.out.println(false & false);

        System.out.println("======逻辑短路与 && 且=======");
        System.out.println(true && true);
        System.out.println(true && false);
        System.out.println(false && true);
        System.out.println(false && false);




        System.out.println("======逻辑或 |=======");
        System.out.println(true | true);
        System.out.println(true | false);
        System.out.println(false | true);
        System.out.println(false | false);

        System.out.println("======逻辑或 ||=======");
        System.out.println(true || true);
        System.out.println(true || false);
        System.out.println(false || true);
        System.out.println(false || false);


        System.out.println("======逻辑^=======");

        System.out.println(true ^ true);
        System.out.println(true ^ false);
        System.out.println(false ^ true);
        System.out.println(false ^ false); // 相同为fasle 不同为true


        System.out.println("======逻辑!=======");
        System.out.println(!true);
        System.out.println(!false);

    }
}

1: &和&& |和||的区别和联系?

逻辑&：左右变量操作的都为true，其结果为true，其余都是fasle。所以&&发现第一个操作数是fasle的情况下，后面一个操作数就不计算了，直接返回false。

逻辑|：左右变量操作数有一个是true，其结果为true，其余都是fasle。所以||发现第一个操作数是true的情况下，后面一个操作数就不计算了，直接返回true。

7.7 条件运算符

唯一的一个三目运算符。存在三个操作数

格式：表达式1 ? 表达式2 : 表达式3

计算过程：计算表达式1的值，如果表达式1的值是true ，则整个条件运算符的结果是表达式2的值，反之则是表达式3的值。

/**
 * 条件运算符
 */
public class Operator05 {
    public static void main(String[] args) {

        // 生成一个随机数 判定当前该数字的奇偶性

        double rand = Math.random(); //[0,1)
        System.out.println(rand);


        // 需要产生一个随机的整数 [min,max](int)(Math.random()*(max-min+1))+min)
        // [5,10]
        int num = (int)(Math.random()*6+5); // [0,10)+1 = [1,11)
        System.out.println(num);


        String msg = num%2 == 0 ? "偶数":"奇数"; // int n = 10;
        System.out.println(msg);



        // 判定两个随机数的大小
        int n = (int)(Math.random()*6+5);
        int m = (int)(Math.random()*6+5);


        int max = n>=m?n:m;

        System.out.println("n和m中的最大值是："+max);


        // 判定三个数的最大值
        int k = (int)(Math.random()*6+5);

        System.out.println(n+"===="+m+"===="+k);

        // max = max>=k?max:k;
        System.out.println("n和m以及k中的最大值是：" + ((n>=m?n:m)>=k?(n>=m?n:m):k));

    }
}

7.8 位运算符

算数的。数值计算中位运算符是特别好用的，因为它是直接基于二进制计算的，所以效率高。

/**
 * 位运算符
 */
public class OperatorTest06 {
    public static void main(String[] args) {

        // 按位&
        /*
        *     0 0 011
        *     0 0 100
        * --------------
        *     0 0 000
        *
        * */
        System.out.println(3&4);

        // 按位|
        /*
         *     0 0 011
         *     0 0 100
         * --------------
         *     0 0 111
         *
         * */
        System.out.println(3|4);




        // 按位^
        /*
         *     0 0 011
         *     0 0 100
         * --------------
         *     0 0 111
         *
         * */
        System.out.println(3^4);


        // 取反 !  符号位也会参与运算的
        System.out.println(~6);


        // >> 右移  8/4 = 8/2^2   M>>N = M/2^N
        // 右移是将 M这个数字的右侧N省略，左侧使用符号位填充补满位数
        /**
         *    0000 10   00
         * 00 0000 10
         *
         *    1000 1000 原码
         *    1111 0111 反码
         *    1111 1000 补码  -8>>2
         *
         *   11111110  补码
         *   11111101  反码
         *   10000010  原码  -2
         *
         */
        System.out.println(8>>2 );
        System.out.println(-8>>2 );


        //左移  2*16 = 2*2^4  M<<N = M*2^N
        //左移将M这个数字的左侧的N位省略掉，右侧使用0填充N位
        /**
         *    0000 0010
         *         0010 0000 -> 32
         *
         *    1000 0010     -2原码
         *    1111 1101     -2反码
         *    1111 1110     -2补码
         *
         *         1110 1111
         *
         *         1110 0000  补码
         *         1101 1111  反码
         *         1010 0000  原码 -32
         */
        System.out.println(2<<4);
        System.out.println(-2<<4);

        // 无符号右移 不管当前数字是多少 都是右移N位的时候 使用0填充左侧的值
        System.out.println(16>>>2);
        System.out.println(-16>>>2);



    }
}

位运算的实际使用场景

public class OperatorTest07 {
    public static void main(String[] args) {

        //1： 面试题1：  如何快速计算 2^3
        System.out.println(2*2*2);
        System.out.println(2<<2);


        //2: 如何判定当前数值的奇偶性
        System.out.println((8&1) == 0);


        //3：异或  调换两个变量的值
        int n = 10;
        int m = 20;

        int temp = 0;
        temp = n;
        n = m;
        m = temp;
        System.out.println("n:"+n+"m:"+m);

        // 使用异或
        n = n^m;
        m = n^m; // n^m^m 20^10^10
        n = n^m; //  n^m ^ n^m^m
        System.out.println("n:"+n+"m:"+m);


        // (min+max)/2
        
    }
}

7.10 运算符优先级

图片来源于：【Java基础系列】第2章数据类型和运算符（3）___Yvan的博客-CSDN博客

优先级：

1>、永远不要试图通过优先级去确定代码的执行顺序；

2>、单目运算符>双目运算符>三目运算符 >赋值运算符

3>、拿不准的括号，括号YYDS

4>、算数>关系>位>逻辑>条件>赋值

本文含有隐藏内容，请开通VIP 后查看

Java学习：运算符

7.1 运算符基本概念

7.2 赋值运算符

7.3 算数运算符

7.4 扩展运算符

7.5 关系运算符

7.6 逻辑运算符

7.7 条件运算符

7.8 位运算符

7.10 运算符优先级

网站公告

今日签到

热门文章

最新发布