操作符

一、算数操作符

算数操作符
基本的有：

+ - * / %

自增自减

++ --

示例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：任意运算单元的长度超过int

如果有任何运算单元的长度超过int,那么运算结果就按照最长的长度计算
比如
int a = 5;
long b = 6;
a+b -> 结果类型是long

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

示例3：任意运算单元的长度小于int

如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算
byte a = 1;
byte b= 2;
a+b -> int 类型

public class HelloWorld {
    public static void main(String[] args) {
        byte a = 1;
        byte b= 2;
        byte c = (byte) (a+b); //虽然a b都是byte类型，但是运算结果是int类型，需要进行强制转换
        int d = a+b;
    }
}

示例4：%取模

% 取余数，又叫取模
5除以2，余1

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

示例5：自增自减

++
--
在原来的基础上增加1或者减少1

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

示例6：自增自减操作符置前以及置后的区别

以++为例
int i = 5;
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
    }
}

二、关系操作符

关系操作符:比较两个变量之间的关系
> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 是否相等
!= 是否不等

示例1：关系操作符

> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 是否相等
!= 是否不等

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); //相同返回假
 
    }
}

四、位操作符

位操作符在实际工作中用的并不常见，但是同学们总是很喜欢纠结这些位操作。

所以本章节会给出每一个操作符的操作实例帮助大家理解其具体含义。

最后说，如果确实感兴趣，就看看，个人建议跳过这个章节。真正工作用到了，再来看。

关键字	简介
Integer.toBinaryString()	一个整数的二进制表达
\|	位或
&	位与
^	异或
~	取非
<< >>	左移右移
>>>	带符号右移与无符号右移

示例1：一个整数的二进制表达

位操作都是对二进制而言的，但是我们平常使用的都是十进制比如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

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 对每一位进行与运算，得到 100->4
 
    }
}

示例4：异或

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

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

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 对每一位进行或运算，得到 011->3
         
        System.out.println(i^0);
        System.out.println(i^i);
    }
}

示例5：取非

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

public class HelloWorld {
    public static void main(String[] args) {
        byte i  =5;
         
        System.out.println(Integer.toBinaryString(i)); //5的二进制是00000101,所以取非即为11111010,即为-6
         
        System.out.println(~i);
         
    }
     
}

示例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);
    }
     
}

五、赋值操作符

赋值操作

关键字	简介
=	赋值操作
+= -= *= /= %= &= \|= ^= <<= >>= >>>=	对本身进行运算，并赋值

示例1：赋值操作

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

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5+5;
    }
}

示例2：对本身进行运算，并赋值

+=即自加
i+=2;
等同于
i=i+2;
其他的 -= , *= , /= , %= , &= , |= , ^= , >>= , >>>= 都是类似，不做赘述

public class HelloWorld {
    public static void main(String[] args) {
        int i =3;
        i+=2;
        System.out.println(i);
         
        int j=3;
        j=j+2;
        System.out.println(j);     
 
    }
}

六、三元运算符

三元操作符
?:

示例1：三元操作符

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

关于if语句的详解讲解在后面章节

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);
 
    }
}

七、Scenner

截至目前为止，学习了使用System.out.println("") 向控制台输出数据。

在接下来的练习中，需要用到从控制台输入数据，所以需要用到Scanner类

步骤1：使用Scenner读取整数

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

import java.util.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);
    }
}

步骤2：使用Scanner读取浮点数

aimport 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：读取了整数后，接着读取字符串

需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".

所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串

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);
    }
}

posted @ 2021-02-16 22:20 786575099 阅读(5) 评论(0) 收藏举报

刷新页面返回顶部

操作符