第五章: 梳理Java 中各种运算符(Operator)的使用

于 2024-06-05 07:23:52 发布
阅读量1.3k 收藏 9
点赞数 34
分类专栏： Java 基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fjiex/article/details/139457835
版权

1. 运算符的分类:

运算符是一种特殊的符号, 用以表示数据的运算,赋值和比较

运算符按照功能可以分为:

  1. 算术运算符
  2. 比较(关系)运算符
  3. 逻辑运算符
  4. 赋值运算符
  5. 位运算符
  6. 三元运算符
  7. Lambda运算符(以后再说)
分类运算符
算术运算符(7个)+ , - , * , / , % , ++ , –
赋值运算符(12个)=, +=, -=, *=, /=, %=, >>=, <<=, >>>=, &= , !=, ^=等
比较(关系)运算符(6个)>, >= , <, <=, ==, !=
逻辑运算符(6个)&, |, ^, !, &&, ||
位运算符(7个)&, |, ^, ~, <<, >>, >>>
三元运算符(1个)(条件表达式)? 结果1 : 结果2
Lambda运算符(1个)

运算符如果按照操作数个数分类,又可分为:

  1. 一元运算符(单目运算符)
  2. 二元运算符(双目运算符)
  3. 三元运算符(三目运算符)
分类运算符
一元运算符(单目运算符)正号+, 符号-, ++, --, !, ~
二元运算符(双目运算符)除了一元和三元剩下的都是二元运算符
三元运算符(三目运算符)(条件表达式)? 结果1: 结果2

2. 算术运算符

2.1 算术运算符基本使用

运算符

运算符运算范例结果
+正号+33
-负号-3-3
+加号5 + 38
-减号5 - 32
*乘号5 * 315
/除号(保留整数)5 / 31
%取模(取余,保留余数)5 % 32
++前自增: 先自增后取值
后自增: 先取值后自增		a=2; b=++a;
a=2; b=a++		a=3;b=3;
a=3;b=2
–前自减: 先自减后取值
后自减: 先取值后自减		a=2; b=–a;
a=2; b=a–		a=1;b=1;
a=1;b=2
+字符串拼接“hel” + “lo”“hello”

示例:

public class Example {
    public static void main(String[] args){
        // 算数运算符
        // + 正 - 负 + 加 - 减 * 乘 / 除 % 取模 ++ 自增 -- 自减 + 字符拼接


        // 1. 加
        int i1 = 12;
        int i2 = 5;
        int i3 = i1 + i2;
        System.out.println(i3); // 17

        // 2. 减
        int i4 = i1 - i2;
        System.out.println(i4); // 7


        // 3. 乘
        int i5 = i1 * i2;
        System.out.println(i5); // 60

        // 4. 除(保留整数部分)
        int i6 = i1 / i2;
        System.out.println(i6); // 2


        // 4.取模(保留余数部分)
        int i7 = i1 % i2;
        System.out.println(i7); // 2

        // 注意: 负数取模后, 结果的符号与模数的符号一致
        int i8 = -12;
        int i9 = 5;
        System.out.println(i8 % i9); // -2

        int i10 = 12;
        int i11 = -5;
        System.out.println(i10 % i11); // 2

        int i12 = -12;
        int i13 = -5;
        System.out.println(i12 % i13); // -2



        // 5. ++ 自增
        // 前自增
        int i14 = 12;
        int i15 = ++i14;  // i14 会先自增1 为13, 再将13 赋值给i15
        System.out.println("i14="+i14+";i15="+i15); // i14=13;i15=13

        // 后自增
        int i16 = 12;
        int i17 = i16++;  // i16 会先取值赋值给i17, 再自增为13
        System.out.println("i16="+i16+";i17="+i17);  // i16=13;i17=12


        // 注意: 自增与 +1 区别
        // +1 是当前类型值加上一个int类型值1
        short s1 = 15;
        // 编译不通过: 因为1是int类型, 相加后不能赋值给s1, 因为s1是short类型
	   // s1 = s1 + 1;

        // 可以使用强类型转行
        s1 = (short)(s1 +1);
        System.out.println(s1);  // 16

        // 自增不会改变原有类型
        s1++;
        System.out.println(s1);  // 17
    }
}

2.2 算术运算符使用细节

算术运算符使用细节:

  1. 如果有负数参与取模, 结果的符合和被模数保持一致.
  2. 取模运算的结果不一定总是整数, 如果有小数参与取模, 结果可能是小数
  3. 对于除号/ , 整数和小数除是有区别的, 整数除的结果只保留整数部分, 小数除才会保留小数部分

示例:

// 整数取模,结果的符号与被模数符号保持一致
System.out.println( 8 % 5 );  // 3
System.out.println( 8 % -5 );  // 3
System.out.println( -8 % 5 );  // -3
System.out.println( -8 % -5 );  // -3


// 取模的如果有小数参数, 结果是小数
System.out.println( 8 %  3.1 );  // 1.7999999999999998


// 整数除与小数除
System.out.println( 8 / 3 );  // 2   只保留整数
System.out.println( 8.0 / 3 );  // 2.66666.  有小数参数的除, 保留小数部分
System.out.println( 8 / 3.0 );  // 2.66666.  有小数参数的除, 保留小数部分

练习题:

随意给出一个三位数，打印显示它的个位数，十位数，百位数的值

public class Example {
    public static void main(String[] args){
        // 输出一个3位数的个位,十位,百位的值,例如153
        int num = 153;

        int ge = num % 10; // 个位
        int shi = num / 10 % 10; // 十位, 或者 num % 100 / 10
        int bai = num / 100;

        System.out.println("个位数是:"+ge);  // 个位数是:3
        System.out.println("十位数是: "+shi); // 十位数是: 5
        System.out.println("百位数是:"+bai); // 百位数是:1
    }
}

3. 比较(关系)运算符

运算符

运算符运算范例结果
==相等4 == 3false
!=不等于4 != 3true
<小于4 < 3false
>大于4 > 3true
<=小于等于4 <= 3false
>=大于等于4 >= 3true
instanceof检查是否是类的对象“hello” instanceof Stringtrue

比较运算符细节

  1. 比较运算符是用来比较不两侧的值, 因此结果是boolean 类型的值, ture 或false
  2. >, <, >=, <= 只适用于基本数据类型(boolean类型除外)
  3. ==, != 适用于基本数据类型和引用数据类型
  4. 比较运算符== 不能误写为=, =是赋值运算符

示例:

public class Example {
    public static void main(String[] args){
        // 比较(关系)运算符
        int num1 = 10;
        int num2 = 20;

        boolean b1 = num1 > num2;
        System.out.println(b1);  // false ,比较num 是否大于 num2

        System.out.println(num1 == num2); // false ,  判断num1 是否等于 num2
    }
}

4. 逻辑运算符

4.1 基本使用

运算符

aba | ba || ba & ba && b!aa ^ b
truetruetruetruetruetruefalsefalse
truefalsefalsefalsetruetruefalsetrue
falsetruefalsefalsetruetruetruetrue
falsefalsefalsefalsefalsefalsetruefalse

逻辑运算符, 操作的都是boolean 类型的变量或常量, 而且运算的结果也是boolean 类型的值

运算符说明:

  • & 和 && : 表示逻辑"与"的关系, 当符号两边的布尔值都是true时,结果才为true, 否则为false
  • | 和 || : 表示逻辑 "或" 关系, 当符号两边的布尔值都是false时,结果才为false, 否则为true
  • ! : 表示逻辑"非"关系, 当操作布尔值类型为true是, 取反结果为false, 操作数为false时,结果为true
  • ^ : 表示"异或", 即操作数布尔类型是否不相同, 当左右两边布尔值不同时,结果true, 相同时,结果为false,

基本使用:

public class Example {
    public static void main(String[] args){
       boolean b1 = true;
       boolean b2 = false;

       if(b1 && b2){
           System.out.println("条件判断为true");
       }else{
           System.out.println("条件判断为false"); // 输出false
       }

    }
}

4.2 两种运算符的区别

"&" 和 "&&"的区别

  • 相同点: 如果运算符左边操作数类型是 true , 则二者都执行 符号右侧的操作

  • 不同点:
    &: 如果左边是false, 则继续执行右边的操作

    && : 如果左边是false, 则不在执行右边的操作, 具有短路效果

  • 建议: 开发中推荐使用 &&


示例:

public class Example {
    public static void main(String[] args){
        // 1. 相同点: &, && 左边为true, 都会执行右边, 输出结果相同
       boolean b1 = true;
       int num1 = 10;

       if(b1 & (num1++ > 0)){
           System.out.println("条件判断为true");
       }else{
           System.out.println("条件判断为false");
       }
        System.out.println("num1 = " + num1);

       /*
            条件判断为true
            num1 = 11
        */

        boolean b2 = true;
        int num2 = 10;

        if(b2 && (num2++ > 0)){
            System.out.println("条件判断为true");
        }else{
            System.out.println("条件判断为false");
        }
        System.out.println("num2 = " + num2);

        /*
            条件判断为true
            num2 = 11
        */


        // 2. 不同点
        // 2.1 &  左侧为false, 已经能决定表达式的结果了, 但是还是会执行右边
        boolean b3 = false;
        int num3 = 10;

        if(b1 & (num3++ > 0)){
            System.out.println("条件判断为true");
        }else{
            System.out.println("条件判断为false");
        }
        System.out.println("num3 = " + num3);

       /*
            条件判断为false
            num3 = 11
        */

        // 2.2 &&  左侧为false, 已经能决定表达式的结果了, 就不会执行右边了, 短路
        boolean b4 = false;
        int num4 = 10;

        if(b4 && (num4++ > 0)){
            System.out.println("条件判断为true");
        }else{
            System.out.println("条件判断为false");
        }
        System.out.println("num4 = " + num4);

        /*
            条件判断为false
            num4 = 10   // num4 没有执行++
        */

    }
}

"|" 和 "||" 的区别

  • 相同点: 如果运算符左边操作数类型是 false, 则二者都执行 符号右侧的操作

  • 不同点:
    | : 如果左边是true, 则继续执行右边的操作

     `||`: 如果左边是true, 则不在执行右边的操作, 具有短路效果

  • 建议: 开发中推荐使用 ||


示例:

public class Example {
    public static void main(String[] args){
        // 1. 相同点: |, || 左边为false, 都会执行右边, 输出结果相同
       boolean b1 = false;
       int num1 = 10;

       if(b1 | (num1++ > 0)){
           System.out.println("条件判断为true");
       }else{
           System.out.println("条件判断为false");
       }
        System.out.println("num1 = " + num1);

       /*
            条件判断为true
            num1 = 11
        */

        boolean b2 = false;
        int num2 = 10;

        if(b2 || (num2++ > 0)){
            System.out.println("条件判断为true");
        }else{
            System.out.println("条件判断为false");
        }
        System.out.println("num2 = " + num2);

        /*
            条件判断为true
            num1 = 11
        */


        // 2. 不同点
        // 2.1 |  左侧为true, 已经能决定表达式的结果了, 但是还是会执行右边
        boolean b3 = true;
        int num3 = 10;

        if(b1 | (num3++ > 0)){
            System.out.println("条件判断为true");
        }else{
            System.out.println("条件判断为false");
        }
        System.out.println("num3 = " + num3);

       /*
            条件判断为false
            num3 = 11
        */

        // 2.2 ||  左侧为true, 已经能决定表达式的结果了, 就不会执行右边了, 短路
        boolean b4 = true;
        int num4 = 10;

        if(b4 || (num4++ > 0)){
            System.out.println("条件判断为true");
        }else{
            System.out.println("条件判断为false");
        }
        System.out.println("num4 = " + num4);

        /*
            条件判断为false
            num4 = 10   // num4 没有执行++
        */

    }
}

5. 位运算符

运算符

运算符运算范例结果
<<左移3 << 16
>>右移4 >> 12
>>>无符号右移4 >>> 12
&按位与6 & 32
|按位或6 | 37
^按位异或6 ^ 35
~按位取反~6-7

位运算是直接对整数的二进制进行的运算

运算符说明
<<空位补0，被移除的高位丢弃，空缺位补0
>>被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。
>>>被移位二进制最高位无论是0或者是1，空缺位都用0补。
&二进制位进行&运算，只有1&1时结果是1，否则是0;
|二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;
^相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0;不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1
~正数取反，各二进制码按补码各位取反

6. 赋值运算符

赋值符号: =

  • 当=两侧数据类型不一致时, 可以使用自动类型转换(类型提升),或使用强制类型转换处理
  • 支持连续赋值
  • 扩展的赋值运算符 +=, -=, *=, /=, %=

示例:

public class Example {
    public static void main(String[] args){
        // 1.赋值语句基本使用
        int num = 20;   // 声明int类型变量num, 并赋值20
        System.out.println(num);  // 20

        long num2 = 30; // 声明long类型变量num2, 将int字面量30,通过自动类型提升赋值给num2 变量
        System.out.println(num2);  // 30

        byte b = (byte)num;  // 通过强制类型转换,将int类型变量num的值赋值给 byte变量

        // 什么变量连续赋值
        int num3;
        int num4;
        num3 = num4 = 50; // 连续赋值
        System.out.println(num3); // 30
        System.out.println(num4);  // 30

        // 也可以通过","分割,连续声明多个相同类型的变量
        int num5 = 20, num6 = 40;
        System.out.println(num5); // 20
        System.out.println(num6);  // 40


        // *********************************
        // 2. 扩展赋值运算符的使用
        // += 的使用
        int i1 = 20;
        i1 += 5;   // 类似于 i1 = i1 + 5,
        System.out.println(i1);  // 15


        // 虽然 i1 += 5 类似于 i1 = i1 +5 当也有区别
        // 例如
        byte by1 = 20;
        // by1 = by1 + 5;  // 此时编译报错, 因为byte类型变量 + int类型字面量5 不能赋值给byte类型 by1
        by1 = (byte)(by1 + 5);  // 通过强制类型 解决问题
        System.out.println(by1);  // 25

        byte by2 = 10;
        by2 += 5; // += 不会改变原有的类型, 因此不存在类型问题
        System.out.println(by2);  // 15

        // 其他也是如此
        int i2 = 2;
        i2 *= 0.1;  // 可以写成 i2 = (int)(i2 * 0.1)
        System.out.println(i2); // 0
        // int 类型变量 i2 乘以 double类型 0.1 结果0.2 转为int类型, 保留整数,结果为 0


        // 相对于运算后赋值,比较常用扩展运算符
        int i3 = 10;
        i3 = i3 +5;
        i3 += 5;  // 比较常用的写法

        // 对于自身数据加1
        int i4 = 10;
        i4 = i4 + 1;
        i4 +=1;
        i4++;  // 这是比较常用的写法


    }
}

7. 三元运算符

三元运算符格式: (条件表达式)? 表达式1: 表达式2

说明: 条件表达式结果是一个boolean 类型, 根据boolean类型的结果,决定执行表达式1,还是表达式2

如果运算后的结果需要赋值给新的变量, 则要求变量类型同时兼容表达式1和表达式2 的类型

public class Example {
    public static void main(String[] args){
        // 条件运算符
        // 1. 根据条件表达式判断执行表达式1,还是表达式2
        // 2. 表达式返回的结果赋值的变量类型必须兼容
        int num = 30;
        double res = (num > 20) ? 10 : 2.0;
        System.out.println(res);  // 10.0

    }
}

8. 运算符的优先级

运算符优先级从高到低排列

运算符说明Java运算符
分隔符() [] {} . , ;
单目(元)运算符+、-, ++ , --, ~ , !
强制类型转换运算符(type)
乘法、除法、求余* 、/ 、%
加法、减法+、-
移位运算符<<、>>、>>>
关系运算符<、<=、>=、>、instanceof
等价运算符==、!=
按位与&
按位异或^
按位或`
条件与&&
条件或`
三目运算符? :
赋值运算符=、+=、-=、*=、/=、%= &=、`
前端付杰
关注
专栏目录
C++中STL在使用过程中的几点深入总结（收藏）
实战开发者Airex
06-06 233
总第97篇对于C++填坑员来说，相信大家肯定使用过STL，只是理解的深与浅罢了。最近在项目开发过程中，发现自己对STL中的有些问题有了更深入的认识，或者说有些知识以前没有掌握，在接下来的几篇文章中，好好总结梳理一下，以便加深印象。1.容器容器是用于存放数据的类模板，在使用容器时，即是将容器类模板进行实例化，对象的变量被插入容器中时，实际插入的是对象的一个复制品。在STL中许多算法(函数模板)，在执...
Flink 极简教程: 架构及原理 Apache Flink® — Stateful Computations over Data Streams
程序员光剑
12-27 9283
Flink 极简教程: 架构及原理 Apache Flink® — Stateful Computations over Data Streams 关键词 分布式流处理 分布式计算引擎 All streaming use cases Event-driven Applications Stream & Batch Analytics Data Pipelines &a...
Java operator
qq_40784315的博客
05-14 166
运算符 算术运算符 + - * / % ++ - - 赋值运算符= 关系运算符> < >= <= == != instanceof 逻辑运算符&& || ! 位运算符& | ^ ~ >> << >>> 条件运算符? : 扩展运算符+= - = *= /= 算术运算符 package operator; import base.*; public class Demo1 { public static v
java-operator
weixin_43904839的博客
06-09 212
self-study java notes --运算符 1.赋值和赋值拓展运算符 int a=3; int b=4; a*=a+b; System.out.println(a); System.out.println("a="+a+"\nb="+b); 先算a+b 2.关系运算符 关系运算符的结果为布尔类型，只有true/false char a='a'; char a2='b'; System.out.println(a<a2); System.out.println(0+a); System.ou
Java 运算符(Operators)
亮亮的专栏
06-25 761
运算符（operator）也被称为操作符，是用于实现赋值、比较和执行算数运算等功能的符号。本文主要介绍Java 中的运算符(算术运算符、关系运算符、赋值运算符、逻辑运算符、位运算符)的使用，以及相关示例代码。 原文地址：Java 运算符(Operators) ...
Java学习(5) —— 算术运算符、关系运算符、逻辑运算符、赋值运算符、标识符命名规则、关键字和保留字、Scanner
weixin_55207124的博客
08-16 1669
个人学习2weq
Apache Flink®极简教程: 架构及原理 Stateful Computations over Data Streams
程序员光剑
12-28 9297
Flink 极简教程: 架构及原理 Apache Flink® — Stateful Computations over Data Streams关键词分布式流处理分布式计算引擎All s...
深入底层｜JVM源码解读：HotSpot的模板解释器
HeapDump性能社区的博客
11-11 1153
本文由HeapDump性能社区首席讲师鸠摩（马智）授权整理发布 第9篇-字节码指令的定义 之前的文章介绍了解释执行下的Java栈帧创建以及字节码分派逻辑，但是始终没有讲到虚拟机到底是怎么执行Java方法中的字节码的，在介绍字节码的执行之前，需要先知道字节码指令的定义。在Bytecodes::initialize()函数中会定义字节码指令的一些属性。这个函数的调用链如下： init_globals() bytecodes_init() Bytecodes::initialize() 在Bytecode.
Operator.java
05-10
运算符 实例。在做一些数学计算时，常用的计算方法一定要有意识的认为Math类中应该有现成的方法（以此类推，在进行一些常规操作时，要有意识去想一下有没有内置的函数可以使用）。
java编程思想教学材料——第三讲Operators
03-02
基于java编程思想（Thinking in java, TIJ）的教学PPT，教学设计请见http://blog.csdn.net/Florianjin
Java运算符(Operator)
最新发布
qq_51149294的博客
07-15 282
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
Java Operators
zx_buaa的博客
04-29 242
本文简述Java中操作符的一些知识点，属于个人学习总结，能力有限，还望各位大神多多指点。
Java记录 -4- 运算符 Operator
weixin_34235371的博客
08-09 162
当有若干个变量参与运算时，结果类型取决于这些变量中表示范围最大的那个变量类型。比如，参与运算的变量中，有整型int，有双浮点型double，有短整型short，那么最后结果类型就是double。int a = 1; int b = 2; double c = (double) a / b;上面代码中，a与b都是整型，但是通过（double）a这种转换将a转换为一个匿名的变...
java operators_Java Basic Operators
weixin_35045973的博客
02-16 97
Java提供了一组丰富的操作符来操纵变量。我们可以将所有Java运算符分成以下组 -算术运算符关系运算符按位运算符逻辑运算符赋值运算符杂项操作符算术运算符算术运算符与数学表达式中使用的代数方法相同。下表列出了算术运算符 -假设整数变量A保持10，变量B保持20，则 -操作符描述例+(加法)在操作符的两边添加值。A + B将给予30- (减法)从左手操作数减去右手操作数。A - B会给-10*(...
java基础之运算符(Operator)
汪云辉的博客
01-13 972
运算符1 算数运算符1.1 运算符两侧的类型一致1.2 运算两侧的类型不一致1.3 ++,-- 运算符1.4 + 字符串中的拼接操作2 赋值运算符1）赋值运算符 =2）+= ,-=,*=,/=,%=3）+= ,-=,*=,/=,%=：自动类型强转功能3 比较运算符4 逻辑运算符5 三元运算符5.1 格式5.2 三元运算符执行顺序： 运算符其实就是操作变量或者是常量的符 1 算数运算符 1.1 运算符两侧的类型一致 运算符两侧的类型一致时，运算的结果也是和运算的数据类型一样的但（byte，sho
Java运算符(Java Operators)
张林林|深蓝(Linlin Zhang,shenlan211314) 的专栏
07-29 827
Operator Purpose + addition of numbers, concatenation of Strings += add and assign numbers, concatenate and assign Strings - subtraction
java operators_Java运算符(Java Operators)
weixin_39609670的博客
02-13 103
Operator Purpose+ addition of numbers, concatenation of Strings+= add and assign numbers, concatenate and assign Strings- subtraction-= subtract and assign* multiplication*= multiply and assign/ divis...
C++中的运算符重载：new运算符与operator new的区别
"本文主要介绍了C++中的运算符重载，特别是`new`运算符的使用和重载。文中强调了`new`运算符在内存分配和对象构造过程中的作用，以及为什么需要通过`new`来创建堆上的对象。同时，文章提到了高质量C++编程中如何利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值