Java操作符

已于 2022-07-23 20:33:09 修改
阅读量93 收藏
点赞数
文章标签： java
于 2022-07-20 11:29:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55861109/article/details/125885739
版权

操作符

操作符

操作符作用例子
=最基础的赋值操作符，=号右边的值，赋给=号左边变量int a = 1; int x = 0;
*=一个变量和另一个数据相乘，并把结果再赋值给这个变量int a = 1; a*=2; //a = a*2;
/=一个变量和另一个数据相除，并把结果再赋值给这个变量int a = 2; a/=2; //a = a/2;
%=一个变量和另一个数据相余，并把结果再赋值给这个变量int a = 5; a%=2; //a = a%2;
+=一个变量和另一个数据相加，并把结果再赋值给这个变量int a = 5; a+=2; //a = a+2;
-=一个变量和另一个数据相减，并把结果再赋值给这个变量int a = 5; a-=2; //a = a-2;
>比较是否大于1>0
>=比较是否大于等于1>=0
<比较是否小于1<2
<=比较是否小于等于1<=2
instanceof判断对象是否属于指定类型stu instanceof Student
  • == 和 ！=
public class Demo {
    public static void main(String[] args) {
        System.out.println(1==2);
        System.out.println(1!=2);
        //比较两个变量指向的地址
        Hello hello = new Hello();
        Hello hello2 = new Hello();
        System.out.println(hello==hello2);
        System.out.println(hello!=hello2);
        System.out.println(hello);
        System.out.println(hello2);
        //基本类型只比较值,不管类型
        System.out.println(1==1.0);//true
        System.out.println(97=='a');//true
    }
}
class Hello{

}

在这里插入图片描述

  • */+ -
public class Demo2 {
    public static void main(String[] args) {
        int a =10;
        int b =4;
        System.out.println(a+b);//14
        System.out.println(a-b);//6
        System.out.println(a*b);//40
        System.out.println(a/b);//2
        System.out.println(a%b);//2
        //特殊 + 可以做拼接 比如和字符串使用
        //字符串 + 任何内容 组成新的字符串
        String s = "hello";
        System.out.println(s+new Demo2());
        System.out.println(s+a);//hello10
        System.out.println(s+"我的值是"+a+"!");
        System.out.println(s+5+5);//hello55
        //注意%对负数求余，最终结果取决于第一个数的符号
        System.out.println(10%-4);//2
        System.out.println(-10%4);//-2
    }
}
  • />> << >>> <<<
public class Demo3 {
    public static void main(String[] args) {
        //8
        // 24个0 00001000 正数 原码 反码 补码 都一样
        //00000000 00000000 00000000 00001000
        //右移1 00000000 00000000 00000000 00000100 丢弃最后一个0
        //有符号 正数补0 负数补1
        System.out.println(8>>1);//4
        //00000000 00000000 00000000 00001000
        //左移1 0 00000000 00000000 00000000 00010000 丢弃最前一个0
        System.out.println(8<<1);//16
        //-8
        //10000000 00000000 00000000 00001000 原码
        //11111111 11111111 11111111 11110111 反码
        //11111111 11111111 11111111 11111000 补码
        //11111111 11111111 11111111 11111001 0左移
        //11111111 11111111 11111111 11111000
        //10000000 00000000 00000000 00000100
        System.out.println(-8>>1);//-4
        //10000000 00000000 00000000 00001000 原码
        //11111111 11111111 11111111 11110111 反码
        //11111111 11111111 11111111 11111000 补码
        //1 11111111 11111111 11111111 11110000 右移
        //11111111 11111111 11111111 11101111
        //10000000 00000000 00000000 00010000
        System.out.println(-8<<1);//-16
    }
}

System.out.println(5&9);
        //5 00000000 00000000 00000000 00000101
        //9 00000000 00000000 00000000 00001001
        //5&9 00000000 00000000 00000000 00000001
        //结果为:1
        System.out.println(5|9);
        //5 00000000 00000000 00000000 00000101
        //9 00000000 00000000 00000000 00001001
        //5&9 00000000 00000000 00000000 00001101
        //结果为:13
        System.out.println(5^9);
        //5 00000000 00000000 00000000 00000101
        //9 00000000 00000000 00000000 00001001
        //5&9 00000000 00000000 00000000 00001100
        //结果为:12
        System.out.println(~-5);
        //5 10000000 00000000 00000000 00000101
        //5 11111111 11111111 11111111 11111010 反码
        //5 11111111 11111111 11111111 11111011 补码
        //~ 00000000 00000000 00000000 00000100
        //结果：4
        System.out.println(5<<2);
        //5 00000000 00000000 00000000 00000101
        //5 00000000 00000000 00000000 00010100
        //结果:20
        System.out.println(-5<<2);
        //-5 10000000 0000000 0000000 00000101
        //-5 11111111 1111111 1111111 11111010 反码
        //-5 11111111 1111111 1111111 11111011 补码
        //-5 11111111 1111111 1111111 11101100 左移
        //   11111111 1111111 1111111 11101011 反码
        //   10000000 0000000 0000000 00010100
        //结果:-20
        System.out.println(-5>>2);
        //-5 10000000 0000000 0000000 00000101
        //-5 11111111 1111111 1111111 11111010 反码
        //-5 11111111 1111111 1111111 11111011 补码
        //-5 11111111 1111111 1111111 11111110 右移
        //   11111111 1111111 1111111 11111101 反码
        //   10000000 0000000 0000000 00000010
        //结果:-2
        System.out.println(-5>>>2);
        //-5 10000000 0000000 0000000 00000101
        //-5 11111111 1111111 1111111 11111010 反码
        //-5 11111111 1111111 1111111 11111011 补码
        //-5 00111111 1111111 1111111 11111110 >>>
        //结果:2^30-2
        System.out.println(5>>2);
        //5 00000000 0000000 0000000 00000101
        //5 00000000 0000000 0000000 00000001
        //结果:1
        System.out.println(5>>34);
        //5>>34=5>>2
        //结果:1
        System.out.println(97=='a');
        //==号不考虑数据类型，返回值为true
        System.out.println(5.0==5);
        //==号不考虑数据类型，返回值为true
        System.out.println(4>5 ^ 'c'>'a');
        //相当于flse^true,返回值仍然true
  • &^~|
public class Demo4 {
    public static void main(String[] args) {
        //1
        //00000000 00000000 00000000 00000001
        //0
        //00000000 00000000 00000000 00000000
        System.out.println(1&0);//0
        //同时为一才为1
        //1&1
        //00000000 00000000 00000000 00000001
        //00000000 00000000 00000000 00000001
        System.out.println(1&1);//1
        //1&3
        //00000000 00000000 00000000 00000001
        //00000000 00000000 00000000 00000011
        //00000000 00000000 00000000 00000001 结果
        System.out.println(1&3);

        //1|3
        //有1取1 无则取0
        //00000000 00000000 00000000 00000001
        //00000000 00000000 00000000 00000011
        //00000000 00000000 00000000 00000011 结果
        System.out.println(1|3);//3

        //1^3
        //相同取0 不同取1
        //00000000 00000000 00000000 00000001
        //00000000 00000000 00000000 00000011
        //00000000 00000000 00000000 00000010 结果
        System.out.println(1^3);//2

        //~:取反 1->0,0->1
        //00000000 00000000 00000000 00000001
        //11111111 11111111 11111111 11111110 补码
        //11111111 11111111 11111111 11111101 反码
        //10000000 00000000 00000000 00000010 原码
        System.out.println(~1);
    }
}

使用场景 交换数值

public class Demo5 {
    public static void main(String[] args) {
        int a =10;
        int b =5;
        //方法1 借助中间变量
        int temp;
        temp=a;
        a=b;
        b=temp;
        System.out.println(a);
        System.out.println(b);
        //方法2:不能使用中间变量
        a = a+b;
        b = a-b;
        a = a-b;
        System.out.println(a);
        System.out.println(b);
        //方法三:使用^异或交换
        a =a^b;
        b =a^b;
        a =a^b;
        System.out.println(a);
        System.out.println(b);
    }
}
  • && ||
public class Demo6 {
    public static void main(String[] args) {
        //&&连接两个布尔表达式,拼接多个判断条件
        //同时为true才为true
        int a=1;
        int b=5;
        System.out.println(a>0&&b>0);//true
        System.out.println(a>1&&b>1);//false
        // || 拼接多个判断条件 一个为true就为true
        System.out.println(a>5||b>5);//false
        System.out.println(a>1||b>1);//true
        //&&的短路效果,前面为false后面表达式不计算
        //a=1,b=5
        System.out.println(a++>1&&++b>0);
        System.out.println(a);
        System.out.println(b);//此时b不会自增
        System.out.println(a++>0&&++b>0);
        System.out.println(a);
        System.out.println(b);//此时b会自增
        //||的短路效果,前面为true后面不执行
        System.out.println(a++>0||++b>0);
        System.out.println(a);
        System.out.println(b);//此时b不会自增
    }
}

计算机会把true识别为1 false为0

  • 三目运算符
public class Demo7 {
    public static void main(String[] args) {
        int num =0;
        char gender;
        if (num==0){
            gender = '男';
        }else {
            gender = '女';
        }
        System.out.println(gender);//男
//        System.out.println((num==0)?(gender='男)':(gender='女'));
        char gender2 = num==1?'男':'女';
        System.out.println(gender2);//女
    }
}
优先级运算符结合性
1
RH-六月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 操作符（运算符）
今天可爱了吗ik的博客
11-24 360
目录优先级赋值位运算逻辑运算短路条件运算符（三元运算符）instance of 运算符直接常量类型转换截尾和舍入运算规则 本文部分引自菜鸟教程 优先级 先乘除后加减 ‘+’：如果前后紧跟String类型的元素时，则进行字符串连接操作（尝试将另一个非String类型的元素转换为String） 且‘+’操作符优先级大于‘==’ public static void main(String[] args) { int a=2; int b=3; int c=4
java操作符（一）
qq_62086412的博客
05-22 203
Java操作符（一） Java的操作符分为好几类，包括算术运算符、自动递增和递减、关系操作符、逻辑操作符、按位操作符、移位操作符、三元操作符（if-else）以及字符串操作符（+和+=）。我们这里先浅学一下前六种。 1.算术运算符 我们通过一段代码来理解算术运算符 public class Example01{ public static void main(String[] args){ int a=1; int b=2; int c=a/b; int d=b/a; S
Java之操作符
qq_48666555的博客
05-13 1307
java的操作符 操作符全 特殊操作符 字符操作符 类型转换
【Java】运算符 / 操作符
hanne_lovegood的博客
03-01 360
Java基础知识 2021/2/28 周日 复习内容: 算术运算符、关系运算符、逻辑运算符、赋值运算符、条件运算符 运算符（操作符）就是对数据进行处理的方式 一、算术运算符 + - * / % ++ -- 加 减 乘 除 取模(求余) 加1 减1 在进行混合类型运算时，会进行类型转换，结果会自动转换成类型最宽的那个类型 byte->short->int->long->float->double char->int byte
Java中的操作符
梦_蝶的博客
04-22 845
在Java中操作符有很多种，包括算数运算符，关系运算符，逻辑运算符，位运算符等。 1.算数运算符 +，-，*，/，%，++，- -，=，+=，-=， *=，/=，%= 这些都比较简单，挑重点讲一下： ①(++i)和（i++）的区别，它们的最终结果都是给i加1，i++是先将它看作一个整体执行完当前语句后再给i加1，而++i是先给i加1，再将i的值代入语句中执行。举个例子： int x=2; int y=x++*2; int z=++x*2; System.out.println(y);//4
Java操作符总结-动力节点共20页.pdf.zip
11-23
Java操作符是编程语言中用于执行特定操作的符号，它们在Java编程中起着至关重要的作用，帮助我们构建复杂的逻辑和算法。这份“Java操作符总结-动力节点共20页.pdf”很可能是对Java中各种操作符的一个全面概述，包括...
java操作符
07-19
Java 操作符与变量初始化是编程中至关重要的概念，它们直接影响到代码的正确性和效率。在 Java 中，操作符用于执行特定的操作，如比较、算术运算或逻辑运算，而变量初始化则是确保变量具备合适初始值的过程。 1. **...
Java操作符及执行流程控制
01-21
　主要操作符：+、-、*、/、=、++、–、+=、-=、==、!=、&&、||、!、&、^、~、>=、<=、>、< ….. 　几乎所有的操作符只能够操作”基本数据类型”，=、==、!=可以操作所有的数据类型及对象 　String类型...
Java关系操作符简写介绍
09-02
在Java编程语言中，关系操作符是用于比较两个值之间关系的关键字。这些操作符帮助开发者确定变量或表达式之间的大小、相等性或其他关系。下面是对Java中常见关系操作符的详细介绍及其简写形式： 1. **等于操作符 (=...
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 458
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 5290
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 5487
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 3463
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 2184
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 2887
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 457
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
死锁及其产生条件
秋夫人
08-26 1570
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
JVM 内存参数
iOS逆向与安全
08-29 797
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
java操作符优先级
11-18
Java操作符优先级如下（从高到低）： 1. 后缀运算符：expr++、expr-- 2. 一元运算符：++expr、--expr、+expr、-expr、~、! 3. 乘性运算符：*、/、% 4. 加性运算符：+、- 5. 移位运算符：<<、>>、>>> 6. 关系运算符：>、>=、<、<=、instanceof 7. 相等运算符：==、!= 8. 按位与运算符：& 9. 按位异或运算符：^ 10. 按位或运算符：| 11. 逻辑与运算符：&& 12. 逻辑或运算符：|| 13. 三元运算符：?: 14. 赋值运算符：=、+=、-=、*=、/=、%=、&=、^=、|=、<<=、>>=、>>>= 以下是一个Java操作符优先级的例子： ```java int a = 10, b = 20, c = 30; int result = ++a * b-- % c; System.out.println(result); // 输出：200 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值