JAVA程序员必读：基础篇(2.b)语言基础

　　语言基础
　　3.2.1 算术操作符
　　这个程序得输出为：
　　变量数值...
　　i = 37
　　j = 42
　　x = 27.475
　　y = 7.22
　　加...
　　i + j = 79
　　x + y = 34.695
　　减...
　　i - j = -5
　　x - y = 20.255
　　乘...
　　i * j = 1554
　　x * y = 198.37
　　除...
　　i / j = 0
　　x / y = 3.8054
　　计算余数...
　　i % j = 37
　　x % y = 5.815
　　混合类型...
　　j + y = 49.22
　　i * x = 1016.58
　　这里注意，当一个整数和一个浮点数用为运算符来执行单一算术操作的时候，结果为浮点型。整型数是在操作之前转换为一个浮点型数的。下面的表总结了根据运算对象的数据类型由算术操作符返回的数据类型。它们是在操作执行之前进行数据转换的
　　　
　　除了双元的运算符+和-，还有以下单元运算符：
　　　
　　另外两个简练的算术操作符为++和--。++是完成自加1的作用；而—是完成自减的作用。不管是++还是—都可能出现在运算对象的前面（前缀）或者后面（后缀），但是它们的作用是不一样的。前缀的格式为：++op或--op，它实现了在加/减之后才计算运算对象的数值；而后缀的格式为：op++或op--，它实现了在加/减之前就计算运算对象的数值。
　　下面的程序SortDemo中使用两次++和一个--，如下：
　　public class SortDemo {
　　public static void main(String[] args) {
　　int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076,
　　2000, 8, 622, 127 };
　　for (int i = arrayOfInts.length; --i >= 0; ) {
　　for (int j = 0; j < i; j++) {
　　if (arrayOfInts[j] > arrayOfInts[j+1]) {
　　int temp = arrayOfInts[j];
　　arrayOfInts[j] = arrayOfInts[j+1];
　　arrayOfInts[j+1] = temp;
　　}
　　}
　　}
　　for (int i = 0; i < arrayOfInts.length; i++) {
　　
　　System.out.print(arrayOfInts[i] + " ");
　　}
　　System.out.println();
　　}
　　}
　　这个程序将10整型数值放置在一个数组arrayOfInts中。这个程序使用了arrayOfInts.length来获得数组中的元素个数。单个的元素可以由arrayOfInts[index]来访问，这里index是一个整型数，它指示数组中元素的位置。这里一定要注意index的下标是从0开始的。
　　这个程序的作用是输出从小到大的10个整数，结果为：
　　3 8 12 32 87 127 589 622 1076 2000
　　还是让我们好好看看这个SortDemo程序是怎样工作的。下面是控制外部循环的语句：
　　for (int i = arrayOfInts.length; --i >= 0; ) {
　　...
　　}
　　这个for语句是一个循环结构。其中--i >= 0给出了循环的条件，即--i大于等于0就继续循环，一旦小于0就结束循环。使用前缀--意味着最后的一次循环迭代是发生在当i等于0的时候。如果我们改变改变一下使用后缀的，那么循环迭代的最后一次发生在当i等于-1的时候，这样就会发生错误，因为数组的下标是从0开始的，-1是一个无效的数组下标。
　　程序中其它两个循环使用了后缀的++。在两个例子中，使用前缀或者后缀是没有问题的。当其中一个运算符号返回的数值没有用到，则约定使用后缀的。
　　下面的表格总结自增/自减运算符：
　　　
　　3.2.2 关系与条件运算符
　　关系运算符是比较两个数值并决定它们的关系。比如!=在如果两个运算对象不相等的情况下返回true。以下这个表格总结了关系运算符：
　　　
　　接下来介绍一个例子RelationalDemo。
　　3.2.2 关系与条件运算符
　　下面是一个例子RelationalDemo，它定义了三个整型数并且使用关系运算符来比较它们，如下：
　　public class RelationalDemo {
　　public static void main(String[] args) {
　　//定义几个数
　　int i = 37;
　　int j = 42;
　　int k = 42;
　　System.out.println("变量数值...");
　　System.out.println(" i = " + i);
　　System.out.println(" j = " + j);
　　System.out.println(" k = " + k);
　　//大于
　　System.out.println("大于...");
　　System.out.println(" i > j = " + (i > j)); //false
　　System.out.println(" j > i = " + (j > i)); //true
　　System.out.println(" k > j = " + (k > j)); //false, they are equal
　　//大于等于
　　System.out.println("大于等于...");
　　System.out.println(" i >= j = " + (i >= j)); //false
　　System.out.println(" j >= i = " + (j >= i)); //true
　　System.out.println(" k >= j = " + (k >= j)); //true
　　//小于
　　System.out.println(小于...");
　　System.out.println(" i < j = " + (i < j)); //true
　　System.out.println(" j < i = " + (j < i)); //false
　　System.out.println(" k < j = " + (k < j)); //false
　　//小于等于
　　System.out.println("小于等于...");
　　System.out.println(" i <= j = " + (i <= j)); //true
　　System.out.println(" j <= i = " + (j <= i)); //false
　　System.out.println(" k <= j = " + (k <= j)); //true
　　//等于
　　System.out.println("等于...");
　　System.out.println(" i == j = " + (i == j)); //false
　　System.out.println(" k == j = " + (k == j)); //true
　　//不等于
　　System.out.println("不等于...");
　　System.out.println(" i != j = " + (i != j)); //true
　　System.out.println(" k != j = " + (k != j)); //false
　　}程序的输出为：
　　变量数值...
　　i = 37
　　j = 42
　　k = 42
　　大于...
　　i > j = false
　　j > i = true
　　k > j = false
　　大于等于...
　　i >= j = false
　　j >= i = true
　　k >= j = true
　　小于...
　　i < j = true
　　j < i = false
　　k < j = false
　　小于等于...
　　i <= j = true
　　j <= i = false
　　k <= j = true
　　等于...
　　i == j = false
　　k == j = true
　　Not equal to...
　　i != j = true
　　k != j = false
　　}
　　关系运算符经常用在条件运算符中来构造更复杂的判断表达式。JAVA变成语言支持六种条件运算符：五个双元运算符和一个单元运算符，如下表所示；
　　　
　　&&运算符可以完成条件AND的操作。你可以使用两个不同的关系运算符和&&来决定是否两个关系都为true。下面的一行代码使用了这个技术来决定是否数组的索引处在两个边界之间。它决定了是否索引都大于等于0并且小于等于NUM_ENTRIES(它是在之前被定义为常数)。
　　0 <= index && index < NUM_ENTRIES
　　这里注意在一些实例中，第二个运算对象可能不用运算，因为如果第一个运算对象是false，则结果就一个是false，因此不用在计算第二个运算对象了。你看看以下的代码：
　　(numChars < LIMIT) && (...)
　　&&运算符只有在两个运算对象都为true的时候，才返回true。因此，如果numChars大于等于LIMIT的时候，&&左边的运算对象就为false，这时就不用在计算右边的运算对象就返回了数值false。在这个例子中，编译器将不会计算右边的运算对象。如果右边运算对象有副效应的的话（比如读一个流、更新一个数值或者进行一个计算）这个有重要的含义。
　　当两边的运算对象都是boolean（布尔型），运算符号&跟&&执行相同运算。但是，&总是要计算两边的运算对象然后再在两个运算对象同为true的时候才返回true。同样地，当运算对象都为boolean（布尔型）的时候，|执行与操作符号||一样的功能。这个|运算符总是要计算两边的运算对象然后在最少有一边为true的时候才返回true。当它们的运算对象为数字的时候，& 和|是按位操作的。
　　3.2.3 移位和逻辑运算符
　　移位运算符通过对第一个运算对象左移或者右移位来对数据执行位操作。下面的这个表总结了JAVA编程语言中有效的移位运算符。
　　　
　　每一个运算符移动左边的运算对象的位数都是由右边的运算符给出的。这个移位的方向取决于运算符本身。比如，下面的语句是实现将整数13右移1位的目的：
　　13 >> 1;
　　13的二进制为1101.右移一位的结果为110，即为十进制的6.左边的位用零来填充。下面的表给出了JAVA编程语言提供的四种运算符来对它们的运算对象执行按位操作：
　　　
　　当它的运算对象为数字的时候，&运算符为每一个运算对象的每位执行按位AND功能。AND在运算对象的相应位为1的时候结果才为1，其余情况结果都为0，如下表所示：
　　　
　　假如你要对数13和12作AND操作，比如13&12。运算的结果为12，因为12的二进制为1100，遥13的二进制为1101，具体运算过程如下所示：
　　1101 //13
　　& 1100 //12
　　------
　　1100 //12
　　如果两个运算对象都为1，AND的结果就为1，或者结果就为0。因此，当你对两个运算对象执行AND操作的时候，你可以看到左边的两位结果位1，而右边两位的结果为0。当两个操作对象都位数字的时候，|操作符执行或操作，而^执行异或操作。或操作是说只要