JavaSE基础学习笔记Day03

                                                        *运算符*

Java中用来运算的符号

 

赋值运算符

 =  // 在java中赋值运算符是唯一一个自右向左进行运算的
     
int num = 20; 

算数运算符

+ - * / % ++ --

// 测试算数运算符
public class ArithTest01{
	public static void main(String[] args) {
		

		//1： + 号
		int num = +4; //正号
		System.out.println(num);


		//+号
		num = 4+6;
		System.out.println(num);


		// 连接符号 String 字符串
		System.out.println("abcd"+"efg"); // 拼接称为一个新的字符串 "abcdefg"

		System.out.println("abcd"+1); // 拼接称为一个新的字符串 "abcd1"

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

	}
}

主要记忆+的连接符号的作用

• 当左右两边有一个操作数是String字符串的时候，此时+是连接符号，会将左右两边的操作数连接成为一个新的字符串；

// 测试使用其他的运算符
public class ArithTest02{
	public static void main(String[] args) {	
		// / % 

		// 声明一个变量 将当前该变量中每一位上的值依次取出
		int num = 1234;
		//1：声明一个变量存储最低位的值
		int bit = num%10;
		System.out.println("1234的个位数字是："+bit);
		//2：改变num的值
		num = num/10;
		System.out.println("修改num的值后，num是："+num);
		// 取十位数字
		bit = num%10;
		System.out.println("1234的十位数字是："+bit);
		num = num/10;
		System.out.println("修改num的值后，num是："+num);
		//取百位数字
		bit = num%10;
		System.out.println("1234的百位数字是："+bit);
		num = num/10;
		System.out.println("修改num的值后，num是："+num);
		bit = num%10;
		System.out.println("1234的千位数字是："+bit);
		num = num/10;
		System.out.println("修改num的值后，num是："+num);
	}
}

// 测试++ -- 运算符
public class ArithTest03{
	public static void main(String[] args) {
		
		//++ 


		//1：声明一个变量 
		int num = 10;


		//2：++ -- 单目运算符
		++num; //自增1


		//3: 输出一下当前num的值
		System.out.println("num++之后num的值："+num);



		//4：重新给num赋值
		num = 10;


		//5： 获取一下当前自增表达式之后的结果
		int result = ++num; //num++  n=11 r=10 ++num n=11 r=11


		//6：打印输出num和resule的结果
		System.out.println("num=["+num+"],resule=["+result+"]");




		// 重新给num赋值
		num = 5;

		num--;

		System.out.println("num："+num);



		num = 5;


		result = --num;

		System.out.println("num："+num+"result:"+result);

	}
}

• ++ --是单目运算符

• 如果是单独一条语句的情况下：

  • ++ 在前 在后无所谓的 都是让当前变量自增1

  • -- 在前 在后无所谓的 都是让当前变量自减1

• 如果不是单独的一条语句的时候：

  • ++ 在前 先自增 再运算 ++在后 先运算 在递增

  • --在前 先自减 再运算 --在后 先运算 在递减

扩展运算符

本质上而言就是算数+赋值或者是位+赋值。

+= -= *= /= %= >>= &= |=

// 测试使用扩展运算符
public class ExtendsTest{
	public static void main(String[] args) {
		

		// 计算两个学生的分数之和

		//1：声明两个学生的分数
		int zhangScore = 149;
		int liScore = 132;

		//2：声明一个变量存储累加的和
		int sum = 0;

		sum +=   zhangScore; // 等价=> sum = sum + zhangScore;
		sum +=  liScore;


		//3：打印输出一下
		System.out.println("两个学生的分数之和是："+sum);



		// 测试扩展运算符的另外一项特点

		int n = 20;
		byte m = 0;

		m += n; // m = m+n;
		System.out.println(m);



	}
}

• 优势

  • 提升开发效率 少写单词

  • 提高了编译速度

  • 自动强制类型转换

• 缺点

  • 不利于阅读 可读性差

关系运算符

> < >= <= == != instanceof

// 测试关系运算符
public class RelationalTest{
	public static void main(String[] args) {
		
		//1： 关系运算符的结果是一个boolean类型的值
		boolean flag = 5>4;
		System.out.println(flag);
		flag = 5<4;
		System.out.println(flag);
		//flag = true > false;
		//System.out.println(flag);
		flag = 'a'<'A';
		System.out.println(flag);
		String str1 = "hehe";
		String str2 = "haha";
		//flag = str1>str2;
		System.out.println(flag);
		// == != 
		flag = 5==4;
		System.out.println(flag);

		flag = true != false;
		System.out.println(flag);
		flag = str1==str2;
		System.out.println(flag);
		// instanceof只能比较引用类型 判定当前某个值是否是属于某个类型的
		flag = "zhangsan" instanceof String;
		System.out.println(flag);


	}
}

• > < >= <= 只能比较基本数据类型(除了boolean类型以外)

• != == 可以比较的所有的数据类型的数据

• instanceof只能比较引用类型 判定当前某个值是否是属于某个类型的

• 关系运算符的最后的结果是一个boolean值；

逻辑运算符

& | && || ^ !

• 最后的结果是一个boolean类型的值

• 逻辑运算符左右两边的操作数一定是一个boolean值

// 测试逻辑运算符
public class Logic{
	public static void main(String[] args) {
		System.out.println("===== 测试逻辑& 且 =====");
		System.out.println( true & false );
		System.out.println( true & true );
		System.out.println( false & false );
		System.out.println( false & true );
		System.out.println("===== 测试逻辑&& 双& 短路与 =====");
		System.out.println( true && false );
		System.out.println( true && true );
		System.out.println( false && false );
		System.out.println( false && true );
		System.out.println("===== 测试逻辑| 或 =====");
		System.out.println( true | false );
		System.out.println( true | true );
		System.out.println( false | false );
		System.out.println( false | true );
		System.out.println("===== 测试逻辑|| 短路或 =====");
		System.out.println( true || false );
		System.out.println( true || true );
		System.out.println( false || false );
		System.out.println( false || true );
		System.out.println("===== 测试逻辑取反 ！ =====");
		System.out.println(!true);
		System.out.println(!false);
		System.out.println("===== 测试逻辑^ 逻辑异或 =====");
		System.out.println( true ^ false );
		System.out.println( true ^ true );
		System.out.println( false ^ false );
		System.out.println( false ^ true );
	}
}

• 异或： 相同为false 不同为true

• &和&& 的区别： 只有两个操作数都为true ，结果才为true，所以第一个操作数如果是false的情况下，&&是不会判定和执行第二个操作数的，所以效率上优于&

• |和|| 的区别： 只有两个操作数都为false ，结果才为false，所以第一个操作数如果是true的情况下，||是不会判定和执行第二个操作数的，所以效率优于|

条件运算符 三目运算符

expression01?expression02:expression03;

会判定表达式1的结果 表达式1的结果只能是true或者时false
如果表达式1的结果时true  则整个条件运算符的结果是表达式2的值 
反之如果表达式1的结果是false，则整个条件运算符的结果是表达式3的值；

// 测试使用条件运算符
public class Condition{
	public static void main(String[] args) {
		

		// 声明两个变量 计算两个变量中的最大值

		int num1 = 20;
		int num2 = 40;

		// 使用条件运算符
		boolean flag = num1>num2;


		int max = flag?num1:num2;

		System.out.println("num1和num2的最大值是："+max);

		// 计算三个变量中的最大值
		int num3 = 44;


		//max = max>num3?max:num3;


		//System.out.println("num1和num2、num3的最大值是："+max);

		System.out.println("num1和num2、num3的最大值是："+(num1>num2?num1:num2>num3?num1>num2?num1:num2:num3));
	}
}

位运算符

& | ^ >> << >>> ~ 计算效率特别高，基于二进制

public class BitTest01{

	public static void main(String[] args) {
		/*			
            0101
		   ------
		    0100 ->4 	
		*/
		System.out.println(4&5);
		String msg = (33&1) == 0 ? "yes":"no";
		System.out.println(msg);
		/*			
			0100
            0101
		   ------
		    0101 ->5 	
		*/
		System.out.println(4|5);
		/*		
			0100
	        0101
		   ------
		    0001 ->1 	
		*/
		System.out.println(4^5);
		// 交换两个变量中的值
		int n1 = 20;
		int n2 = 30;
		System.out.println("n1："+n1+"，n2："+n2);
		int temp = 0;
		temp = n1;
		n1 = n2;
		n2 = temp;	
		System.out.println("n1："+n1+"，n2："+n2);
		// 使用异或交换
		n1 = n1^n2;
		n2 = n1^n2; // n1^n2 ^ n2
		n1 = n1^n2; // n1^n2   n1^n2 ^ n2
		System.out.println("n1："+n1+"，n2："+n2);
		// 取反
		/*
	        0 0101
		   ------
		    1 1010 -->	1 1001 -> 1 0110 = -6 
		*/
		System.out.println(~5);
		// >> 右移  M>>N = M/2^N  
		System.out.println(-32>>4);
		// << 左移 M<<N = M*2^N  
		System.out.println(4<<3);
		// >>> 无符号右移 M>>>N
		System.out.println(-32>>>4);
		// 计算一个数字中二进制里1的个数 5 --> 2    -5 --> 31


	}

}

运算符优先级

• 要想先算加括号

• 不要试图通过优先级控制程序的执行顺序

• 大方向的优先级顺序

  • 算数 > 关系 > 逻辑 > 条件 > 赋值

  • 单目>双目>三目

boolean flag = ('A'+32 > (77 ^ 1)) & false