Java 运算符

运算符是什么呢？

想想小时候，从上学的哪一天开始,我们就学习到了一门学科<<数学>>,同时<<数学>>也是万科之后,数学是一门神奇的学科,至于神奇在哪里,以本人现在悟性要参透还需要一段时候。如果说在生活中能够运用到的数学知识,对于一个平常人来讲学完高中足以(本人也就是高中水平)。

想想我对数学的简单认识就是 一些数字加上一些符号的组成的一门学科。说道符号我依稀记得 "+" , "-" "x" "/": 这几个基本的运算符至于上初中学到的几何，已经是很模糊的概念了。

回想上来也就只有勾股定理了。(还是记得一句口诀沟3股4玄5)。

说了一推不该说的。我只是想回忆下数学中的符号而已，现在想来这些符号富含了一些思想的结晶。不管在哪个领域几乎都离不开数学。

符号的作用: 对数子进行运算,

回到正题:在Java中的运算符又有哪些呢?

1.Java中的运算符的分类

01.算术运算符

001. 单目运算符

+(正号) -(负号)  --(自减) ++(自增)

002.双目运算符

+(加好) -(减号) *(乘号) /(除号) %(求余)

003,三目运算符

a > b ? true : false

整个三目运算符由 表达式a + 关系运算符 + 表达式b + ?号 + :号组成

当a > b的时候,就执行:号前面的语句(也就是true的部分)，否则就执行 :号后面的部分（也就是false的部门）

2.关系运算符

大于(>) 小于(<) 等于(==) 大于等于(>=) 小于等于(<=)   不等于(!=) 

3.逻辑袁福

,与(& 和 &&)  或(| 和 ||)  非(!)

& 和 &&的区别 :

 &和&&两端都是boolean表达式,例如: false & false 这里不仅需要判断第一个false，同时还会判断第二false

但是 false && false 如果第一个为false就不会去判断第二个false了。

| 和 || 也是同样的区别。

4.位运算符

&(与) :  当&作为运算符的时候,&两端的操作数就会转换为二进制码然后在进行运算

当两边的操作数的位同时为1时，结果为1，否则为0。如1100&1010=1000

|(或) :  当两边的操作数只需要有一个1使,结果就为1,否则就为0.如1100|1010=1110

~(非): 0变1,1变0

^(异或) : 当两边的操作不相同的时候,结果为1,否则就为0 . 如1100^1010=0110

5.位移运算符

左移(<<) : 向左移位 , 高位丢弃 , 地位补0.

右移(>>) : 向右移位 , 高位还是原来的最高位 , 低位丢弃

无符号右移(>>>) : 向右移位 , 高位永远为1 , 低位丢弃

6.赋值运算符

=(直接复制) +=(加等) -=(减等)  *=(乘等) /=(除等) %=(模等)

<<=(左移等) >>(右移等) >>>(无符号右移等) &=(与等) |=(或等) ^=(异或等)

7.特殊运算符

instanceof : 判断某个对象是否属于某个类型

下面是小子做的一些位运算的例子:

package com.zgy.javase.one;


public class BitComputing {



public static void main(String[] args) {
int param1 = -1000;
int param2 = 200;
//and(param1, param2);
//or(param1, param2);
//not(param1);
//xor(param1, param2);
//left(param1 , 3);
//right(param1, 5);
//unsignedRight(param1, 5);
System.out.println(Integer.toBinaryString(-32));
}

/**
* 位且 两个数对应的二进制位同时为 1 的时候 结果位才为 1
* @param param1
* @param param2
*/
public static void and(int param1 , int param2){

bitComput(Operator.BIT_AND, param1, param2);
}

/**
* 位或 两个数对应的二进制位只要有一个为 1 的时候 结果位就为为 1
* @param param1
* @param param2
*/
public static void or(int param1 , int param2){
bitComput(Operator.BIT_OR, param1, param2);
}

/**
* 位非 把原来数的二进制位都去反即可
* @param param1
* @param param2
*/
public static void not(int param1){
printBitComput(Operator.BIT_NOT, param1);
}

/**
* 位异或 两个数对应的二进制位不相同 结果位为1 , 相同则为0
* @param param1
* @param param2
*/
public static void xor(int param1 , int param2){
bitComput(Operator.BIT_XOR, param1, param2);
}

/**
* 位左移 将原来的数的二进制位都向左边移动 , 最高位丢弃 , 最低位补0
* @param value
* @param leftCount
*/
public static void left(int value , int leftCount){
moveBitComput(Operator.BIT_LEFT, value, leftCount);
}

/**
* 位右移 将原来的数的二进制位都向右边移动 , 最低位丢弃 , 最高位补0
* @param value
* @param leftCount
*/
public static void right(int value , int rightCount){
moveBitComput(Operator.BIT_RIGHT, value, rightCount);
}

/**
* 位无符号右移
* @param value
* @param rightCount
*/
public static void unsignedRight(int value , int rightCount){
moveBitComput(Operator.BIT_UNSIGNED_RIGHT, value, rightCount);
}


/**
* 位移
* @param operator
* @param value
* @param moveCount
*/
private static void moveBitComput(Operator operator, int value, int moveCount) {

String binary = Integer.toBinaryString(value);
String o = operator.getOperator();
System.out.print(value + " " + o + " " + moveCount + " = " + binary + " " + o + " " + moveCount + " = ");
switch (operator) {
case BIT_LEFT:
System.out.println(Integer.toBinaryString(value << moveCount) + " = " + (value << moveCount));
break;
case BIT_RIGHT:
System.out.println(Integer.toBinaryString(value >> moveCount) + " = " + (value >> moveCount));
break;
case BIT_UNSIGNED_RIGHT:
System.out.println(Integer.toBinaryString(value >>> moveCount) + " = " + (value >>> moveCount));
break;
default:
break;
}


}


/**
* 位运算
* @param operator
* @param param1
* @param param2
*/
public static void bitComput(Operator operator , int param1 , int param2){
if(param1 >= param2){
printBitComput(operator , param1 , param2);
}else{
printBitComput(operator , param2 , param1);
}
}

/**
* 打印位运算结果
* @param operator
* @param max
* @param min
*/
private static void printBitComput(Operator operator , int max, int min) {
String formatBlank = "  ";
String maxBinary = Integer.toBinaryString(max);
String minBinary = Integer.toBinaryString(min);
String blank = getBlank(String.valueOf(maxBinary).length() - String.valueOf(minBinary).length());
System.out.println(formatBlank + maxBinary);
System.out.println(operator.getOperator() + " ---------------------------");
System.out.println(formatBlank + blank + minBinary);
System.out.print("= ");
switch (operator) {
case BIT_AND:
System.out.println(blank + Integer.toBinaryString(max & min) + " = " + (max & min));
break;
case BIT_OR:
System.out.println(Integer.toBinaryString(max | min) + " = " + (max | min));
break;
case BIT_XOR:
System.out.println(Integer.toBinaryString(max ^ min) + " = " + (max ^ min));
break;
default:
break;
}
}



/**
* 打印位运算结果
* @param operator
* @param max
* @param min
*/
private static void printBitComput(Operator operator , int param) {
String binary = Integer.toBinaryString(param);
String o = operator.getOperator();
System.out.print(o + param + " = " + o + binary + " = ");
switch (operator) {
case BIT_NOT:
System.out.println(Integer.toBinaryString(~ param) + " = " +(~param));
break;
default:
break;
}
}

/**
* 获得空格
* @param leng
* @return
*/
private static String getBlank(int leng) {
String result = "";
for (int i = 0; i < leng; i++) {
result += " ";
}
return result;
}


}

package com.zgy.javase.one;


public enum Operator {

//位运算符
BIT_NOT("~"),
BIT_OR("|"),
BIT_AND("&"),
BIT_XOR("^"),

BIT_LEFT("<<"),
BIT_RIGHT(">>"),
BIT_UNSIGNED_RIGHT(">>>"),
;

private String operator;
public String getOperator(){
return operator;
}
private Operator(String operator){
this.operator = operator;
}


public static void main(String[] args) {
System.out.println("BIT_Unsigned_RIGHT".toUpperCase());
}

}