JavaSE---------基础知识点03（各类运算符的使用）

public class Test01{

    public static void main(String[] args){

        int num1=10;
        int num2=5;

        System.out.println(num1 + num2);//15
        
        System.out.println(num1 - num2);//5

        System.out.println(num1 * num2);//50

        System.out.println(num1 / num2);//2

        System.out.println(num1 % num2);//0
    }
}

1.2、自增

1.2.1、先自增，再使用

public class Test02{

    public static void main(String[] args){

        int a = 10;
        System.out.println(++a);//11
        System.out.println(a);//11
    }
}

1.2.2、先使用，再自增

public class Test03{

    public static void main(String[] args){

        int b =10;
        System.out.println(b++);//10
        System.out.println(b);//11
    }
}

1.3、自减

1.3.1、先自减，再使用

public class Test04{

    public static void main(String[] args){

        int c=10;
        System.out.println(--c);//9
        System.out.println(c);//9
    }
}

1.3.2、先使用，再自减

public class Test05{

    public static void main(String[] args){

        int d = 10;
        System.out.println(d--);//10
        System.out.println(d);//9
    }
}

2、深入算数运算符

2.1、案例

2.1.1、案例一：byte类型做运算，会向上转型成int类型

public class Test06{

    public static void main(String[] args){

        byte b1 = 10;
        byte b2 = 20;
        //10 - byte --8位： 0000，1010
        //10 - int  --32位：0000,0000,0000,0000,0000,0000,0000,1010
        //20 - byte - 8位:0001,0100
		//20 - int  -32位:0000,0000,0000,0000,0000,0000,0001,0100
		//30 - int  -32位:0000,0000,0000,0000,0000,0000,0001,1110
		//30 - byte - 8位:0001,1110
		byte result = (byte)(b1+b2);
        System.out.println(result);
    }
}

2.1.2、案例二：short类型做运算，会向上转型成int

public class Test07{

    public static void main(String[] args){

        short s1 = 10;
		short s2 = 20;

		short result = (short)(s1+s2);
		System.out.println(result);
    }
}

2.1.3、案例三：描述下列计算结果的类型

            byte b = 10;
			short s = 10;
			int i = 10;
			long l = 10;
			float f = 1.1F;
			double d = 2.2;
			System.out.println(b+s);//int类型
			System.out.println(i+s);//int类型
			System.out.println(l+s);//long类型
			System.out.println(i+l);//long类型
			System.out.println(i+f);//float类型
			System.out.println(i+d);//double类型

2.1.4、案例四：浮点类型不能直接做运算，要做运算会使用BigDecimal

            //由于浮点类型直接做运算会产生误差，如下：
            double d1 = 0.5;
			double d2 = 0.4;
			System.out.println(d1-d2);//0.09999999999999998

2.1.5、案例五：char类型与int类型相加时，char类型转换成ASCII的值

            //'a'的ASCII是97
			char c = 'a';
			System.out.println(c+1);//98

2.2经典面试题：

2.2.1、面试题一：

            //输出结果为？
			int a = 8;
			int b = (a++)+(++a)+(a*10);//可拆分为：c=a++ ; d=++a ; 
            //c=a++时， c=8;因为a++先使用，后自增，所以此时a自增长到9；
            //d=++a时， ++a为  先自增，后使用，即，在原来自增到9上面再次自增到10；即d=10;
            //故此，int b = 8 + 10 + (10*10);
            //所以 b=8 + 10 + 100;
    
			System.out.println(b);//因此，在这里打印出118

2.2.2、面试题二：

            //输出结果为？
			int i =  0;   
			i = ++i; 
			//底层原理：
			//i = (int)(i+1);
			//i = i;
			System.out.println(i);//1
			
			int i = 0;   
			i = i++;  
			//底层原理：
			//int temp = i;--temp用于记录i最初的值
			//i = (int)(i+1);
			//i = temp
			System.out.println(i);//0

2.3、拓展

2.3.1拓展一：整数类型的先自增，在使用

            byte b = 10;
			++b;//底层：b = (byte)(b+1);
			short s = 10;
			++s;//底层：s = (short)(s+1);
			int i = 10;
			++i;//底层：i = (int)(i+1);
			long l = 10;
			++l;//底层：l = (long)(l+1);

2.3.2拓展二：++i;与i++;无区别

            int a = 10;
            int b = 10;
			//++a; 和 b++; 没有区别，因为分号是一条执行语句的结束，不管先加还是后加都给我加
			
            ++a;
			b++;
			System.out.println(a);
			System.out.println(b);

3、赋值运算符

知识点：赋值运算符

=（等）、+=（加等）、-=（减等）、*=（乘等）、/=（除等）、%=(余等）

3.1、赋值运算符的基本使用

public class Test{

    public static void main(String[] args){
        int i = 10;
        i += 10;//i = (int)(i+10);
		i -= 10;//i = (int)(i-10);
		i *= 5 ;//i = (int)(i*5);
		i /= 5 ;//i = (int)(i/5);
		i %= 3 ;//i = (int)(i%3);
		System.out.println(i);//1
    }
}

3.2、经典面试题

3.2.1、题一：

public class Test1{

    public static void main(String[] args){
        
        //输出结果为？
		//一次性声明多个变量
		int a,b; 
		a = b = 100;//把100赋值给b，b再赋值给a
		System.out.println(a);//100
		System.out.println(b);//100
    }
}

3.2.2、题二：

public class Test1{

    public static void main(String[] args){
        
        //下面的两种写法结果分别是？
		short s=1; 
		s = s+1;//报错：short类型的变量s 与 int类型的数字字面量1 做运算的结果是int类型 
		short s=1; 
		s += 1;//s = (short)(s+1);//s=2;
    }
}

赋值规则： short s = 1 ;
                                 s + = 1 s = (T)((s) + (1) )
               复合赋值 E1 op = E2等价于简单赋值 E1 = (T)((E1)op(E2))，
               其中T是E1的类型。

4、关系运算符

知识点：关系运算符

==（等于）、!=（不等于）、>（大于）、>=（大于等于）、<（小于）、<=（小于等于）

4.1关系运算符的基本运算

public class Test001{

    public static void main(String[] args){

        System.out.println(10 == 10);//true
		System.out.println(10 != 10);//false
		System.out.println(10 > 10);//false
		System.out.println(10 >= 10);//true
		System.out.println(10 < 10);//false
		System.out.println(10 <= 10);//true
    }
}

总结：
1.=是赋值号，==是判断两个值是否相等
2.关系运算符运算的结果都是boolean值

4.2、经典面试题

4.2.1、题一：

                int x = 10;
				int y = 10;
				boolean flag = (x == y);
				System.out.println(flag);//true
        //		flag = (x = y);//报错：boolean不能与其他类型兼容
        //		System.out.println(flag);

4.2.2、题二：

        boolean b1 = true;
		boolean b2 = false;
		boolean b3 = (b1 == b2);//因为true!=false,所以b3为false
		System.out.println(b3);//false
		boolean b4 = (b1 = b2);//将b2赋值给b1，再将赋值过后的b1赋值给b4
		System.out.println(b4);//false

5、逻辑运算符

   知识点：逻辑运算符

&与   &&短路与         |或   ||短路或 ^异或        !非

5.1、算术运算符的基本使用

public class Test04 {

	public static void main(String[] args) {

		//&与：前后两者都是boolean值，同时成立(true)，结果才为true
		System.out.println(true & true);//true
		System.out.println(true & false);//false
		System.out.println(false & true);//false
		System.out.println(false & false);//false
		
		//&&短路与：前后两者都是boolean值，同时成立(true)，结果才为true
		System.out.println(true && true);//true
		System.out.println(true && false);//false
		System.out.println(false && true);//false
		System.out.println(false && false);//false
		
		//& vs &&
		//&：判断前者为false后，才会判断后者
		//&&:判断前者为false后，不会判断后者，所以效率更高
		//ArithmeticException - 算数类异常
		System.out.println(false && 10/0>5);
		
		//|或：前后两者都是boolean值，有一个成立(true)，结果就为true
		System.out.println(true | true);//true
		System.out.println(true | false);//true
		System.out.println(false | true);//true
		System.out.println(false | false);//false
		
		//||短路或：前后两者都是boolean值，有一个成立(true)，结果就为true
		System.out.println(true || true);//true
		System.out.println(true || false);//true
		System.out.println(false || true);//true
		System.out.println(false || false);//false
		
		//| vs ||
		//|：判断前者为true，还会判断后者
		//||:判断前者为true，不会判断后者，所以效率更高
		System.out.println(true || 10/0>5);
		
		//^异或：前后两者都是boolean值，相同为false，不同为true
		System.out.println(true ^ true);//false
		System.out.println(true ^ false);//true
		System.out.println(false ^ true);//true
		System.out.println(false ^ false);//false
		
		//!非 - 置反
		boolean bool1 = true;
		System.out.println(!bool1);//false
		
		boolean bool2 = false;
		System.out.println(!bool2);//true
	}

}

5.2、知识点Scanner的引用

import java.util.Scanner;
/**
 * 知识点：Scanner类的使用
 * 含义：Java给我们提供的一个类，这个类的功能就是在控制台输入数据
 *
 */
public class Test06 {

	public static void main(String[] args) {
        //创建Scanner类的对象
		//人类	类名 = new 人类();
		Scanner scan = new Scanner(System.in);
				
		//调用功能
		int i1 = scan.nextInt();//在控制台输入一个int数据
		int i2 = scan.nextInt();//在控制台输入一个int数据
		double d = scan.nextDouble();//在控制台输入一个double数据
		String str = scan.next();//在控制台输入一个String数据
	}

}

5.3、逻辑运算符的案例

import java.util.Scanner;
/**
 * 知识点：逻辑运算符的案例
 * 在dos窗口输入一个数字，判断是否在50~100的区间内
 */
public class Test05 {

	public static void main(String[] args) {

		        //1.输入一个int数字
				Scanner scan = new Scanner(System.in);

				System.out.println("请输入一个int值：");
				int num = scan.nextInt();
				
				//2.判断是否在50~100的区间内
				boolean bool = num>50 && num<100;
				
				//3.输出结果
				System.out.println("该值是否在50~100的区间内：" + bool);
	}

}

6、字符串拼接符

知识点：字符串拼接符 +

           +两侧都是数值，此符号为算术运算符
           +有一侧或者两侧是字符串，此符号为字符串拼接符

6.1字符串拼接的使用

public class Test07{
	
	public static void main(String[] args){
		/**
			知识点：字符串拼接符 +
			
			+两侧都是数值，此符号为算术运算符
			+有一侧或者两侧是字符串，此符号为字符串拼接符
		*/
		
		System.out.println(1+2+"abc" + "def" +1+2);//3abcdeef12
		//				    3 +"abc" + "def" +1+2
		//					"3abc"	 + "def" +1+2
		//					"3abcdef"		 +1+2
		//					"3abcdef1"		   +2
		//					"3abcdef12"
		
	}
}

7、三目运算符/三元运算符

知识点：三目运算符/三元运算符

           语法：
               数据类型变量 = (表达式)?值1:值2;

           理解：
               表达式的结果必须是boolean类型
               true - 将值1赋值给变量
               false- 将值2赋值给变量

            做实验：
           int num = (false)?10:20;
           System.out.println(num);

7.1、三目运算符/三元运算符的案例

7.1.1案例一

public class Test08 {

	public static void main(String[] args) {

//		案例1：在控制台输入两个int类型的数字，输出最大值
			//创建Scanner类的对象scan
			Scanner scan = new Scanner(System.in);
			
			//输入两个数字
			System.out.println("请输入第一个数字：");
			int a = scan.nextInt();
			System.out.println("请输入第二个数字：");
			int b = scan.nextInt();
			
			//判断大小
			int max = (a>b)?a:b;//判断a是否大于b，如果大于就返回a，否则返回b
			
			//输出最大值
			System.out.println("最大值为：" + max);
			
	}

}

7.1.2案例二

public class Test08 {

	public static void main(String[] args) {

//		案例2：在控制台输入两个int类型的数字，输出最小值
			//创建Scanner类的对象scan
			Scanner scan = new Scanner(System.in);
			
			//输入两个数字
			System.out.println("请输入第一个数字：");
			int a = scan.nextInt();
			System.out.println("请输入第二个数字：");
			int b = scan.nextInt();
			
			//判断大小
			int min = (a<b)?a:b;//判断a是否大于b，如果小于就返回a，否则返回b
			
			//输出最大值
			System.out.println("最小值为：" + min);
			
	}

}

7.1.3案例三

public class Test08 {

	public static void main(String[] args) {

//		案例3：在控制台输入三个int类型的数字，输出最大值
			Scanner scan = new Scanner(System.in);

			System.out.println("请输入第一个数字：");
			int a = scan.nextInt();
			System.out.println("请输入第二个数字：");
			int b = scan.nextInt();
			System.out.println("请输入第三个数字：");
			int c = scan.nextInt();
			
			int max = (a>b)?a:b;
			max = (max>c)?max:c;
			
			System.out.println("最大值为：" + max);
			
	}

}

7.1.4、案例四

public class Test08 {

	public static void main(String[] args) {

//		案例4：在控制台输入三个int类型的数字，由小到大输出
                Scanner scan = new Scanner(System.in);
	
				System.out.println("请输入第一个数字：");
				int a = scan.nextInt();
				System.out.println("请输入第二个数字：");
				int b = scan.nextInt();
				System.out.println("请输入第三个数字：");
				int c = scan.nextInt();
				
				//获取最大值
				int max = (a>b)?a:b;
				max = (max>c)?max:c;
				//获取最小值
				int min = (a<b)?a:b;
				min = (min<c)?min:c;
				//获取中间值
				int mid = a+b+c-max-min;
				
				System.out.println(min + "<" + mid + "<" + max);

	}

}

7.2、扩展面试题：

public class Test09{
	
	public static void main(String[] args){
			
//			扩展面试题1：
				int a = 5;
				System.out.println((a<5)?10.9:9);//9.0
				
//			扩展面试题2：
				char x = 'x';//'x' - ASCII - 120
				int i = 10;
				System.out.println(false?i:x);//120
				
//			扩展面试题3：
				char m = 'x';//'x' - ASCII - 120
				System.out.println(false?100:m);//x
				System.out.println(false?65536:m);//120
				
	}
}

7.3、三目运算符返回值规则：

1.值1和值2是常量的情况，就会按照取值范围大的类型返回数据
2.值1和值2是变量的情况，就会按照取值范围大的类型返回数据
3.值1是常量，值2是变量的情况，值1是否在值2所属类型的取值范围里
在，就按照值2类型返回数据
不在，就按照值1类型返回数据

8、位运算符

知识点：位运算符

           &与 |或 ^异或         << 左移        >> 右移        >>>无符号位右移

           含义：将十进制的数据转换为二进制再进行运算

8.1、位运算符的基本使用

public class Test10 {

	public static void main(String[] args) {

		byte a=23;// 0001,0111
		byte b=25;// 0001,1001
		
		//23 byte --- 0001,0111
		//23 int  --- 0000,0000,0000,0000,0000,0000,0001,0111
		//25 byte --- 0001,1001
		//25 int  --- 0000,0000,0000,0000,0000,0000,0001,1001
		
//		byte result = (byte)(a & b);System.out.println(result);==System.out.println(a & b);
		
		System.out.println(a & b);// 0001,0001  // &：同位比较，两者相同时为1，就为1
		
		System.out.println(a | b);// 0001,1111  // |：同位比较，两者有一个为1，就为1
		
		System.out.println(a ^ b);// 0000,1110; // ^：同位比较，两者相同时为0，不同时为1
	
		//  &、|、^：前后两者都是数值，该符号为位运算符
	
		//	&、|、^：前后两者都是boolean值，该符号为逻辑运算符

		
		//<<：整体向左移动n位，就用n个0补位
		byte b1 = 10;//0000,1010
		//10 byte:0000,1010
		//10  int:0000,0000,0000,0000,0000,0000,0000,1010
		//40  int:0000,0000,0000,0000,0000,0000,0010,1000
		System.out.println(b1 << 2);
		
		//>>：整体向右移动n位，就用n个最高位补位
		byte b1 = 10;//0000,1010
		//10 byte:0000,1010
		//10  int:0000,0000,0000,0000,0000,0000,0000,1010
		//2		 :0000,0000,0000,0000,0000,0000,0000,0010
		System.out.println(b1 >> 2);
		
		byte b2 = -10;//1111,0110
		//-10 byte:1111,0110
		//-10  int:1111,1111,1111,1111,1111,1111,1111,0110
		//-3 	  :1111,1111,1111,1111,1111,1111,1111,1101
		System.out.println(b2 >> 2);
		
		//>>>：整体向右移动n位，就用n个0补位
		byte b1 = 10;//0000,1010
		//10 byte:0000,1010
		//10  int:0000,0000,0000,0000,0000,0000,0000,1010
		//2		 :0000,0000,0000,0000,0000,0000,0000,0010
		System.out.println(b1 >>> 2);
		
		byte b2 = -10;//1111,0110
		//-10 byte:1111,0110
		//-10  int:1111,1111,1111,1111,1111,1111,1111,0110
		//1073741821:0011,1111,1111,1111,1111,1111,1111,1101
		System.out.println(b2 >>> 2);
	}

}

注意:>> 和 >>> 如果是操作正数，效果是一样的

8.2、经典面试题：

            经典面试题1：使用最有效率的方式计算2*8
				System.out.println(2<<3);
				
			经典面试题2：描述下列代码的输出结果
				//-1 int:1111,1111,1111,1111,1111,1111,1111,1111
				//(byte):1111,1111
				//(char):1111,1111,1111,1111 -- char类型向上转型用0补位
				//(int) :0000,0000,0000,0000,1111,1111,1111,1111
				System.out.println((int)(char)(byte)-1);//65535

9、表达式

5 + 6：算数表达式

5 > 6：关系表达式

true & false:逻辑表达式

5 | 6：位运算表达式

10、运算符的优先级别

知识点：运算符的优先级别
经验：不用记，灵活运用小括号

11、转义字符

知识点：转义字符

           含义：具有特殊意义的字符本身

           \n：表示换行
           \"：表示一个双引号
           \'：表示一个单引号
           \\：表示一个斜杠
           \t：表示水平制表

11、转义字符的基本使用

        System.out.print("认真敲代码\n");
        System.out.print("认真敲代码\n");
        System.out.println("榮十一说:\"认真敲代码\"");
        System.out.println("榮十一说:\'认真敲代码\'");
        System.out.println("榮十一说:\\认真敲代码\\");

        System.out.println("3*3=9\t3*4=12\t3*5=15");
		System.out.println("4*3=12\t4*4=16\t4*5=20");

知识点：常量
           含义：在程序执行过程中不可变的量
           分类：
               1.数字字面量（ps：69、100、200）
               2.字面值常量（ps："榮十一","十一"）
               3.final(最终的)修饰的变量
                   final int i = 100;
                   System.out.println(i);

           字面值常量和final(最终的)修饰的变量：存储在常量池中，直到项目结束才会被销毁