【JAVA】一本糊涂账系列——操作符

最新推荐文章于 2022-11-13 09:26:28 发布

郭慧鹏

最新推荐文章于 2022-11-13 09:26:28 发布

阅读量1.3k

点赞数 4

分类专栏： JAVA 文章标签： JAVA

本文链接：https://blog.csdn.net/Hit_the_lights/article/details/85324425

版权

JAVA 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

算数操作符：

1、基本的加、减、乘、除

public class HelloWorld {
	public static void main(String[] args) {
		int i = 10;
		int j = 5;
		int a = i+j;
		int b = i - j;
		int c = i*j;
		int d = i /j;
	}
}

2、%运算（% 取余数，又叫取模）

public class HelloWorld {
	public static void main(String[] args) {
		int i = 5;
		int j = 2;
		System.out.println(i%j); //输出为1
	}
}

3、自增减运算（在原来的基础上增加1或者减少1），以++为例

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        i++;
        System.out.println(i);//输出为6
    }
}

4、自增、自减操作符置前以及置后的区别（i++; 先取值，再运算、++i; 先运算，再取值），以++为例

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i++); //输出5
        System.out.println(i);   //输出6
         
        int j = 5;
        System.out.println(++j); //输出6
        System.out.println(j);   //输出6
    }
}

注意：如果有任何运算单元的长度超过int,那么运算结果就按照最长的长度计算；如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算，其它的道理也一样。

public class HelloWorld {
    public static void main(String[] args) {
        //int a = 5; long b = 6; a+b -> 结果类型是long
        int a = 5;
        long b = 6;
        int c = (int) (a+b); //a+b的运算结果是long型，所以要进行强制转换
        long d = a+b;

        //byte a = 1; byte b= 2; a+b -> int 类型
        byte a = 1;
        byte b= 2;
        byte c = (byte) (a+b); //虽然a b都是byte类型，但是运算结果是int类型，需要进行强制转换
        int d = a+b;
    }
}

关系操作符:

用于比较两个变量之间的关系，这些操作符包括：> 大于、>= 大于或等于、< 小于、<= 小于或等于、== 是否相等、!= 是否不等

public class HelloWorld {
    public static void main(String[] args) {
       int a = 5;
       int b = 6;
       int c = 5;
        
       System.out.println(a>b);  //返回 false
       System.out.println(a>=c);  //返回 true
        
       System.out.println(a==b); //返回false
       System.out.println(a!=b);//返回true       
    }
}

逻辑运算符：

1.长路与&和短路与&&

无论长路与还是短路与，两边的运算单元都是布尔值，都为真时，才为真；任意为假，就为假。
区别：长路与两侧，都会被运算；短路与只要第一个是false，第二个就不进行运算了。

public class HelloWorld {
    public static void main(String[] args) {
        //长路与  无论第一个表达式的值是true或者false,第二个的值，都会被运算
        int i = 2;
        System.out.println( i== 1 & i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
        System.out.println(i);
         
        //短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了
        int j = 2;
        System.out.println( j== 1 && j++ ==2  );  //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2
        System.out.println(j);           
    }
}

2.长路或|和短路或||

无论长路或还是短路或，两边的运算单元都是布尔值，都为假时，才为假；任意为真，就为真。
区别：长路或两侧都会被运算；短路或只要第一个是true的，第二个就不进行运算了。

public class HelloWorld {
    public static void main(String[] args) {
        //长路或  无论第一个表达式的值是true或者false,第二个的值，都会被运算
        int i = 2;
        System.out.println( i== 1 | i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
        System.out.println(i);
         
        //短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了
        int j = 2;
        System.out.println( j== 2 || j++ ==2  );  //因为j==2返回true,所以右边的j++就没有执行了，所以j的值，还是2
        System.out.println(j);              
    }
}

3.取反！（真变为假，假变为真）

public class HelloWorld {
    public static void main(String[] args) {
        boolean b = true;
         
        System.out.println(b); //输出true
        System.out.println(!b);//输出false         
    }
}

4.异或 ^（不同，返回真；相同，返回假）

public class HelloWorld {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
         
        System.out.println(a^b); //不同返回真
        System.out.println(a^!b); //相同返回假 
    }
}

赋值操作符：

1.赋值操作：赋值操作的操作顺序是从右到左，例如int i = 5+5; 首先进行5+5的运算并得到结果10，然后把10这个值赋给i

2.+=即自加。i+=2;等同于i=i+2;其他的 -= , *= , /= , %= , &= , |= , ^=也类似。

三元操作符：

表达式?值1:值2，如果表达式为真返回值1；如果表达式为假返回值2。

public class HelloWorld {
    public static void main(String[] args) { 
        int i = 5;
        int j = 6;
        int k = i < j ? 99 : 88;
 
        // 相当于
        if (i < j) {
            k = 99;
        } else {
            k = 88;
        }
 
        System.out.println(k); 
    }
}

位操作符：

1.一个整数的二进制表达：Integer.toBinaryString()

位操作都是对二进制而言的，但是我们平常使用的都是十进制。比如5，而5的二进制是101。所以在开始学习之前，需要掌握一个整数的二进制表达是多少。通过Integer.toBinaryString() 方法，将一个十进制整数转换为一个二进制字符串。

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        String b = (Integer.toBinaryString(i)); // 5的二进制的表达101
        System.out.println(i+" 的二进制表达是: "+b);
    }
}

2.位或|

例如：5的二进制是101，6的二进制是110 ，所以 5|6 对每一位进行或运算，得到 111->7

public class HelloWorld {
    public static void main(String[] args) {
         
        int i  =5;
        int j = 6;
         
        System.out.println(Integer.toBinaryString(i)); //5的二进制是101
         
        System.out.println(Integer.toBinaryString(j)); //6的二进制是110
         
        System.out.println(i|j); //所以 5|6 对每一位进行或运算，得到 111->7 
    }
}

3.位与&

例如：5的二进制是101，6的二进制是110，所以 5&6 对每一位进行与运算，得到 100->4

4.异或^

例如：5的二进制是101，6的二进制是110，所以 5^6 对每一位进行异或运算，得到 011->3

一些特别情况：任何数和自己进行异或都等于 0，任何数和0 进行异或都等于自己。

5.取非~

例如：5 的二进制是 00000101，所以取反即为 11111010，这个二进制换算成十进制即为-6

6.左移、右移

左移：根据一个整数的二进制表达，将其每一位都向左移动，最右边一位补0
右移：根据一个整数的二进制表达，将其每一位都向右移动

public class HelloWorld {
    public static void main(String[] args) {
        byte i  =6;
         
        //6的二进制是110
        System.out.println(Integer.toBinaryString(i));
        //6向左移1位后，变成1100，对应的10进制是12
        System.out.println(i<<1);
        //6向右移1位后，变成11，对应的10进制是3
        System.out.println(i>>1);
    }     
}

7.带符号右移与无符号右移

带符号右移 >>
对于正数，带符号右移 >> 会把所有的位右移，并在最前面补0；对于负数，带符号右移 >> 会把所有的位右移，并在最前面补1。
无符号右移>>>
如果是一个负数，那么对应的二进制的第一位是1，无符号右移>>>会把第一位的1也向右移动，导致移动后，第一位变成0，这样就会使得负数在无符号右移后，得到一个正数。

总结：带符号右移 >> 移动后正的还是正的，负的还是负的,符号不变；无符号右移>>>移动后，变正的了。

public class HelloWorld {
    public static void main(String[] args) {
        int i  =-10;
         
        //-10的二进制是11111111111111111111111111110110
        //第一位是1，即符号位，代表这是一个负数
        System.out.println(Integer.toBinaryString(i));
         
        //对于正数， 带符号右移 >> 会把所有的位右移，并在最前面补0
        //对于负数， 带符号右移 >> 会把所有的位右移，并在最前面补1
         
        //-10带符号右移1位，移动后前面补齐1
        //得到11111111111111111111111111111011
        //因为第一位是1，所以依然是一个负数，对应的十进制是-5
        int j = i>>1;
        System.out.println(Integer.toBinaryString(j));
        System.out.println(j);
         
        //-10无符号向右移1位，符号位也会向右移，第一位就变成了0
        //得到01111111111111111111111111111011，对应的十进制是2147483643
        int k = i>>>1;
        System.out.println(Integer.toBinaryString(k));     
         
        System.out.println(k);
    }     
}

SCANNER：

1.使用Scanner读取整数

import java.util.Scanner;   //表示导入这个类，才能够正常使用
 
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int a = s.nextInt();
        System.out.println("第一个整数："+a);
        int b = s.nextInt();
        System.out.println("第二个整数："+b);
    }
}

注意：使用Scanner类，需要在最前面加上。

2.使用Scanner读取浮点数

import java.util.Scanner;
  
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        float a = s.nextFloat();
        System.out.println("读取的浮点数的值是："+a);
 
    }
}

3.使用Scanner读取字符串

import java.util.Scanner;
  
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String a = s.nextLine();
        System.out.println("读取的字符串是："+a);
    }
}

4.读取了整数后，接着读取字符串

import java.util.Scanner;
   
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        System.out.println("读取的整数是"+ i);
        String rn = s.nextLine();
        String a = s.nextLine();
        System.out.println("读取的字符串是："+a);
    }
}

需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行："\r\n"，因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n"。所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串。