java基础之---运算符

1. 算术运算符

概念

1. “+” 加法运算符
2. “-” 减法运算符
3. “*” 乘法运算符
4. “/” 除法运算符
5. “%” 求余/取模运算符

实践出真理

int ia = 5;
int ib = 16;

System.out.println(" +  运算符 ： " + (ia + ib));   //  21
System.out.println(" -  运算符 ： " + (ia - ib));   //  -11
System.out.println(" *  运算符 ： " + (ia * ib));   //  80
System.out.println(" /  运算符 ： " + (ia / ib));   //  0
System.out.println(" %  运算符 ： " + (ib % ia));   //  1

注意事项

//当两个整数相除时结果只保留整数部分，丢弃小数部分
System.out.println((5 / 2));      // 2

//保留小数方式一：
System.out.println((double) 5 / 2);
System.out.println(5 / (double) 2);
System.out.println((double) 5 / (double) 2);
//无效处理
System.out.println((double) (5 / 2));
//方式二： 
System.out.println(ia * 1.0 / ib);      //通过 1.0 改变原来数据的类型

// 0 不能作除数
System.out.println(ia * 1.0 / 0);  //可以通过编译，运行时发生 java.lang.ArithmeticExcetion(算术异常/Infinity) by zero

System.out.println(ia * 1.0 / 0.0);     // Infinity 无穷
System.out.println(0.0 / 0.0);          // NaN(Not a Number)

应用

• 通过输入一个正整数类型的秒数，通过拆分秒数后输出x小时x分钟x秒

  System.out.println("请输入一个正整数： ");
  Scanner sc = new Scanner(System.in);
  int num = sc.nextInt();
  
  int hour = num / 3600;
  int minute = num % 3600 / 60;
  int second = num % 60;
  
  System.out.println(num + "转换为： " + hour + "小时" + minute + "分钟" + second + "秒");
  

• 结果
  

2. 字符串连接运算符"+"

• “+” 可以实现字符串的连接，同时可以实现字符串与其他数据类型“相连”

实践出真理

此处代码接拆分整数应用代码

  // 区分 "+"作为加法运算符与字符串连接符
  // 当 "+" 两边的操作数中有一个操作数是字符串类型，则该"+"就被当做字符串连接符处理；否则当做 加法运算符处理

 System.out.println(hour + minute + second);   //当做 加法运算进行相加
 System.out.println(hour + minute + second + "A");   //hour、minute、second进行算术相加后的数值当做字符串连接 "A"
 System.out.println(hour + minute + "A" + second);   //hour、minute进行加法运算后连接"A"后连接second
 System.out.println(hour + "A" + minute + second);   
 System.out.println("A" + hour + minute + second);
 System.out.println("A" + (hour + minute + second));

结果

3. 关系/比较 运算符

概念

1. “>” 是否大于
2. “>=” 是否大于等于
3. “<” 是否小于
4. "<= " 是否小于等于
5. “==” 是否等于
6. “!=” 是否不等于

实践出真理

int ia = 5;
int ib = 3;

System.out.println(ia < ib);        //false
System.out.println(ia <= ib);       //false
System.out.println(ia > ib);        //true
System.out.println(ia >= ib);       //true
System.out.println(ia == ib);       //false
System.out.println(ia != ib);       //true

应用示例

//判断输入的整数是否为负数
System.out.println("请输入任意一个整数");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();

boolean b = num >= 0;
System.out.println(b ? "输入的数字为正整数" : "输入的整数为负数");

结果

4. 自增减运算符

1. ++ 自增运算符 当前变量的数值 +1
2. – 自减运算符 当前变量的数值 -1
3. ！！只能用于变量 ，常数不可以！！

实践出真理

int ia = 8;

System.out.println("当前ia的值为："+ia);               // 8
ia++;
System.out.println("自增运算符后的结果为： "+ia);       // 9
++ia;
System.out.println("自增运算符后的结果为： "+ia);       // 10
ia=10;
ia--;
System.out.println("自减运算符后的结果为： "+ia);        // 9
--ia;
System.out.println("自增运算符后的结果为： "+ia);         //8

System.out.println(ia++ + ++ia);                        // 18 (8+10)

i++ 与 ++i 的区别

1. i++ 与 ++i 表示不同的含义，占用不同的内存空间
2. i++ 先赋值再运算
   表示先让 i 的数值作为整个表达式的最终结果，再让 i 变量自身的数值 +1；
   a = i++ 先赋值 a = i,后运算 i= i+1 ，最终的结果 a == i++ 运算前的数值
3. ++i 先运算后赋值
   表示先让变量 i 的数值+1 ，然后再让变量的数值作为整个表达式的结果
   a = ++i 先运算 i=i+1,后赋值 a = i,最终的结果为 i=i+1后的结果

i++ 与 ++i 执行效率上的区别

分析

• 总结
  只有在必要时才使用后置操作符
  因为前置操作需要做的工作更少，只需要加1后返回加1后的结果即可。而后置操作符则必须先保存操作数原来的值，以便返回未加1之前的值作为操作的结果。对于int对象和指针，编译器可优化掉这项额外工作。但是对于更多的复杂迭代器类型，这种额外工作可能会花费更大代价

5. 逻辑运算符

概念

1. && ：and 表示逻辑 与 运算符
   • 同真为真（true && true：结果为true），一假为假（false&&true：结果为false）
   • 只有当两个条件同为 true 时，结果才为：true
2. || ：or 表示逻辑 或 运算符
   • 一真为真（true || true：结果为true），同假为假（false||false：结果为false）
   • 只有当两个条件同为 false时，结果才为：false
3. ! ：not 表示逻辑 非 运算符
   • 取反 为 true 时结果为：false；为 false 时结果为 true

• 逻辑运算符

左操作数 b1	右操作数 b2	&&与	或	！b1
false	false	false	false	true
false	true	false	true
true	false	false	true	false
true	true	true	true

• 实践出真理

 //逻辑运算符的操作数均为 boolean 类型
    boolean b1 = true
    boolean b2 = false 

    System.out.println( b1 && b2)   // false
    System.out.println( b1 || b2)   // true
    System.out.println(  !b1 )      // false
    System.out.println(  !b2)       // true

短路特性

• && 逻辑与
  若第一个表达式为 false，则结果为false：此时 跳过 第二个表达式

  int left = 3
  int right = 5
  
  boolean jude_and = left==right && (++right==6)
  System.out.println( "判断的结果为："+ jude_and +"/n"+ left +" ::: "+ right)     
  // 判断的结果为： false  3  5
  // 此情况下第二个表达式 ++right==6 因为短路特性并没有执行
  

• || 逻辑或
  若第一个表达式为 true ，则结果为 true：此时 跳过 第二个表达式

  int left = 3
  int right = 5
  
  boolean jude_and = left==3 && (++right==6)
  System.out.println( "判断的结果为："+ jude_and +"/n"+ left +" ::: "+ right)     
  // 判断的结果为： true  3  5
  // 此情况下第二个表达式 ++right==6 因为短路特性并没有执行
  

应用示例

//判断一个数字是否为三位数
System.out.println("请输入一个正整数：  ");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt(); 
		
System.out.println(100<=num && num<=999); 

运行截图

6. 三目运算符（条件运算符）

概念

• 条件表达式？表达式1：表达式2
• 判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2

示例

1. 判断一个整数是否是三位数

   System.out.println("请输入一个正整数：  ");
   Scanner sc = new Scanner(System.in);
   int num = sc.nextInt();
   System.out.println(num + (100<=num && num<=999?":是三位数":":不是三位数"));
   

   运行结果：
   

2. 查找最大的值

   System.out.println("请输入两个正整数：  ");
   Scanner sc = new Scanner(System.in);
   int a = sc.nextInt();
   int b = sc.nextInt();
   
   int maxNum = a > b ? a : b;
   System.out.println("输入的两个整数中最大的是： " + maxNum);
   

   运行结果 ：
   

7. 赋值运算符

单一运算符

• “=”

1. 赋值运算符，将右边的数据（值）赋值给 = 左边的变量，覆盖变量原来的值
2. 赋值表达式本身也有值，其本身值即为所赋之值

复合运算符

• “+=、-=、*=、/=”

实践出真理

int testNumT = 5;
System.out.println("初始的值为： " + testNumT);
System.out.println("表达式的值为： " + (testNumT = 5));     //表达式的值为： 5
testNumT = 6;
System.out.println("单一赋值运算符 = ：" + testNumT);  //单一赋值运算符 = ：6
System.out.println("---------复合运算符--------");
testNumT += 1;
System.out.println("复合运算符 += ： " + testNumT);    // 复合运算符 += ：7
testNumT -= 1;
System.out.println("复合运算符 -= ： " + testNumT);    // 复合运算符 -= ：6
testNumT *= 3;
System.out.println("复合运算符 *= ： " + testNumT);    // 复合运算符 *= ：18
testNumT /= 6;
System.out.println("复合运算符 /= ： " + testNumT);    // 复合运算符 /= ：3

补充内容

• byte转int

  byte b = 3;
  //b=b+2;            //错误： 从int转换到byte可能会有损失 【byte】最大值为：127
  //b= b+(byte)2;     //错误： 从int转换到byte可能会有损失
  b += 2;             //等价于 b= (byte)(b+2);
  System.out.println("当前b的值为: " + b);
  

• "="与 “==” 比较

  int ia = 3;
  ia == 2;   //判断变量 ia 的数值是否等于3
  2 == ia;   //判断2是否等于变量ia的数值  
  //以上两种方式从结果看一样的，推荐实际中采用第二种方式
  ia = 2;   //将2赋值给变量ia，覆盖ia原来的值
  //2 = ia //错误：意外的类型  2为数值，不可以当作变量使用
  

8. 移位运算符

概念

• 通过移动二进制位的操作

<< 左移运算符

• 将数据的二进制位向左移动，右边使用 0 补充
• 实践出真理

  byte b_Shift = 13;
  System.out.println(b_Shift << 1);     //26
  System.out.println(b_Shift << 2);     //52
  

• 过程分析
  13的二进制为： 0000 1101
  向左移动一位后为： 0001 1010
  0001 1010 转换为十进制 ： 0+12^1+0+1*23+12^4 = 0+2+0+8+16 = 26

应用（效果）

• 左移 1 位 相当于当前的 数值*2
• 左移 2 位 相当于当前的 数值*4

>> 右移运算符

• 将数据的二进制向右移动，左边使用 符号位 补充

  byte b_Shift = 13;
  System.out.println(b_Shift >> 1);     //6
  System.out.println(b_Shift >> 2);     //3
  

应用（效果）

• 左移 1 位 相当于当前的 数值/2
• 左移 2 位 相当于当前的 数值/4

>>> 逻辑右移运算符

• 或称为：无符号右移运算符（无符号右移等同于非负数时的 “>>”）
• 将数据的二进制位向右移动，左边使用 0 补充

9. 位运算符

概念

• & 按位 与 运算符 同 1 为 1 ，同 0 为 0 如果相对应位都是1，则结果为1，否则为0
• | 按位 或 运算符 -1 为 1 ，同 0 为 0 如果相对应位都是 0，则结果为 0，否则为 1
• ~ 按位 取反 运算符 按照二进制位进行取反， 1 为 0 ，0 为 1 按位取反运算符翻转操作数的每一位，即0变成1，1变成0
• ^ 按位 异或 运算符 按照二进制进行异或运算 ，同为 0 ，不同为 1 如果相对应位值相同，则结果为0，否则为1

实践

byte b1 = 11;   // 0000 1011
byte b2 = 13;   // 0000 1101

// & 按位 与
System.out.println(b1 & b2);    // 9
// | 按位 或
System.out.println(b1 | b2);     // 15
// ~ 按位 取反
System.out.println(~b1);          // -12
// ^ 按位 异或
System.out.println(b1 ^ b2);        // 6

10.运算符优先级

• 最高优先级的运算符在的表的最上面，最低优先级的在表的底部
  
• 总结

1. ()的优先级极高
2. =的优先级极低

---