首页 > 编程入门 文章详情

JAVA核心技术4-运算符

编程入门 行业动态 更新时间:2024-10-23 19:33:52

JAVA<a href=https://www.elefans.com/category/jswz/34/1767668.html style=核心技术4-运算符"/>

JAVA核心技术4-运算符

文章目录

  • 1 运算符
    • 1.1 算术运算符
    • 1.2 数学函数与常量
      • 1.2.1 平方根
      • 1.2.2 幂运算
      • 1.2.3 三角函数
      • 1.2.4 随机数
      • 1.2.5 绝对值
      • 1.2.6 π和e
    • 1.3 数值之间的类型转换
      • 1.3.1 自动类型转换
      • 1.3.2 强制类型转换
      • 1.3.3 编译器的常量优化
    • 1.4 结合赋值运算符
    • 1.5 自增自减运算符
    • 1.6 关系运算符
    • 1.7 逻辑运算符
    • 1.8 三元运算符
    • 1.9 位运算符
      • 1.9.1 与运算符
      • 1.9.2 或运算符
      • 1.9.3 非运算符
      • 1.9.4 异或运算符
      • 1.9.5 移位运算符
    • 1.10 运算符的优先级

1 运算符

1.1 算术运算符

在Java中，使用算术运算符+、-、*、/表示加、减、乘、除运算。

当参与 / 运算时，如果两个操作数都是整数，表示整数除法(小数部分被截断，不会四舍五入)；否则表示浮点除法。

int num = 15/2;		//num的值为7int mun =15.0/2		//num的值为7.5

整数的求余操作用%表示：

int num = 15%2;		//num的值为1

求余操作一般不用于浮点型和浮点型以及浮点型和整型之间。

严格的浮点型计算（了解）：可以用strictfp关键字修饰方法或者类，主要是为了保证程序可移植性，使结果在各平台间一致：

public static strictfp void main(String[] args)	//表示main方法中必须使用严格的浮点计算public strictfp class JavaTest					//表示JavaTest类中必须使用严格的浮点计算

1.2 数学函数与常量

在Math类中，包含了各种各样的数学函数。下边只列出常用的一些方法，想查看更多有关Math类的方法可以参看API文档：

1.2.1 平方根

要想计算一个数值的平方根，可以使用sqrt方法：

double x = Math.sqrt(4);	//x = 2.0;
double y = Math.sqrt(x);	//y=1.4142135623730951

使用sqrt方法必须用一个double类型的变量或者常量，接收计算得到的值。

1.2.2 幂运算

在Java中没有幂运算，需要借助Math类中的pow方法：

double y = Math.pow(x,a);	
double x = Math.pow(10,2);	//值为100.0

上述代码表示将y设置为x的a次幂，即 x a x^a xa，x和a是两个double类型的参数，返回值也为double类型。

1.2.3 三角函数

Math类提供一些常用的三角函数：Math.sin、Math.cos、Math.tan、Math.atan、Math.atan2，使用方法如下：

double num = Math.sin(Math.PI/6)	//返回正弦值,结果为0.49999999999999994，而非0.5
double num = Math.cos(Math.PI/3)	//返回余弦值，结果为.5000000000000001，而非0.5

同样的Math.tan返回正切值，Math.atan返回反正切值，Math.atan2把直角坐标转换为极坐标。、

1.2.4 随机数

Math类提供random方法来生成随机数，这个随机数是double类型，该值大于0小于1。

利用random方法生成一个1~y的随机数（生成x~y的随机数再Random类中进行）：

int x = (int) (Math.random()*y+1) //将1换成0可以的到0~y的随机数，但是不能用该公式生成x~y的随机数。

解释：因为Math.random类生成的是0~1间的double类型的值，将其乘以y,获得的是0~y之间double类型的值，再加上x得到的是1~y+1的值。

1.2.5 绝对值

Math类提供abs方法来获取一个数的绝对值：

System.out.println(Math.abs(-1));		//输出结果为1

1.2.6 π和e

Java提供了两个用于表示π和e最接近的近似值，可以用以下方法调用他们：

Math.PI：调用圆周率；

Math.E：调用自然常数。

不必在数学方法名和常量名前加"Math."，只要在源文件顶部进行静态导入就行：

import static java.lang.Math.*

只后使用Math类中的方法和常量，可以省略类名调用，如下：

System.out.println(abs(PI));

1.3 数值之间的类型转换

Java程序中要求参与计算的数据类型必须相同，如果不同就会发生数据类型的转换，转换主要包括两种：自动类型转换和强制类型转换。

1.3.1 自动类型转换

自动类型转换指的是，代码不需要特殊处理，直接由系统完成类型转换，这种转换一般不会造成信息丢失。

以下的转换不会发生信息丢失：

当用一个二元运算符连接两个值的时候，先要将两个操作数转换为同一种类型，然后再进行计算：

  1. 如果两个操作数有一个是double类型，另一个操作数就会转换成double类型；
  2. 否则，如果两个操作数有一个是float类型，另一个操作数会转换为float类型；
  3. 否则，如果两个操作数有一个是long类型，另一个操作数会转换为long类型；
  4. 否则，两个操作数都将转换为int类型。
//第四行语句是错误语句，因为x和y在进行运算时会自动转换为int型，int型结果不能直接赋值给byte型变量。
byte x = 3;
byte y = 4;
byte z = x + y;			//ERROR

1.3.2 强制类型转换

在必要的时候int类型可以自动转换为double类型，但有时候，我们也需要将double型转换为int型。在Java中允许这种数值之间的类型转换，不过可能丢失信息，这种转换需要通过强制类型转换来完成。

格式：范围小的类型 范围小的变量名 = （范围小的类型）（范围大的数据）；

double x = 9.8;
int nx = (int) x;		//nx=8/*上述可以看出这种强制类型转换通过截断小数部分将浮点值转换为整型如果想进行四舍五入，需要使用Math.round方法。*/double x= 9.8;
int nx = (int)Math.round(x);	//nx=10;//当调用round方法仍然需要强制类型转换是因为round方法返回的是一个long类型的值，long无法自动转换为int类型。

如果试图将一个数值从一种类型强制转换为另一种类型而又超出其范围时，结果会被截断成一个完全不同的值，如（byte）300的实际值是44，原因可以根据二进制编码进行分析，300的二进制编码是0001 0010 1100，由于byte类型占用1个字节空间相当于8个字符，因此截断时只会保留前八位，0010 1100，对应的二进制数是44。

1.3.3 编译器的常量优化

byte z = 3 + 4;		//合法，结果为7，等价于：byte z = (byte)(3+4)

分析：我们知道数值没有声明类型默认是int类型，然而与1.3.1不同的是，在运算结束后却可以把结果直接赋值给byte 类型，这是因为编译器对其做出优化，在给变量进行赋值的时候，如果右侧是常量，则当右侧从低到高进行类型转化时，编译器会自动补上强制类型转换但是只要右侧有变量，该优化即消失。

1.4 结合赋值运算符

可以在赋值中使用二元运算符，这是一种很方便的简写方式。例如：

x += 4;		//等价于x = x + 4,相应的减法，乘法，除法，取余也有这种简便写法。

需要注意的是，这种运算符通常蕴含了隐式类型转换。

short a = 2;
a += 10;			//合法，可以得出正确的结果

分析：a+=10，相当于a=a+10，其中a是short类型，在进行运算时会发生自动类型转换，将其提升为int类型，此时等号左边的a是short型，右边的值是int型，很明显从高类型到低类型，需要强制类型转换，但是这么写程序不会报错，因为系统自动给他补上强制类型转换，转化为a=(short)(a+10)，这种转化称为隐式类型转换。

1.5 自增自减运算符

自增自减运算符有两种形式：前++（–）和后++（–）：

以++为例：

前缀形式的++i会先完成i的值加1，再使用i的值。后缀形式的i++会先使用i的值，再对i的值加1；

int i = 2;
System.out.println(++i);		//打印输出的值是3
System.out.println(i++);		//打印输出的值是3

注意：自增自减运算符改变的是变量的值，所以不能用于数据本身。

1.6 关系运算符

Java包括丰富的关系运算符，主要有以下几种：

  1. 比较相等的运算符，用==表示，如：3==7; //false;
  2. 表示不等的运算符，用!=表示，如：3!=7; //true;
  3. 还有<（小于）、>（大于）、<=（小于等于）、>=（大于等于）运算符。

需要注意的是，关系运算符的结果都是布尔值，即true或者false。

1.7 逻辑运算符

Java用&&来表示逻辑“与”运算符，使用||来表示逻辑“或”运算符，使用！来表示逻辑“非”运算符。

&&（短路与）1. 两边都是true，结果才是true 2. 只要一边是false，结果就是false 短路规则：只要左边为false，不再判断右边是否成立
||（短路或）1.只要一边是true，结果就是true 2.只有两边都是false，结果才是false 短路规则：只要左边是true，不再判断右边是否成立
！（取反）1. !（true）结果是false 2.!（false）结果是true

注意事项：

  1. 逻辑运算符只能用于布尔值；
  2. 与或运算符如果需要可以多写；
  3. 在Java中不能写1<x<3，而应该写为x>1 && x<3；
  4. 单&和单|不采用短路方式，得到结果前，两个操作数都需要计算。
//短路示例，两个if语句独立，初始i均为1int i = 1;
if(i>1 && i++<3)System.out.println(i);			//打印输出的结果是1if(i>0 && i++<3)System.out.println(i);			//打印输出的结果是2

1.8 三元运算符

格式：数据类型 变量名 = 布尔表达式 ？ 结果1 ：结果2；

流程：先判断布尔表达式是否成立：如果成立为true，将结果1赋给左边的变量，如果不成立false，表达式B的值赋给左边的变量。

注意事项

  1. 必须保证结果1和结果2符合左边的数据要求，但下述情况例外；

    System.out.println(a > b ? a : b);

  2. 三元运算符的结果必须被使用。

1.9 位运算符

位运算符主要针对二进制，它包括了：“与”、“非”、“或”、“异或”。从表面上看似乎有点像逻辑运算符，但逻辑运算符是针对两个关系运算符来进行逻辑运算，而位运算符主要针对两个二进制数的位进行逻辑运算。（具体理解参参看二进制码，补码，反码）

1.9.1 与运算符

对二进制数各个位置的字符进行比较，如果是都是1则结果为1，否则为0，符号为**&**。

System.out.println((125&124));			//结果是124/*	125的二进制数是：0000 0000 0000 0000 0000 0000 0111 1101 124的二进制数是：0000 0000 0000 0000 0000 0000 0111 1100&后的二进制数是：0000 0000 0000 0000 0000 0000 0111 1100		*/

1.9.2 或运算符

对二进制数各个位置的字符进行比较，只要有一个结果为1则为1，否则为0，符号为**|**。

System.out.println((125|124));			//结果是125/*  125的二进制数是：0000 0000 0000 0000 0000 0000 0111 1101124的二进制数是：0000 0000 0000 0000 0000 0000 0111 1100|的二进制数是：  0000 0000 0000 0000 0000 0000 0111 1101		*/

1.9.3 非运算符

对二进制数各个位置的字符进行比较，如果为1则取非为0，如果为0则取非为1，符号为~。

System.out.println((~125));			//结果是-126/*	125的二进制数是：0000 0000 0000 0000 0000 0000 0111 1101~的二进制数是：  1111 1111 1111 1111 1111 1111 1000 0010			*/

这里虽然看上去是正数，但是在存储时125是0000 0000 0000 0000 0000 0000 0111 1101 。前边的0表示正数，取非后为1111 1000 0010，前边的1表示其为负数，负数采用 补码存储。而1111 1111 1111 1111 1111 1111 1000 0010表示的-126的补码。这里只是略作介绍，详细转换在下一节的移位运算符讲解。这里只是说明代码处理原理，具体转换方式搜索二进制码存储。

1.9.4 异或运算符

对二进制数各个位置的字符进行比较，如果两个字符相同，则异或为0，否则为1，符号位^。

System.out.println((125^124));			//结果是1/*  125的二进制数是：0000 0000 0000 0000 0000 0000 0111 1101124的二进制数是：0000 0000 0000 0000 0000 0000 0111 1100^的二进制数是：  0000 0000 0000 0000 0000 0000 0000 0001		*/

1.9.5 移位运算符

移位运算符主要处理二进制数，可以将位模式左移或者右移。

位运算符功能实例
<<左移运算符，将运算符左边的对象向左移动运算符右边指定的位数（在右边补0）125<<3
>>有符号右移运算 符，将运算符左边的对象向右移动运算符右边指定的位数。如果值为正数，则在左边补0，如果为负数，则在左边补1.-125>>3
>>>无符号右移运算 符，将运算符左边的对象向右移动运算符右边指定的位数。不论是正数还是负数，都在左边补0.-125>>>3
操作结果十进制结果
125的二进制编码0000 0000 0000 0000 0000 0000 0111 1101125
-125的二进制编码1111 1111 1111 1111 1111 1111 1000 0011-125
125<<30000 0000 0000 0000 0000 0011 1110 10001000
125>>30000 0000 0000 0000 0000 0000 0000 111115
-125<<31111 1111 1111 1111 1111 1100 0001 1000-1000
-125>>31111 1111 1111 1111 1111 1111 1111 0000-16
-125>>>30001 1111 1111 1111 1111 1111 1111 0000536870896

说明：正数存储方式是原码，负数的存储方式是补码，等于其绝对值的二进制编码的反码再加1。

求-125的补码：125的二进制编码为： 0000 0000 0000 0000 0000 0000 0111 1101它的反码是： 1111 1111 1111 1111 1111 1111 1000 0010反码再加1是补码，故补码是：  1111 1111 1111 1111 1111 1111 1000 0011
-----------------------------------------------------------------------------------
求 1111 1111 1111 1111 1111 1100 0001 1000 表示的数：因为左边第一位是1，说明这个数是负数，因此这个码是补码；补码减去1得到反码，反码是： 1111 1111 1111 1111 1111 1100 0001 0111对反码取反得到原码，原码是： 0000 0000 0000 0000 0000 0011 1110 1000因此根据二进制转换为十进制的方法得到这个码的原码对应的值是1000因为这个数是负数：故表示的值是 -1000。

1.10 运算符的优先级

优先级运算符结合性
1(),[],{}，方法调用从左向右
2! ~ ++ – +(一元运算) -(一元运算) (强制类型转换) new从右向左
3* / %从左向右
4+ -从左向右
5<< >> >>>从左向右
6< <= > >= instance of从左向右
7== !=从左到右
8&从左到右
9^从左到右
10|从左向右
11&&从左向右
12||从左向右
13？：从右向左
14=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=从右向左

更多推荐

JAVA核心技术4-运算符

本文发布于:2023-07-28 17:49:10，感谢您对本站的认可！
本文链接:https://www.elefans.com/category/jswz/34/1267193.html
版权声明:本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
本文标签：核心技术   运算符   JAVA

发布评论

评论列表 （有 0 条评论）

最近发表

草根站长

>www.elefans.com

编程频道|电子爱好者 - 技术资讯及电子产品介绍！

热门文章

标签列表