Java编程思想——操作符

3操作符

Java其实是建立在C++的基础之上的，很多语法之类都很类似。关于操作符也基本类似。

3.1更简单的打印语句

java的打印语句示例：

System.out.println("a lot of type");

Java SE5中新增了静态导入(static import)这一概念，创建一个小类库来简化打印语句的编写。这个在之后详细讨论，一般打印语句不多的时候还是使用上述的例句形式。关于简化的打印语句例句如下：

import java.util.*;
import static net.mindview.util.Print.*;
public class HelloDate{
    public static void main(String[]args){
        print("Hello,it's:");
        print(new Date());
    }
}

输出：
Hello,it’s:
Wed oct 22 19:56:06 MDT 2017

3.2使用java操作符

操作符接受一个或多个参数，并生成一个新值。其中+,-,*,/,=的用法与其他编程语言类似。关于“=”“==”“！=”这些操作符，它们可以操作所有对象。除此以外，String类支持“+”，“+=”

3.3优先级

一个表达式中存在多个操作符，操作符的优先级就决定了各部分的计算顺序。java中的各个操作符的优先级如下：

.    ()    {}    ;    ,
++    --    ~    !(data type)
*    /    %
+    -
<<    >>    >>>
<    >    <=    >=    instanceof
==    !=
&
^
|
&&
||
?    :
=    *=     /=    %=
+=    -=    <<=    >>=
>>>=    &=    ^=    |=

3.4赋值运算符

赋值使用操作符“=”，即取右边的值，复制给左边。右值可以是任何常数，变量或者表达式。左值必须是一个明确的，已命名的变量。但是常数不可以为左值。
对基本类型的变量很简单，例如：

int a,b = 4;
a=b;

将b的值复制后给a，修改b的值不会影响到a的值。
在为对象赋值的时候，如果对一个对象进行操作，我们操作的是对对象的引用。倘若将一个对象赋值给了另一个对象，实际上就是将引用从一个定法复制到另一个地方，即若将对象c赋值给对象d，则对象d修改，对象c也将修改。这里可以将引用看作家的地址，你把c的家的地址赋给了d，则d顺着地址找到的家和c是同一个家，则c中的家有什么变动，同样的d也会变动。
浮点型的默认数据类型是double，如果给float数据类型赋值，应为：

float i = 0.5f;

3.5算术操作符

java的算术运算符基本上与其他编程语言类似，其中包括加号（+），减号（-），除号（/）,乘号（$*$）以及取模操作符（%，即求余数），整数除法直接去掉结果的小数位。关于算术符号可以自己编写相关程序自己看看运行结果，看看整数与浮点数之间的差别。关于算术操作符，要注意+=、-=、*=、/=、%=这些符号，隐含了强制转换，强制转换为左右的数据类型。例如：

int i = 1;
i*=0.1;
Sysout.out.println(i);

上述代码输出结果为0，i*0.1之后强制转换为int型。
对于字符串与基本类型的操作也要注意，例如：

System.out .println(3+4+“Hello!”);      //输出：7Hello!
System.out.println(“Hello!”+3+4);      //输出：Hello!34
System.out.println(‘a’+1+“Hello!”);    //输出：98Hello!

3.5.1一元加、减操作符

一元减号（-）与加号（+）与二元的一样，编译器可以自动识别使用的是哪一种。例如

x=-a;
//或者如下
x=a*-b;

不过为了程序的可读性，一般写作

x=a*(-b);

3.6自动递增和递减操作

自动递增和递减操作符号为“++”、“–”。例如a是int型，则++a等价于（a=a+1）;关于递增和递减有前缀和后缀式两种表达式，位于前缀表达先进行加减值，再进行其他运算，后缀式与其相反。例如

int i = 2;
System.out.println(++i);//输出3
System.out.println(i++);//输出3

3.7关系操作符

关系操作符生成的是一个boolean结果，计算的是操作数之间的关系。如果关系真实，生成true，否则生成false。关系操作符包括：小于（<）、大于（>）、小于或等于（<=）、大于或等于（>=）、等于（==）以及不等于（！=）。等于与不等于适用于所有类型，其他比较符不适用于boolean。

3.8逻辑操作符

逻辑操作符“与”（&&）、“或”（||）、“非”（！）根据参数的逻辑关系，生成一个布尔值。逻辑操作符只能用于boolean，不可将一个非布尔值当做布尔值在逻辑表达式中使用。如果在使用String值得地方使用了布尔值，布尔值会自动转换为文本形式。例如：

3.8.1短路

使用逻辑操作符，会出现一种短路情况。例如如果使用&&

if(a>10&&b<10){
    a=b;
};

如果a>10表达式微false，则整个if表达式肯定为false，则&&后的表达式被短路了，即b<10不会参与运算。同理如果是（||），则一个表达式为true，则其后的表达式都被短路了，不会参与运算。这种情况有助于减少某些参数的运算错误。例如在&&的表达式，只有前一个表达式为true，后一个表达式才可能下标不越界等等，如果前一个表达式为false，再运算后一个表达式，可能出现下标越界错误等。

3.9直接常量

直接常量的后缀标明了其类型，如果是16进制数据，以ox（0X）开头，如果是八进制，则以0开头。对于输出数据类型，可以使用包装类的方法来确定要输出的进制数。例如：

int i = 15;
System.out.println(Integer.toHexString(i));//16进制数输出
System.out.println(Integer.toBinaryString(i));//2进制数输出
System.out.println(Integer.toOctalString(i));//8进制数输出

关于浮点型，java中还提供了一种指数的表达式，例如$1.39*10^{-12}$

float a = 1.39e-12f;
double b = 1.39E-12;

3.10按位操作符

按位操作符用来操作整数基本数据类型中的单个比特，即二进制。按位操作符中有：按位与“&”，按位或“|”，按位异或“^”，按位非“~”以及与“=”联合操作的“&=”等。（~是一元操作）。
按位操作符与逻辑操作符有相同的效果，但是不会存在中途短路的情况。
例如：

int i = 5;//101
int b = 4;//100
int c = i&b;//100，即c=4
c = i|b;//101
c=i^b;//001即c=1
c=~i;//010

3.11移位操作符

移位操作符的运算对象是二进制的位，只可用来处理整数类型。左移位操作符（<<）将操作数向左边移动一位（低位自动补0）。“有符号”右移位操作符（>>）将操作数向右移动。符号为正，高位插0，符号为负，高位插1；java中增加了无符号右移位操作符（>>>）,无论正负，高位插0。（C/C++没有）。如果对char，byte，short类型进行移位处理，在移位之前要先转换为int类型。
移位可以与等号组合使用（<<=,>>=,>>>=），如果对byte或者short进行这样的移位，可能得到的结果不是正确的结果。因为它要被转换为int类型，再移位，再截位再转换数据类型。

3.12三元操作符

三元操作符称作为条件操作符，它的表达式形式为：
boolean-exp?value0:value1
如果boolean-exp（布尔表达式）为true，计算value0，否则计算value1。
例如：

int i=12;
int b = i>10?i:10;//b=12

3.13字符串操作符

字符串操作符是用来连接不同的字符串。即+与+=。
例如：

String s="adsf";
String b="jkl";
String sb=s+b;//"adsfjkl"
sb+=s;//"adsfjkladsf"

3.14类型转换操作符

类型转换（cast）意味着模型重铸，适当的时候，java会自动将一种数据转换为另一种数据类型，例如为浮点数赋予整数值，java会自动将整数值转换为浮点型。类型转换运算允许我们显示的进行这种类型转换。例如：

int i = 400;
long l = (long)i;//400
byte b = (byte)i;//-112

大容量数据类型转换为小容量数据类型可能就会出现数据错误，而且浮点数数据类型转换为整数型数据类型是将小数点后的数舍去掉，如果想要实现四舍五入，可以使用java.lang.Math中的round()方法。
注意：

float f = -29.5f;
System.out.println(Math.round(f));//输出-29
float ff = -29.51f;
System.out.println(Math.round(ff));//输出-30

不同数据类型的数据进行运算，要格外注意

3.15操作符小结

//: operators/AllOps.java
// Tests all the operators on all the primitive data types
// to show which ones are accepted by the Java compiler.

public class AllOps {
// To accept the results of a boolean test:
void f(boolean b) {}
void boolTest(boolean x, boolean y) {
// Arithmetic operators:
//! x = x * y;
//! x = x / y;
//! x = x % y;
//! x = x + y;
//! x = x - y;
//! x++;
//! x–;
//! x = +y;
//! x = -y;
// Relational and logical:
//! f(x > y);
//! f(x >= y);
//! f(x < y);
//! f(x <= y);
f(x == y);
f(x != y);
f(!y);
x = x && y;
x = x || y;
// Bitwise operators:
//! x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Compound assignment:
//! x += y;
//! x -= y;
//! x *= y;
//! x /= y;
//! x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! char c = (char)x;
//! byte b = (byte)x;
//! short s = (short)x;
//! int i = (int)x;
//! long l = (long)x;
//! float f = (float)x;
//! double d = (double)x;
}
void charTest(char x, char y) {
// Arithmetic operators:
x = (char)(x * y);
x = (char)(x / y);
x = (char)(x % y);
x = (char)(x + y);
x = (char)(x - y);
x++;
x–;
x = (char)+y;
x = (char)-y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x= (char)~y;
x = (char)(x & y);
x = (char)(x | y);
x = (char)(x ^ y);
x = (char)(x << 1);
x = (char)(x >> 1);
x = (char)(x >>> 1);
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean bl = (boolean)x;
byte b = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void byteTest(byte x, byte y) {
// Arithmetic operators:
x = (byte)(x* y);
x = (byte)(x / y);
x = (byte)(x % y);
x = (byte)(x + y);
x = (byte)(x - y);
x++;
x–;
x = (byte)+ y;
x = (byte)- y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = (byte)~y;
x = (byte)(x & y);
x = (byte)(x | y);
x = (byte)(x ^ y);
x = (byte)(x << 1);
x = (byte)(x >> 1);
x = (byte)(x >>> 1);
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean bl = (boolean)x;
char c = (char)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void shortTest(short x, short y) {
// Arithmetic operators:
x = (short)(x * y);
x = (short)(x / y);
x = (short)(x % y);
x = (short)(x + y);
x = (short)(x - y);
x++;
x–;
x = (short)+y;
x = (short)-y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = (short)~y;
x = (short)(x & y);
x = (short)(x | y);
x = (short)(x ^ y);
x = (short)(x << 1);
x = (short)(x >> 1);
x = (short)(x >>> 1);
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean bl = (boolean)x;
char c = (char)x;
byte b = (byte)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void intTest(int x, int y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x–;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
x = x << 1;
x = x >> 1;
x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean bl = (boolean)x;
char c = (char)x;
byte b = (byte)x;
short s = (short)x;
long l = (long)x;
float f = (float)x;
double d = (double)x;
}
void longTest(long x, long y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x–;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
x = x << 1;
x = x >> 1;
x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
x <<= 1;
x >>= 1;
x >>>= 1;
x &= y;
x ^= y;
x |= y;
// Casting:
//! boolean bl = (boolean)x;
char c = (char)x;
byte b = (byte)x;
short s = (short)x;
int i = (int)x;
float f = (float)x;
double d = (double)x;
}
void floatTest(float x, float y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x–;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
//! x = ~y;
//! x = x & y;
//! x = x | y;
//! x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
//! x &= y;
//! x ^= y;
//! x |= y;
// Casting:
//! boolean bl = (boolean)x;
char c = (char)x;
byte b = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
double d = (double)x;
}
void doubleTest(double x, double y) {
// Arithmetic operators:
x = x * y;
x = x / y;
x = x % y;
x = x + y;
x = x - y;
x++;
x–;
x = +y;
x = -y;
// Relational and logical:
f(x > y);
f(x >= y);
f(x < y);
f(x <= y);
f(x == y);
f(x != y);
//! f(!x);
//! f(x && y);
//! f(x || y);
// Bitwise operators:
//! x = ~y;
//! x = x & y;
//! x = x | y;
//! x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;
// Compound assignment:
x += y;
x -= y;
x *= y;
x /= y;
x %= y;
//! x <<= 1;
//! x >>= 1;
//! x >>>= 1;
//! x &= y;
//! x ^= y;
//! x |= y;
// Casting:
//! boolean bl = (boolean)x;
char c = (char)x;
byte b = (byte)x;
short s = (short)x;
int i = (int)x;
long l = (long)x;
float f = (float)x;
}
} ///:~