简介：`long`类型内存8个字节， `int`类型内存4个字节。 `long`取值范围大于`int` ；

三、运算符

3.1 算术运算符

算术运算符
+	加法运算，字符串连接运算
-	减法运算
*	乘法运算
/	除法运算
%	取模运算，两个数字相除取余数
++、—	自增自减运算

3.1.1 基本运算

算数运算符练习：

/** 
* @author lscl 
* @version 1.0 
* @intro: 
*/
public class Demo05 {    
    public static void main(String[] args) {        
        // 定义变量        
        int a = 5;        
        int b = 3;        
        System.out.println(a + b);      //8        
        System.out.println(a - b);      //2        
        System.out.println(a * b);      //15        
        System.out.println(a / b);      //1        
        System.out.println(a % b);      //2        
        System.out.println("------------");        //整数相除，结果是整数，要得到小数，必须有小数参与运算(提升为double类型)        
        System.out.println(5.0 / 3);        //1.6666666666666667        
        System.out.println(5 / 3.0);        //1.6666666666666667    
    }
}

%取余注意事项：

/** 
* @author lscl 
* @version 1.0 
* @intro: 
*/
public class Demo06 {    
    public static void main(String[] args) {        
        System.out.println(5 % 3);        
        System.out.println(-5 % 3);        
        System.out.println(5 % -3);        
        System.out.println(-5 % -3);    
    }
}

Tips：取余结果符号与左边符号相同

3.1.2 ++和—

++ 运算，变量自己增长1。反之， — 运算，变量自己减少1，用法与 ++ 一致。

独立运算：
- 变量在独立运算时，前++ 和后++ 没有区别。
- 变量前++ ：例如 ++i 。
- 变量后++ ：例如 i++ 。
混合运算：
- 和其他变量放在一起，前++ 和后++ 就产生了不同。

变量前++：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo07 {
    public static void main(String[] args) {

        int a = 1;
        int b = ++a;                //先++,后赋值

        System.out.println(a);          //2
        System.out.println(b);          //2
    }
}

变量后++：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo08 {
    public static void main(String[] args) {

        int a = 1;
        int b = a++;            //先赋值，后++

        System.out.println(a);      //2
        System.out.println(b);      //1
    }
}

自增自减小练习

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo09 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 10;
        a = b++;
        c = --a;
        b = ++a;
        a = c--;

        System.out.println(a);      //?
        System.out.println(b);      //?
        System.out.println(c);      //?
    }
}

3.1.3 +=运算

public class Demo {    
    public static void main(String[] args) {        
        short s = 1;       
        s += 1;                                          
        System.out.println(s);    
    }
}

s += 1 逻辑上看作是 s = s + 1；计算结果被提升为int类型再向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型，但是， s=s+1进行两次运算， += 是一个运算符，只运算一次，并带有强制转换的特点，也就是说 s += 1 就是 s = (short)(s + 1) ，因此程序没有问题编译通过，运行结果是2；
但如果是s=s+1；那么就会出现编译报错，需要强制转换；

3.1.4 字符串注意事项

符号在遇到字符串的时候，表示连接、拼接的含义。”a”+”b”的结果是“ab”，连接含义

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo10 {
    public static void main(String[] args) {
        // +遇到字符串表示连接
        System.out.println("df" + "bz");        //"dfbz"
        System.out.println("dfbz" + 10);        //"dfbz10"

        //1. "dfbz"+5="dfbz5"; 2. "dfbz5"+5="dfbz"
        System.out.println("dfbz" + 5 + 5);

        System.out.println("dfbz" + (5 + 5));   //1. 5+5=10; 2. 10+"dfbz"="10dfbz"
        System.out.println(5 + 5 + "dfbz");     //1. 5+5=10; 2. 10+"dfbz"="10dfbz"

        System.out.println("1+1="+1+1);
    }
}

思考？

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

3.1.5 常量和变量的运算

思考？下面的程序有问题吗？

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo {    
    public static void main(String[] args) {    

        byte b1 = 1;        
        byte b2 = 2;        
        byte b3 = 1 + 2;        
        byte b4 = b1 + b2;    
    }
}

分析： b3 = 1 + 2 ， 1 和 2 是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了 1+2 的结果并没有超过byte类型的取值范围，可以赋值给变量 b3 ，因此b3=1 + 2是正确的。反之， b4 = b2 + b3 ， b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。

3.2 赋值运算符

赋值运算符，就是将符号右边的值，赋给左边的变量。

赋值运算符
=	赋值
+=	加后赋值
-=	减后赋值
*=	减后赋值
/=	除后赋值
%=	取模后赋值

赋值运算符测试：

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo11 {
    public static void main(String[] args) {

        // 定义变量    
        int i = 3; // 将3赋值给变量i    
        i = i + 2; // 将变量i和2相加,再赋值给变量i    
        System.out.println(i);
        // +=: 赋值运算符, 将=左边的变量和=右边的值进行操作,再赋值给变量    
        int j = 10;
        j += 5; // j = j + 5    
        System.out.println(j);

        int m = 10;
        m -= 5; // m = m ‐ 5;    
        System.out.println(m);
        System.out.println("‐‐‐‐‐‐‐‐‐‐");
        byte b = 1;
        // b = b + 2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失    
        // b += 2; // 可以

        b = (byte) (b + 2);
        System.out.println(b);
    }
}

3.3 比较运算符

比较运算符又叫关系运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。

比较运算符：
==	比较符号两边数据是否相等，相等结果是true。
<	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=	比较符号左边的数据是否小于或者等于右边的数据，如果小于或等于结果是true。
>=	比较符号左边的数据是否大于或者等于右边的数据，如果小于或等于结果是true。
!=	不等于符号，如果符号两边的数据不相等，结果是true。

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo12 {
    public static void main(String[] args) {
        System.out.println(3 == 3); // true    
        System.out.println(3 == 4); // false    
        System.out.println(3 != 4); // true    
        System.out.println(3 > 4); // false    
        System.out.println(3 < 4); // true    
        System.out.println(5 <= 4); // false    
        System.out.println(4 >= 4); // true    
        // 注意    
        int i = 3;
        int j = 4;
        System.out.println(i = j); // 将j赋值给i,输出i    
        System.out.println(i == j); // true    
    }
}

3.4 逻辑运算符

3.4.1 运算规则

逻辑运算符，是用来对两个布尔类型进行运算的，运算结果都是布尔值 true 或者 false
| 运算符 | 运算规则 | 示例 | 结果 |
| —- | —- | —- | —- |
| & | 与（有假为假）并且 | false&true | false |
| | | 或（有真为真）或者 | false|true | true |
| ^ | 异或（相同为false，不同为true） | false^true | true |
| ! | 非（取反，true为false，false为true） | !true | false |
| && | 短路与（和& | | |
| 一样，前面条件为false不执行后面的，效率高） | false&&true | false | |
| || | 短路或（和| | | |
| 一样，前面条件为true不执行后面的，效率高） | false||true | true | |

3.4.2 代码示例

& ：与；
|：或；
!：非；
^：异或；

【代码示例】

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo13 {
    public static void main(String[] args) {
        // & 与: 有false则false, 
        System.out.println(false & false); // false
        System.out.println(false & true); // false
        System.out.println(true & false); // false
        System.out.println(true & true); // true
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

        // | 或: 有true则ture, 
        System.out.println(false | false); // false
        System.out.println(false | true); // true
        System.out.println(true | false); // true
        System.out.println(true | true);// true
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

        // ! 非: 取反
        System.out.println(!true); // false
        System.out.println(!false); // true
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

        // ^ 异或: 相同为false,不同为true
        System.out.println(false ^ false); // false
        System.out.println(false ^ true); // true
        System.out.println(true ^ false); // true
        System.out.println(true ^ true);// false
    }
}

3.4.3 特殊情况

短路运算和非短路运算的结果都是一样的，唯一的区别时短路运算在前面条件符合时是不会执行后面条件的，效率较高；非短路运算则不管前面运算结果如何而一定会执行后面的运算，在特定场景下会使用到；

1）短路与运算

短路与：
```
int a = 10;
int b = 10;

System.out.println(a != b && a++ > 10); // false
System.out.println(a); // 10


- 非短路与：

int a = 10;
int b = 10;

System.out.println(a != b & a++ > 10); // false
System.out.println(a); // 11

#### 2）短路或运算

- 短路或：

int a = 10;
int b = 10;

System.out.println(a == b || a++ > 10); // true
System.out.println(a); // 10


- 非短路或：

int a = 10;
int b = 10;

System.out.println(a == b | a++ > 10); // true
System.out.println(a); // 11

## 3.5 三元运算符

- 三元运算符格式：

数据类型变量名 = 布尔类型表达式 ? 结果1 : 结果2;

![](https://cdn.nlark.com/yuque/0/2024/png/1329505/1718247962742-cbaa2147-ec4b-4762-bd39-908744e1019f.png#averageHue=%233a8290&clientId=u438e24a7-97d0-4&from=paste&id=uf9bb9de9&originHeight=657&originWidth=1316&originalType=url&ratio=2.25&rotation=0&showTitle=false&status=done&style=none&taskId=u8ef8b633-8b70-473d-bf91-5d723ce2605&title=)
三元运算符计算方式：

- 布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
- 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

/**

@author lscl
@version 1.0
@intro:
*/
public class Demo15 {
public static void main(String[] args) {
```
 int a = 30;
 int b = 30;
 int c = a > b ? 100 : 20;

 System.out.println(c);
```
}
}
```
三元运算符练习

判断两个数是否相同
获取两个数的较大值

3.6 位移运算
位移运算是对于”位”直接的运算，是将任何进制的数字先转化为2进制，之后再进行移位运算；位移运算分为有符号位移和无符号位移，其中有符号位移包含左位移和右位移，无符号位移只有右位移；

3.6.1 有符号位移
1）左移位运算
正数的左移位：如10 << 2，右边自动补0，左边移出位舍弃，即00001010 —> 00101000，结果是40。实际的意思是，每向左移动一位，就相当于乘以2
```
10: 00000000 00000000 00000000 00001010
10 << 2: 00000000 00000000 00000000 00101000 : 40

相当于: 10 * 2^2 = 40


- 负数的左移位：负数的左移与正数的左移一致，**在右边自动补0**。如-2<<2：11111110 --->11111100，结果为-4。

**对于负数的计算记得要转成补码来运算**

-2: 11111111 11111111 11111111 11111110
-2 << 2: 11111111 11111111 11111111 11111000 : -8

相当于: -2 * 2^2 = -8

Tips：**左位移N，就是乘以2^N**
左位移运算代码：

/**

@author lscl
@version 1.0

@intro:
*/
public class Demo14有符号位移左位移运算 {
public static void main(String[] args) {

 // 左位移N,就是乘以2^N
 // 10 * 2^1
 System.out.println(10 << 1);       // 10 * 2 = 20

 // 10 * 2^2
 System.out.println(10 << 2);       // 10 * 4 = 40

 // 10 * 2^3
 System.out.println(10 << 3);       // 10 * 8 = 80

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

 // -10 * 2^1
 System.out.println(-10 << 1);       // -10 * 2 = -20

 // -10 * 2^2
 System.out.println(-10 << 2);       // -10 * 4 = -40

 // -10 * 2^3
 System.out.println(-10 << 3);       // -10 * 8 = -80

}
}
```

2）右移位运算

正数的右移：如10 >> 2，左边自动补0，右边移出位舍弃，即00001010 —> 00000010，结果是2，实际的意思是，每向右移动一位，就相当于除以2，小数舍弃，即10/2/2=2.5，舍弃小数，结果就是2。
```
10: 00000000 00000000 00000000 00001010
10 >> 2: 00000000 00000000 00000000 00000010 : 2

相当于: 10 / 2^2 = 2.5 = 2

4: 00000000 00000000 00000000 00000100
4 >> 2: 00000000 00000000 00000000 00000001 : 1

相当于: 4 / 2^2 = 1


- 负数的右移：如-2 >> 2，由于二进制的首位为符号位，负数在右移过程中，为了保持负数的特性，**所以左边会自动补1而不是0**，即11111110 --> 11111111，结果为-1。

-2: 11111111 11111111 11111111 11111110
-2 >> 2: 11111111 11111111 11111111 11111111 : -1

相当于: -2 / 2^2 = -1(特殊情况)

-8: 11111111 11111111 11111111 11111000
-8 >> 2: 11111111 11111111 11111111 11111110 : -2

相当于: -8 / 2^2 = -2

Tips：**有符号右位移N，就是除以2^N**
有符号右位移代码：

/**

@author lscl
@version 1.0
@intro:
*/
public class Demo15有符号位移右位移运算 {
public static void main(String[] args) {
```
 // 有符号右位移N,就是除以2^N
 // 10 / 2^2
 System.out.println(10 >> 2);      // 2

 // 4 / 2^2
 System.out.println(4 >> 2);      // 1

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

 // -2 / 2^1
 System.out.println(-2 >> 2);      // -1

 // -8 / 2^2
 System.out.println(-8 >> 2);      // -2
```
}
}
```

3.6.2 无符号位移
无符号右位移：所谓的无符号右移，就是无论是正数还是负数，高位通通补0。**另外无符号位移没有左位移运算。
如：-2 >>> 2，对于负数的有符号右移在左边自动补1，但是对于无符号右移，左边是自动补0**。

1）对于正数而言，>>和>>>没区别。
```
2: 00000000 00000000 00000000 00000010
2 >>> 1: 00000000 00000000 00000000 00000001 : 1

相当于: 2 / 2^1 = 1

8: 00000000 00000000 00000000 00001000
8 >>> 2: 00000000 00000000 00000000 00000010 : 2

相当于: 8 / 2^2 = 2


- 2）但是对于负数而言：**由于无符号右移位不管是正数还是负数，高位通通补0**，这样下来就会出现这样的问题：
   - -2 >>> 1：结果是2147483647（Integer.MAX_VALUE）

-2: 11111111 11111111 11111111 11111110

-2 >>> 1: 01111111 11111111 11111111 11111111(变为正数了) : 2147483647(int的最大值)


- -1 >>> 1：结果是2147483647（Integer.MAX_VALUE）

-1: 11111111 11111111 11111111 11111111

-1 >>> 1: 01111111 11111111 11111111 11111111(变为正数了) : 2147483647(int的最大值)


- -2 >>> 2：等于 Integer.MAX_VALUE / 2

-2: 11111111 11111111 11111111 11111110
-2 >>> 2: 00111111 11111111 11111111 11111110(变为正数了) : 1073741822

无符号右位移：

/**

@author lscl
@version 1.0

@intro:
*/
public class Demo16_无符号位移运算 {
public static void main(String[] args) {

 // 由于无符号右移都是在左边补0,因此对于正数而言和有符号位移是一样的,都是: 无符号右位移N,就是除以2^N
 // 2 / 2^1
 System.out.println(2 >>> 1);      // 2 / 2 = 1

 // 8 / 2^2
 System.out.println(8 >>> 2);      // 8 / 4 = 2

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

 // 对于负数而言,在左边补0将会把负数变为了正数,因此无符号右移会出现非常大的int数

 // 11111111 11111111 11111111 11111110 ---> 01111111 11111111 11111111 11111111(变为正数了)
 System.out.println(-2 >>> 1);      // 2147483647

 // 11111111 11111111 11111111 11111111 ---> 01111111 11111111 11111111 11111111(变为正数了)
 System.out.println(-1 >>> 1);      // 1073741823

 // 11111111 11111111 11111111 11111110 ---> 00111111 11111111 11111111 11111110(变为正数了)
 System.out.println(-2 >>> 2);      // 1073741823

}
}
```
Tips：左移位运算只有无有符号位移，没有无符号位移运算；

Java中运算符的详细使用

三、运算符

3.1 算术运算符

3.1.1 基本运算

3.1.2 ++和—

3.1.3 +=运算

3.1.4 字符串注意事项

3.1.5 常量和变量的运算

3.2 赋值运算符

3.3 比较运算符

3.4 逻辑运算符

3.4.1 运算规则

3.4.2 代码示例

3.4.3 特殊情况

1）短路与运算

3.6 位移运算

3.6.1 有符号位移

1）左移位运算

2）右移位运算

3.6.2 无符号位移

最热文章

Java中运算符的详细使用

三、运算符

3.1 算术运算符

3.1.1 基本运算

3.1.2 ++和—

3.1.3 +=运算

3.1.4 字符串注意事项

3.1.5 常量和变量的运算

3.2 赋值运算符

3.3 比较运算符

3.4 逻辑运算符

3.4.1 运算规则

3.4.2 代码示例

3.4.3 特殊情况

1）短路与运算

3.6 位移运算

3.6.1 有符号位移

1） 左移位运算

2） 右移位运算

3.6.2 无符号位移

最热文章

1）左移位运算

2）右移位运算