Java各种运算符详解，计算机对进制的计算

前言❤️❤️

hello hello💕，这里是洋不写bug~😄，欢迎大家点赞👍👍，关注😍😍，收藏🌹🌹
这篇文章中介绍了Java各种运算符的用法以及进制的转换，大部分内容在C语言中是学过的，这篇文章会对代码的逻辑进行解析，并对知识点进行常见知识点进行总结，帮助大家快速入门Java💪

🎇个人主页：洋不写bug的博客
🎇所属专栏：Java学习之旅，从入门到进阶
🎇铁汁们对于Java的各种常用核心语法（不太常用的也有😆），都可以在上面的Java专栏学习，专栏正在持续更新中🐵🐵，有问题可以写在评论区或者私信我哦~

1，算术运算符

1，基础规则

+ - * /
这些都是二元运算符，使用时必须左右要有两个操作数，下面这段代码就用了这4个二元运算符：

public class Test1 {
    public static void main(String[] args) {
      int a = 10;
      int b = 5;
      System.out.println(a + b);
      System.out.println(a * b);
      System.out.println(a / b);
      System.out.println(a % b);
    }
}

在进行除法和求余运算时，右边的数不能为0，否则就会报错。

public class Test1 {
    public static void main(String[] args) {
      int a = 10;
      int b = 0;
      System.out.println(a / b);
    }
}

报错信息是by zero,表示这里不能是0。（求余运算也是这样，右边的为0也会报错）
注意，这里的Exception表示异常，这是C语言没有的概念，在C语言中遇到了类似的情况一般是程序直接崩溃，Java 中的 Exception 本质上是程序运行时出现的错误或意外情况

下面的这种就是编译出错，println写错了，写成printn了，而报错界面可以看出跟刚才是不一样的，这个是在编译器检查代码时就发现出错了，压根就没有运行：

public class Test1 {
    public static void main(String[] args) {
      int a = 10;
      int b = 0;
      System.out.printn(a / b);
    }
}

还有下面一个例子，恰好可以印证前面的double不能精确表示,执行后显示的单词Infinty的意思是无限，这里double不能准确表示0,而是0.0000000000001（这里0有很多位），因此用10去除以一个无限接近于0的小数，就是无限：

public class Test1 {
    public static void main(String[] args) {
      int a = 10;
      double b = 0;
      System.out.println(a / b);
    }
}

注：%不仅可以对整形取模，还可以对double类型取模，但是没有意义，所以一般还是对整型取模。而C语言的%则不能针对小数类型取模。

2，自增自减

这里的打印结果是11

public class Test1 {
    public static void main(String[] args) {
      int a = 10;
      a++;
      System.out.println(a);
    }
}

而这段代码，打印的结果就是10，因为++在后面，先打印，再自增。

public class Test1 {
    public static void main(String[] args) {
      int a = 10;
      System.out.println(a++);
    }
}

这段代码最后打印出的结果就是10，如果把a++替换成++a，打印结果就变成了11

public class Test1 {
    public static void main(String[] args) {
      int a = 10;
      int b = a++;
      System.out.println(b);
    }
}

• 后置++打印的b的结果是10，说明后置++表达式的返回值是10（自增之前的值）
• 而前置++打印的b的结果是11，结果就是11,说明前置++表达式的返回值是11（自增之后的值）

• 
  
  

  总结：

  1. 如果单独使用的话，前置++和后置++几乎没有什么区别。
  2. 如果混合使用，前置++先加1，然后使用变量加1后的值，后置++，先使用变量原来的值，表达式结束时给变量加1。
  3. 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改。

  3，+=和-=

  下面这个代码的打印结果是13

  public class Test1 {
      public static void main(String[] args) {
        int a = 10;
        a += 3;
        System.out.println(a);
      }
  }
  

  
  
  

  注：+=和 -=都不能用于常量

  

  2，关系运算符(> < == !=)

  注：在Java中关系运算符的计算结果，一定是boolean类型的值（true,false）

  public class Test1 {
      public static void main(String[] args) {
        int a = 20;
        int b = 10;
        System.out.println(a > b);
      }
  }
  

  

  boolean类型是不能比大小的,这里先计算前面的a > b，算出来是一个true，true是没法跟数字比较大小的

  

  3，逻辑运算符(&& || !)

  1，简介

  结果和操作数都是boolean类型，不能为其他类型，这点跟C语言中的区别还是比较大的，在C语言中是看0和非0来计算的。而在Java中就没有这一说，这点一定要区分好！！！

• &&，与运算符，左右表达式，都是true，结果才是true，只要左右有一个false,算出来的结果就是false。
• ||，或运算符来说，当左右表达式都为false，结果才是false，有一个是true，结果就是true.
• ！非运算符，只有一个操作数。

• 
  
  
  

  注：正常编写的程序，结果可能是false,也可能是true,如果恒定是false或者true的话，那这里再写这个程序可能就意义不大，这时IDEA就会检测出来，给出警告（下面是黄色波浪线，来提醒检查一下这里是不是写错了）

  

  2，优先级问题

  !的优先级是比大于号和小于号要高的，因此这里要加上一个括号，不加括号就是!a > b,在数字前加上！，就会报错，这里加上括号，就可以避免这个，其实也没必要把所有的运算符优先级都给记住，写的时候尽量都加上括号，这样看着也清楚，也容易判断。

  public class Test1 {
      public static void main(String[] args) {
        int a = 20;
        int b = 10;
        System.out.println(!(a > b));
      }
  }
  

  3，短路求值

• 计算&&，只要左侧为false,结果就一定是false,右侧表达式就可以不看了。
• 同理，计算||，只要左侧为true，结果就一定是true，右侧的表达式就可以不看了。

• 这段代码两个判断都是短路求值

  public class Test1 {
      public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a > b && 10 / 0 == 0);
        System.out.println(a < b || 10 / 0 == 0);
      }
  }
  

  4，位运算符（<< >> & | ~）

  位运算符是针对数据的二进制位来进行计算的

  1，十进制，二进制，十六进制的相互转化

  如果有个int类型的变量a，值为10，下面是这个变量转为二进制的计算过程：

  一直除以2，看其余数。
  10 / 2 = 5 ，余 0 ④
  5 / 2 = 2，余 1 ③
  2 / 2 = 1，余 0 ②
  1 / 2 = 0，余 1 ①

  注：二进制按余数来写，是从下往上下的，上面写的用圆圈的序号就是写二进制的顺序，因此，转为二进制就是1010
  在编程时，二进制不方便人阅读，因此更习惯用“十六进制”来表示二进制，4个二进制比特位正好对应一个十六进制的数字。

  
  
  

  十六进制是这样表示的，最多能表示到十进制15，二进制为1111
  十六进制的表示：0-9 ABCDEF（这里的字母大小写其实都可以）
  另外，十六进制表示前加上"0x"

  2，按位与（&），按位或（|），按位取反操作（~）

  这里就是用十六进制来表示，变量b指的是十进制11，变量b指的是十进制11,进行按位与操作
  这里的%x指的就是以十六进制的形式输出，这里的0x指的是打印的格式，这里的printf语句跟C语言的语法的相同的，而println，也就是我们输入sout后补全的，是Java中特有的，还自动加了一个换行符。

  public class Test1 {
      public static void main(String[] args) {
        int a = 0xa;
        int b = 0xc;
        System.out.printf("0x%x\n",a & b);
      }
  }
  

  

  计算逻辑：
  先将十六进制转为十进制，再将十进制转为二进制。
  变量a (十进制为10) => 1010(二进制)
  变量b(十进制为12） => 1100(二进制)
  
  
  按位与(&)：两个数都是1，结果是1，否则就是0
  a&b二进制就是1000，十进制是8，十六进制就是0x8

  
  
  
  

  按位或(|)：只有两个二进制位都是0，结果才是0，否则就是1，跟按位与的原理基本上相同，示例如下：

  public class Test1 {
      public static void main(String[] args) {
        int a = 0xa;
        int b = 0xc;
        System.out.printf("0x%x\n",a & b);
        System.out.printf("0x%x\n",a | b);
        System.out.printf("0x%x\n",~a);
      }
  }
  

  

  1010 => 变量a (十进制为10)
  1100 => 变量b（十进制为12）
  按位或来看，就是1110，二进制12，十六进制就是0xe;

  按位取反（~）：把二进制位的1转为0，0转为1。
  变量a的二进制是1010，int四个字节，32个比特位，取反的话就要把32位都写出来
  00000000 00000000 00000000 00001010
  取反后就成了这样：1111 1111 1111 1111 1111 1111 1111 0101
  按照4位一组进行拆分，每四位转为一个十六进制位，就是0xfffffff5

  3，左移位运算

  10的二进制位就是1010，左移一位在右面补上一个0，这时候二进制位就变成了10100，把这个二进制位再转为十进制位，就是20

  public class Test1 {
      public static void main(String[] args) {
        int a = 10;
        System.out.println(a << 1);
      }
  }
  

  

  
  
  
  

  接着可以左移两位，左移三位看一下：

  public class Test1 {
      public static void main(String[] args) {
        int a = 10;
        System.out.println(a << 1);
        System.out.println(a << 2);
        System.out.println(a << 3);
      }
  }
  

  
  原来是 0000 1010（10）

• 左移一位变成了0001 0100（20）
• 左移两位变成了0010 1000（40）
• 左移三位变成了0101 0000（80）

• 总结：左移N位，相当于乘以 2^N，也就是左移多少位，二进制后边补多少个零

  注意事项：

  1. 不要 << 超过32位这样的内容（因为int的比特位就是32位，左移超过32位，数据溢出，就没有意义了）
  2. 不要 << 负数个位，也没有什么意义

  4，右移位运算

  我们在学习C语言时已经知道，二进制的左侧最高位为符号位，正数符号位为0，负数的符号位为1，举例（因为int是32比特位，非常长，最左边的4个，和最右边的4个比特位，以便于大家的观看）：
  +5：0000 0101
  -5：1000 0101

  刚刚的算术左移就是把二进制位左移，右边补零
  而算术右移就是把二进制向右移，在左边补数，但左边是符号位，因此就不是直接补零那么简单，规则就是在左侧的最高位补充 符号位（当前最高位为0，正数，补0；最高位为1，负数，补1）

  public class Test1 {
      public static void main(String[] args) {
        int a = 10;
        System.out.println(a >> 1);
        System.out.println(a >> 2);
        System.out.println(a >> 3);
      }
  }
  

  
  原来是1010，
  右移一位，变成 101（5）
  右移两位，变成 10 （2）
  右移三位，变成 1 （1）

  因此，我们可以得出，右移一位，相当于除以2（向下取整）

  
  
  
  

  负数也是如此

  public class Test1 {
      public static void main(String[] args) {
        int a = -10;
        System.out.println(a >> 1);
        System.out.println(a >> 2);
        System.out.println(a >> 3);
      }
  }
  

  

  注：这里没必要一步一步算，搞清楚逻辑和原理，规律就行了

  
  
  

  补充：

  关于运算符的优先级，其实没有必要去刻意的记忆那些优先级的顺序，在写复杂的式子时，只需加上括号就行，这样看代码的人也能够特别清楚

  5，条件运算符(? : )

  这个在C语言阶段已经学习过了
  表达式1 ? 表达式2 : 表达式3
  如果表达式的结果为true，那么整个表达式的结果就是表达式2的值
  如果表达式的结果为false,那么整个表达式的结果就是表达式1的值

  public class Test1 {
      public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a < b ? a : b);
      }
  }
  

  

  6，计算器计算进制(win11系统)

  打开这里的选项，选择程序员，点击，就进入了不同的进制相互换算界面

  英文补充：

• BIN(Binary) 二进制
• OCT(Octal) 八进制
• DEC(Decimal) 十进制
• HEX(Hexadecimal) 十六进制

• 

  

  结语💕💕

  位运算符的知识比较细，比较多，特别是运算符，一些铁汁可能在学习C语言的时候并没有完全掌握；但是没关系🐵👌，在学习JavaSE时，首先就是语法进行复习，同时以前掌握的不太牢固的部分再学习一下，这部分很容易补上来。🥳🥳大家都学废了吗？完结撒花~ 🎉🎉🎉