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