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