C# 操作符之二 算数操作符

赋值运算符也有和算数操作符所结合的用法之前附录中有提及，用法是：比如要将x加上4,然后再赋值给x，就可以写成x+=4.

public class mathops{
public static void main(string [] args){
random rand=new random(47);
int i,j,k;
j=rand.nextinf(100)+1;
system.out.println("j:"+j);
k=rand.nextint(100)+1;
system.out.println("k:"+k);
i=j-k;
system.out.println("j-k:"+i);
i=k/j;
system.out.println("k/j:"+i);
i=k*j;
system.out.println("k*j:"+i);
j%=k;
system.out.println("i%=k:"+j);
float u,v,w;
v=rand.nextfloat();
system.out.println("v:"+v);
w=rand.nextfloat();
system.out.println("w:"+w);
u=v+w;
system.out.printlln("v+w:"+u);
u=v-w;
system.out.println("v-w:"+u);
u=v*w;
system.out,print("v*w"+u);
u=v/w;
system.out.print("v/w:"+u);
u+=v;
system.out.print("u+=v:"+u);
u-=v;
system.out.print("u-=v:"+u);
u*=v;
system.out.print("u*=v:"+u);
u/=v;
system.out.print("u/=v:"+u);
}
}

输出：
j:59;
k:56;
j+k:115;
j-k:3;
k/j:0;
k*j:3304;
k%j:56;
j%=k:3;
v:0.5309454;
w:0.0534122
v+w:0.5843576
v-w:0.47753322
v*w:0.028358962
v/w:9.94025
u+=v:10.471473
u-=v:9.940527
u*=v:5.2778773
u/=v:9.940527
通过random类的对象，程序可以生成许多不同类型的随机数字。做法很简单，只需要调用方法nextint()和nextfloat()即可（或nextlong()或者nextdouble()）。传递给nextint()的参数设置了所产生的随机数的上限，而其下线为0，但是这个下线并不是我们想要的，因为他会产生除0的可能性，所以做了+1的操作。
一元操作符中编译器会自动判断+，-号的作用
比如：x=a*-b;编译器可以编译其含义b前-号是负号但为了避免读者混淆最佳的写法是
x=a*(-b)
一元减号用于转变数据的符号，而一元加号只是为了与一元减号相对应，但是它唯一的作用仅仅是将较小类型的操作数提升为int;
算术操作符

operator	use	description
+	op1 + op2	返回op1和op2的和
-	op1 - op2	返回op1和op2的差
*	op1 * op2	返回op1和op2的积
/	op1 / op2	返回op1除以op2的商
%	op1 % op2	返回op1除以 op2的余数

自动递增和递减
java中提供的打量快捷运算中递增和递减运算时两种相当不错又快捷的运算（通常被称为"自动递增"和"自动递减"运算）。其中，递减操作符是"--"，意私事减少一个单位，递增是"++"意思是增加一个单位
++a等价于a=a+1递减亦同
递增，递减又分为"前缀式"和"后缀式"。
对于前缀式：++a,--a，会先执行运算,再生成值。而对于后缀式a++,a--，会先生成值，在执行运算。

public class autoinc{
public static void main(string [] args){
int i=1;
system.out.println("i:"+1);
system.out.println("++i:"+ ++i);
system.out.println("i++:"+ i++);
system.out.println("—i:"+ --i);
system.out.println("i--:" + i--);
}
}

输出
i:1
++i:2
i++:2
--i:1
i--:1
从上面这个例子中可以看书前缀式和后缀式的区别
递增操作符正是c++这个名字的一种解释,"超越c一步"
关系操作符
关系操作符主要生成的的是一个boolean布尔结果，他们比较值之间的结果如果为真返回true,如果为假则返回false,关系操作符包括<,>,<=,>=,==,!=（不等于）,等于和不等于适合于所有基本数据类型，而其他的操作符不适合对boolean值的操作，因为true和false两个之间不存在大于或小于的关系

public class equivalence{
public static void main(string [] arg){
integer n1=new integer(47);
integer n2=new integer(47);
system.out.println(n1==n2);
system.out.println(n1!=n2);
}
}

输出
false
true
结果可能会跟你想的不一样，在这里尽管对象内容相同，但是对象的引用是不同的，而==和！=比较的是对象的引用,而不是内容。
如果相比较两对象的实际内容是否相同的话要怎么做？需要使用所有对象都适用的equals()方法。但这个方法不适用于基本类型，基本类型直接使用==，！=即可

public class equalmethod{
public static void main(string [] args){
integer n1=new integer(47);
interger n2=new integer(47);
system.out.println(n1.equals(n2));
}
}

输出
true
但是如果引用的对象是自己创建的类，结果又会有不同

class value{
int i;
}
public class equalsmethod2{
public static void main(string [] args){
value v1=new value();
value v2=new value();
v1.i=v2.i=100;
system.out.println(v1.equals(v2));
}
}

输出
false
结果又是false，这是由于equals的默认其实是比较引用。所以除非在自己的新类中重写equals方法、否则是不能达到我们预期的效果的。
关系操作符

operator	use	description
>	op1 > op2	当op1 大于op2 时返回true
>=	op1 >= op2	当op1 大于或等于op2 时返回true
<	op1 < op2	当op1 小于op2 时返回true
<=	op1 <= op2	当op1 小于或等于op2 时返回true
==	op1 == op2	当op1 等于大于op2 时返回true
!=	op1 != op2	当op1 不等于op2 时返回true

逻辑操作符
逻辑操作符与(&&)，或(||)，非(!)能根据参数的关系返回布尔值

public class bool{
public static void main(string [] args){
random rand=new random(47);
int i=rand.nextint(100);
int j=rand.nextint(100);
system.out.println("i=" + i);
system.out.println("j=" + j);
system.out.println("i > j is" +( i>j));
system.out.println("i < j is" +( i<j));
system.out.println("i > =j is" +( i>=j));
system.out.println("i <=j is" +( i<=j));
system.out.println("i ==j is" +( i==j));
system.out.println("i !=j is" +( i!=j));
system.out.println("(i <10) && (j<10) is" +((i <10) && (j<10)));
system.out.println("(i <10) || (j<10) is" +((i <10) ||(j<10)));
}
}

输出
i=58
j=55
i>j is true
i<j is false
i>= j is true
i<=j is false
i==j is false
i!=j is true
(i <10) && (j<10) is false
(i <10) ||(j<10) isfalse
与或非操作只能应用于布尔值，如果在应该是string值的地方使用了boolean的话，布尔值会自动转换成适当的形式。
应注意的是在程序上对浮点数的比较是非常严格的。
条件操作符

operator	use	description
&&	op1 && op2	当op1和op2都是true时，返回true ；如果op1的值是false，则不运算右边的操作数
||	op1 || op2	当op1和op2有一个是true时，返回true；如果op1的值是true，则不运算右边的操作数
!	! op	当op是false时，返回true；当op是true时，返回false
&	op1 & op2	运算op1和op2；如果op1和op2都是布尔值，而且都等于true，那么返回true，否则返回false；如果op1和op2都是数字，那么执行位与操作
|	op1 | op2	运算op1和op2；如果op1和op2都是布尔值，而且有一个等于true，那么返回true，否则返回false；如果op1和op2都是数字，那么执行位或操作
^	op1 ^ op2	运算op1和op2；如果op1和op2不同，即如果有一个是true，另一个不是，那么返回true，否则返回false；如果op1和op2都是数字，那么执行位异或操作

短路
当使用逻辑操作符的时候会遇到一种短路状况。既一但能够明确无误地确定整个表达式的值，就不再计算表达式余下的部分了。因此，整个逻辑表达式靠后的部分有可能不再计算。下面的例子展示了短路现象

public class shortcircuit{
static boolean test1(int val){
system.out.println(“test1(“+val+")");
system.out.println(“result:"+(val<1));
return val<1
}
static boolean test2(int val){
system.out.println(“test1(“+val+")");
system.out.println(“result:"+(val<2));
return val<2
}
static boolean test3(int val){
system.out.println(“test1(“+val+")");
system.out.println(“result:"+(val<3));
return val<3
}
public static void main(string [] args){
boolean b=test1(0)&&test2(2)&&test3(2);
system.out.println(“expression is “ + b);
}
}

输出
test1(0)
result:true
test(2)
result:false
expression is false
由于调用了3个方法你会很自然的觉得3个方法应该都被运行，但实际上输出并非这样，因为在第二次测试产生一个false结果。由于这意味着整个表达式肯定为false,所以没必要继续计算剩余的表达式,那样只是浪费。“短路“一次正来源于此。实际上，逻辑上所有的逻辑表达式都有一部分不必计算，那将获得性能的提升。
三元操作符
三元操作符也成为条件操作符，他显得比较特别，因为有三个操作数，但是他又确实属于操作符的一种
其形式为
boolean-exp?value0 ：value1
如果boolean-exp表达式结果为true,就计算value0,而且这个计算结果也就是操作符最终产生的值。如果boolean-exp表达式结果为false,就计算value1,同样的，他的结果也将成为操作符最后的值。
当然它也可以被if-else代替，但是三元操作符与if-else是完全不同的，操作符会产生一个值。

public class ternaryifelse{
static int ternary(int i){
return i<10?i*100:i*10;
}
static int standardifelse(int i){
if(i<10)
return i*100;
else
return i*10;
}
public static void main(string [] args){
system.out.println(ternary(9));
system.out.println(ternary(10));
system.out.println standardifelse( (9));
system.out.println standardifelse( (10));
}
}

输出
900
100
900
100
相比之下三元运算符要紧凑很多，而if-else更易理解
字符串操作符+和+=
java中+和+=操作符除了之前讲到的作用外，在特殊的上下文环境中是可以用作字符连接的。所以他们又称为字符串操作符，字符串操作符有一些很有趣的行为。如果表达式以一个字符串起头，那么后续所有的操作数都必须是字符串型（编译器会自动将双引号中的字符序列传化成字符串）:

public class stringoperators{
public static void main(string [] args){
int x=0,y=1,z=2;
string s="x,y,z";
system.out.println(s+x+y+z);
system.out.println(x+""+s);
s+="(summed) =";
system.out.println(s+(x+y+z));
system.out.println(“"+x);
}
}

输出
x,y,z 012
0 x,y,z
x,y,z (summed) = 3
0
应注意的是第一行输出的是012而不是总和3,是因为编译器将他们自动转化成了字符串形式，最后部分用+=讲一个字符串追加到了s上，并且用括号来控制了编译器的转换，使他们可以顺利求和。