小白必备的java语言基础之运算符最详细的讲解

最新推荐文章于 2024-06-25 08:15:00 发布

WoAiChenXuYuan

最新推荐文章于 2024-06-25 08:15:00 发布

阅读量348

点赞数 1

文章标签： java 算法

本文链接：https://blog.csdn.net/WoAiChenXuYuan/article/details/120112357

版权

运算符

常见的数学运算符

+ - * / % ......

+加号

**+作用：**加法运算、拼接字符串
**规律：**将多个字符串的值拼接成一个字符串,+的左边或者右边，只要有一边是字符串，则一定做拼接字符串处理

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(1+1);

        /*
        拼接字符串
        1.将多个字符串的值 拼接成一个字符串
        2.字符串与其他类型的值也可以拼接成一个字符串
        规律：+的左边或者右边，只要有一边是字符串，则一定做拼接字符串处理
         */
        String s1 = "Hello ";
        String s2 = "Wrold ";
        System.out.println(s1 + s2);

        System.out.println("hello" + 3.14);

        System.out.println(5 + 6 + "," + 6 + 5);//11,65
    }
}

%取余

public class Demo2 {
    public static void main(String[] args) {
        System.out.println(10%3);//1
        System.out.println(3%10);//3
        System.out.println(-4%10);//-4
        System.out.println(-10%4);//-2
    }
}

**取余练习：**声明整型变量，并赋值为5位数,取出该数的每一位的值

public class Demo3 {
    public static void main(String[] args) {
        int i = 56757;

        int ge = i % 10;//取出个位数
        int shi = i / 10 % 10;// 取出十位数
        int bai = i / 100 % 10;// 取出百位数
        int qian = i / 1000 % 10;// 取出千位数
        int wan = i / 10000;// 取出万位数
        System.out.println(ge);
        System.out.println(shi);
        System.out.println(bai);
        System.out.println(qian);
        System.out.println(wan);

    }
}

数学运算中的结果值的类型

public class Demo {
    public static void main(String[] args) {
        //在数学运算中，结果值的数据类型与运算中的最大类型一致
        
        /*
        结果值应该是int类型  真实结果是2.5  但是结果要处理为int
        相当于将2.5转换为int类型   就是将小数位直接砍掉
         */
        System.out.println(5/2);//2
        //结果值应该是double类型   
        System.out.println(5/2.0);//2.5
        /*
        结果值是double类型  真实结果为15  会被转换为double类型
        转换的方式就是添加.0
         */
        
        System.out.println(3.0 * 5);//15.0
    }
}

++与–

++：自增符号

–：自减符号

注意：在使用自增或自减符号时，变量一定要有值

++符号的基本效果：

整型变量++;   或者    ++整型变量;
效果：将该变量的本身的值+1

–符号的基本效果：

整型变量--;   或者    --整型变量;
效果：将该变量的本身的值-1

/*
a++:先赋值，再自增
++a:先自增，再赋值
赋值：将变量的值赋值给表达式
自增：将变量本身的值+1
 */
public class Demo5 {
    public static void main(String[] args) {
        int i = 5;
        int j = 5;

        /*
        为什么i++的值为5
        因为i++的效果是
        1.将i的值赋值给 i++,所以i++的值就是i的值5
        2.将i的值+1     i的值变为6
         */
        System.out.println(i++);//5
        System.out.println(i);//6

        /*
        为什么++j的值为6
        因为++j的效果是
        1.将j的值+1   变为6
        2.将j的值赋值给++j   所以++j的值为6
         */
        System.out.println(++j);//6
        System.out.println(j);//6

        int a = 5;
        System.out.println(a++ + ++a);//12

        int k = 6;//7  6
        int v = 7;//6 7
        System.out.println(k++ - --v + k-- - ++v);//0
        //                 6     6      7     7

    }
}

深入算数运算符

public class Test02{
	
	public static void main(String[] args){
		/**
			知识点：深入算数运算符
			
			+、-、*、/、%、++、--
			
			案例一：byte类型做运算，会向上转型成int
			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);
			
			案例二：short类型做运算，会向上转型成int
			short s1 = 10;
			short s2 = 20;
			short result = (short)(s1+s2);
			System.out.println(result);
			
			案例三：描述下列计算结果的类型
			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类型
			
			案例四：浮点类型不能直接做运算，要做运算会使用BigDecimal
			double d1 = 0.5;
			double d2 = 0.4;
			System.out.println(d1-d2);//0.09999999999999998
			
			案例5：'a'的ASCII是97
			char c = 'a';
			System.out.println(c+1);//98
		
			经典面试题一：输出结果为？
			int a = 8;
			int b = (a++)+(++a)+(a*10);
			System.out.println(b);//118
			//a = 10
			//b = 8 + 10 + 10
			
			经典面试题二：输出结果为？
			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 
			
			扩展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：
			int i = 10;
			//++i; 和 i++; 没有区别，因为分号是一条执行语句的结束，不管先加还是后加都给我加
			//++i;
			//i++;
			System.out.println(i);
		*/	
	}
}

复合运算符

a += 值;     效果：  a = a + 值
a -= 值;     效果：  a = a - 值
a *= 值;     效果：  a = a * 值
....

基本使用


public class Demo6 {
    public static void main(String[] args) {
        int i = 5;
        i += 5;//效果是  i = i + 5
        System.out.println(i);//10
        i -= 6;//效果是  i = i - 6
        System.out.println(i);//4
    }
}

深入符合运算

public class Test03{
	
	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
			
			经典面试题一：输出结果为？
				//一次性声明多个变量
				int a,b; 
				a = b = 100;//把100赋值给b，b再赋值给a
				System.out.println(a);//100
				System.out.println(b);//100
				
			经典面试题二：下面的两种写法结果分别是？
				short s=1; 
				s = s+1;//报错：short类型的变量s 与 int类型的数字字面量1 做运算的结果是int类型 

				short s=1; 
				s += 1;//s = (short)(s+1);
				
		
		*/		
	}
}

自动进行类型转换

复合运算符的好处：

代码更简洁
如果需要类型转换，则复合运算符会自动的进行转换

public class Demo7 {
    public static void main(String[] args) {
        byte b = 5;
        // b = b + 3;//会出错  因为右边的结果值是int类型所以需要强转
        b = (byte)(b + 3);
        System.out.println(b);


        byte b2 = 5;
        //b2 += 3 效果： b2 = b2 + 3.  但是我们并没有进行强转，因为复合运算符会自动的帮我们转换
        b2 += 3;
        System.out.println(b2);
    }
}

深入符合运算

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
		
		经典面试题一：输出结果为？
			//一次性声明多个变量
			int a,b; 
			a = b = 100;//把100赋值给b，b再赋值给a
			System.out.println(a);//100
			System.out.println(b);//100
			
		经典面试题二：下面的两种写法结果分别是？
			short s=1; 
			s = s+1;//报错：short类型的变量s 与 int类型的数字字面量1 做运算的结果是int类型 

			short s=1; 
			s += 1;//s = (short)(s+1);
			*/
}

赋值符号=

变量 = 值;

效果:java一定是先获取都右边的值，再将值赋值给左边的变量
    
int a = 5;
a = a++;
System.out.println(a);//5

练习：声明两个同类型的变量，交换这两个变量的值

public class Practise2 {
    public static void main(String[] args) {
        /*
        声明两个同类型的变量，交换这两个变量的值
         */
        int a = 5;
        int b = 6;
        /*
        这个写法不能达到交换的效果
        因为a = b 执行时，a变量的值因为被覆盖所以丢失
         */
//        a = b;
//        b = a;
//        System.out.println(a);
//        System.out.println(b);

        /*
        如果要替换两个变量的值
        一定要避免某个变量的值丢失
        解决：在某个变量的值被覆盖之前   全复制一份作为备份
         */
        int c = a;
        a = b;
        b = c;
        System.out.println(a);
        System.out.println(b);

        /*
        要求不创建第三个变量达到替换的效果
        实际开发中，不建议使用这个写法
        因为可读性太差了
        但是考试可能会遇到，所以要会写
         */
        int i = 5;
        int j = 6;

        i = i + j;
        j = i - j;
        i = i - j;
        System.out.println(i);
        System.out.println(j);
    }
}

比较运算符

== :比较左边与右边的值是否相等，如果相等结果true. 否则返回false
!= :比较左边与右边的值是否不相等，如果不相等返回true.否则返回false
> >= < <=.....

public class Demo8 {
    public static void main(String[] args) {
        int a = 5;
        int b = 6;
        System.out.println(a==b);//false
        System.out.println(a!=b);//true

        System.out.println(a >= 5);
        /*
        =与==的区别：
        =是赋值符号，效果是将右边的值赋值给左边的变量
        ==是比较符号，效果是判断两边的值是否相等
         */
    }
}

注意： =与==的区别：
=是赋值符号，效果是将右边的值赋值给左边的变量
==是比较符号，效果是判断两边的值是否相等

逻辑运算符

& ：并且    
	效果：连接两个条件，如果两个条件都成立，则整体成立
| : 或者
	效果：连接两个条件，如果两个条件都不成立，则整体不成立
! : 取反  
	效果：本身的值是true,使用了取反符号就变成false

&& : 双与  也表示并且，但是带短路效果
|| : 双或  也表示或者，但是带短路效果

&与&&

public class Demo10 {
    public static void main(String[] args) {
        int i = 5;
        /*
        & 不带短路效果  所以任何情况下都会将两个条件都判断一次
        这样是不合理的，因为如果第一个条件不成立了，则第二个条件就不需要判断了
        在不影响整体结果值的情况下，不判断第二个条件，我们将这种情况称之为短路效果
         */
        System.out.println(i > 5 & i++ < 6);//false
        System.out.println(i);//6

        int j = 5;
        /*
        使用&&符号  带短路效果
        意思就是：在判断了第一个条件，如果就能决定整体的结果，则不会判断第二个条件
        当前这个代码，第一个条件为false,就已经决定了整体的结果肯定为false
        所以就触发了短路效果，不会判断第二个条件也就不会执行j++
        所以j的值还是5
         */
        System.out.println(j > 5 && j++ < 6);//false
        System.out.println(j);//5
    }
}

|与||

public class Demo11 {
    public static void main(String[] args) {
        int i = 5;
        /*
        | 不带短路效果  所以会将两个表达式都判断一次
         */
        System.out.println(i >= 5 | i++ <= 9);//true
        System.out.println(i);//6

        int j = 5;
        /*
        || 带短路效果
        第一个条件已经能决定整体的结果了，就不会判断第二个条件了
         */
        System.out.println(j >= 5 || j++ <= 9);//true
        System.out.println(j);//5

位运算符(了解)

&   :如果连接的是boolean表达式，则充当逻辑运算符
     如果连接的是整数，则充当位运算符
     将两个数字的二进制形式，每一位都进行运算，如果两个数字都是1，则结果为1
     否则结果为0
|   :如果连接的是boolean表达式，则充当逻辑运算符
     如果连接的是整数，则充当位运算符
     将两个数字的二进制形式，每一位都进行运算，如果两个数字有一个是1，则结果为1
     否则结果为0

^   : 将两个数字的二进制形式，每一位都进行运算，如果两个数字不相等，则结果为1
	  否则结果为0
     
>>  :右移
	 将指定整型的二进制数向右边移动指定的位数。
	 右边移动的数字就丢失，左边会空出位置出来，如果符号位是1则左边填1，如果符号位是0，则左边填0
<<  :
	 左移
	 将指定整型的二进制数向做边移动指定的位数。
	 左边移动的数字就丢失，右边会空出位置出来，空出的位置填0
>>> :无符号右移
	将指定整型的二进制数向右边移动指定的位数。
	 右边移动的数字就丢失，左边会空出位置出来，空出的位置填0

public class Demo12 {
    public static void main(String[] args) {
        int i = 15;
        int j = 2;
        /*
        00000000 00000000 00000000 00001111
        00000000 00000000 00000000 00000010
        -------------------------------------
        00000000 00000000 00000000 00000010
         */
        System.out.println(i & j);//2

        /*
        00000000 00000000 00000000 00001111
        00000000 00000000 00000000 00000010
        -------------------------------------
        00000000 00000000 00000000 00001111
         */
        System.out.println(i | j);//15

         /*
        00000000 00000000 00000000 00001111
        00000000 00000000 00000000 00000010
        -------------------------------------
        00000000 00000000 00000000 00001101
         */
        System.out.println(i ^ j);//13

    }
}

/*计算结果：
-12 >> 3
-12 >>> 3
*/
public class Practise3 {
    public static void main(String[] args) {
        byte b = -12;
        /*
        -12的原码：10001100
        -12的反码：11110011
        -12的补码: 11110100
        右移3位：11111110
        结果的反码：11111101
        结果的原码：10000010    十进制：-2
         */
        System.out.println(b >> 3);

         /*
        -12的原码：10000000 00000000 00000000 00001100
        -12的反码：11111111 11111111 11111111 11110011
        -12的补码: 11111111 11111111 11111111 11110100
        无符号右移3位：00011111 11111111 11111111 11111110
         */
        System.out.println(b >>> 3);
        System.out.println(0b00011111111111111111111111111110);
    }
}

三目运算符

boolean表达式?java代码1:java代码2

特点：如果boolean表达式的值为true,则执行java代码1，否则执行java代码2

public class Practise5 {
    public static void main(String[] args) {
        /*
        定义三个整型变量并赋值
        使用三目运算符，打印更大的那一个值
         */
        int a = 25;
        int b = 12;
        int c = 9;
        System.out.println(a>b?(a>c?a:c):(b>c?b:c));
    }
}

/*练习：
>> 3
-12 >>> 3
*/
public class Practise3 {
    public static void main(String[] args) {
        byte b = -12;
        /*
        -12的原码：10001100
        -12的反码：11110011
        -12的补码: 11110100
        右移3位：11111110
        结果的反码：11111101
        结果的原码：10000010    十进制：-2
         */
        System.out.println(b >> 3);
         /*
        -12的原码：10000000 00000000 00000000 00001100
        -12的反码：11111111 11111111 11111111 11110011
        -12的补码: 11111111 11111111 11111111 11110100
        无符号右移3位：00011111 11111111 11111111 11111110
         */
        System.out.println(b >>> 3);
        System.out.println(0b00011111111111111111111111111110);
    }

三目运算符

boolean表达式?java代码1:java代码2

特点：如果boolean表达式的值为true,则执行java代码1，否则执行java代码2

public class Practise5 {
    public static void main(String[] args) {
        /*
        定义三个整型变量并赋值
        使用三目运算符，打印更大的那一个值
         */
        int a = 25;
        int b = 12;
        int c = 9;
        System.out.println(a>b?(a>c?a:c):(b>c?b:c));
    }
}

WoAiChenXuYuan

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
小白必备的java语言基础之运算符最详细的讲解

运算符常见的数学运算符+ - * / % ......+加号**+作用：**加法运算、拼接字符串**规律：**将多个字符串的值拼接成一个字符串,+的左边或者右边，只要有一边是字符串，则一定做拼接字符串处理public class Demo1 { public static void main(String[] args) { System.out.println(1+1); /* 拼接字符串 1.将多个字符串的
复制链接

扫一扫