2.运算符篇

1.

int[] refToArray={10,11};int var=1;refToArray[var-1]=var=2;System.out.println(refToArray[0]+" "+refToArray[1]);/** * 根据java语言规定，运算顺序从右至左，赋值属性从左至右。 * 故先计算数组下标的，所以refToArray[0]被赋值为2。 * 所以，打印输出2 11. * */

2.在补码中，1110代表的是几？

（1）首位为1，所以是负数，先写一个负号，再确定后面的数字

（2）取反-------》0001

（3）加1---------》0010（对应的十进制是2）

所以第一步和第三步合起来就是：-2

3.-2在补码中如何表示？

正数在补码中就是该正数；负数的补码是，不管负号，取反加1就是该负数的补码。

（1）2的二进制表示是：0010

（2）取反加1：1110

所以-2的补码是：1110

4.

int x=1;int y=~x+1;System.out.println(x+" "+y);/** * ~运算符和++、--运算符不一样，它不会改变变量的值。所以x还是原值，经过运算后y的值为-1. * 所以输出1 -1 * */

5.

（1）

System.out.println(3/0);//该句代码会抛出 java.lang.ArithmeticException异常

（2）

System.out.println(3.0/0);//该句代码不会抛出异常，输出的是：Infinity

小结：当除法运算中右操作数为0的时候，如果左操作数为整数，会抛出异常；如果左操作数为float或者double，会产生Infinity值。

    当除法运算中右操作数为0.0（或者简写为0.）的时候，不管左操作数是整型还是浮点型，都会产生Infinity值。

这是因为如果有浮点型的值，会进行自动转换。浮点型有无限值（Infinity）和NaN的概念，不会抛出异常；但是整数没有这些概念。

（3）

System.out.println(3%0);//该句代码会抛出 java.lang.ArithmeticException异常

（4）

System.out.println(3.0%0);//该句代码不会抛出异常，输出的是：NaN

小结：取余运算归根结底为除法运算，当右边操作数为0时，如果操作数均为整数，则会抛出 java.lang.ArithmeticException异常；

  如果左操作数为浮点数，则结果为一个NaN。

6.

byte x=-64;byte y=-6;System.out.println(x/y+" "+x%y);/** * x/y好确定，为10；取模运算中，余数的符号完全取决于左操作数，和左操作数的符号一致，故x%y值为-4。 * 打印：10 -4 * */

7.

double x=64.5;double y=6.0;System.out.println(x/y+" "+x%y);/** * x/y好确定，为10.75； * 在取模运算中，不管有没有浮点数，步骤是用左边的操作数连续地去减右边的操作数，直到结果小于右边的操作数，此时的结果即为余数 * 故x%y值为4.5。 * 打印：10.75 4.5 * */

8.

double x=64.0;double y=0.0;System.out.println(x%y!=x%y);/** * 本题考察的核心是NaN值。NaN是一个封装在Float和Double类中的一个代表非正常整数值结果的常量。 * 尽管它可以被应用到逻辑运算中和任何值包括自身进行比较，除了不等于（!=）这个结果为true， * 其它的比如大于、小于或者等于，结果都为false。 * 故输出为false。 * 小结： * x%y!=x%y   输出true * x%y==x%y   输出false * x%y > x%y  输出false * x%y < x%y  输出false * */

9.

System.out.println(Float.NaN==Float.NaN);System.out.println(Float.POSITIVE_INFINITY==Float.POSITIVE_INFINITY);/** * INFINITY常量代表无限值，但其只是一个特殊的数值，而不是非数值（其行为不同于NaN，NaN是非数值）。 * INFINITY和自身进行逻辑相等运算返回的是true * 输出为false * true * */

10.移位运算符

（1）java提供了三种移位运算符：<<（带符号左移）、  >>（带符号右移）、  >>>（无符号右移）

（2）移位运算的操作数只能是整数，即char、byte、short、int、long5中类型。进行移位运算时，总是先将char、byte、short转换为int后再进行运算，实际上移位运算操作的对象只有整型或者长整型。

（3）<<（带符号左移）不论正负，低位补0； >>（带符号右移）整数高位补0，负数高位补1；>>>（无符号右移），高位总是补0。

（4）移位运算符右边的操作数用于指定移动的位数，按规定其不应该超过左操作数的二进制表示位数。比如，对一个int型数进行移位，其右操作数应该小于32；对一个long型的数据进行移位，其右操作数应该小于64。

但实际上，如果右操作数大于了规定的位数，并不会报错，而是取右操作数对于规定位数的模来进行移位操作。比如，对于一个int型的数据，左移或者右移32（或者32*n位）位，结果还是原来的数。即17>>32的结果仍然是17，而不是0。

11.

System.out.println(-31>>>5>>5>>>5>>5>>>5>>5);

算术运算从左到右一个一个算，按照运算规则，输出为3。

12.

System.out.println(32>>32);//输出为32，见第十题的分析。

13.比较运算符：

（1）java提供了6种比较运算符：>、>=、<、<=、==、!=

（2）这6种比较运算符适合所有的基本类型数值之间的比较，但布尔型值只能与布尔型值进行==和!=，运算

（3）字符型的值可以与除了布尔型的值之外的其它基本类型进行比较，因为每个字符都有一个对应的标准字符码。当字符型值进行比较运算时，实际比较的是该字符对应的一个整数字符码。比如64.0f<'A' ，此表达式返回的是true，因为字符'A'被强制转换为浮点型65.0f，所以值为true

（4）关系运算符==和!=不仅可以用于基本类型之间的比较，还可以用于引用类型之间的比较，但比较的是引用类型指向对象的内存地址值

14.

（1）表达式       "String".replace('g', 'G')=="String".replace('g', 'G')     的值是多少？

在String类的代码中，replace方法的执行流程是这样的：

如果发生了替换，就返回一个新的字符串；如果没有发生替换，就返回this，即原来的字符串。

所以上面的表达式返回false

（2）表达式 "String".replace('T', 'G')=="String" 的值是多少？

由于替换没有发生，所以返回的是原来的字符串，因此表达式的值为true

（3）同理，表达式   "String".replace('t', 't')=="String"的值是true

15.对于String类的substring函数和trim函数等等一些字符串处理函数，和replace函数一样，是同一个道理（道理就是，没有变化，返回的就是原来的；变化了返回的就是一个新的对象），所以

（1）表达式 "String".substring(1)=="String" 值为false

（2）表达式 "String".substring(0)=="String" 值为true

（3）表达式 "String".substring(0,6)=="String" 值为true

注意，在substring方法中，substring(int beginIndex, int endIndex)，截取的包含头，不包含尾。这样的话有一个好处，就是尾减去头就是字符串的长度了。

（4）表达式 "String".trim()=="String" 值为true

（5）表达式 "String     ".trim()=="String" 值为false

（6）表达式 "STRING".toUpperCase()=="STRING" 值为true

（7）表达式 "STRING".toString()=="STRING" 值为true