Java面试程序题（一）

一、Integer装箱问题

public class TestMian {
	public static void main(String[] args) {
		Integer aInteger  = 3;
		int bInteger = 3;
		System.out.println(aInteger == bInteger);  // Integer与int比较
		
		Integer cInteger = 3;
		Integer dInteger = 3;
		Integer fInteger = 128;
		Integer gInteger = 128;
		
		System.out.println(dInteger == cInteger);  // Integer与Integer比较
		System.out.println(fInteger == gInteger);  // 超过127，相当于new Integer（）
		
		Integer eInteger = new Integer(3);
		Integer hInteger = 3;
		System.out.println(eInteger == hInteger);
		
	}
}

运行结果：

true,true,false,false

总结：

• 1、int和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较
• 2、Integer与Integer进行比较的时候，由于直接赋值的时候会进行自动装箱，这里需要注意两个问题，一个是 -128=< x <=127 的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中取得已经创建好的Integer对象。当大于这个范围的时候，直接用new Integer来创建Integer对象
• 3、new Integer（1） 和 Integer a = 1不同，前者会创建对象存储在堆中，而后者因为在-128到127之间，不会创建新的对象，而是直接从缓存中取，所以地址肯定不同。
  如果Integer b = 128，大于该范围，会直接new Integer。

二、java 中的 Math.round(-1.5) 等于多少？

答：-1（特殊值-1.5，-2,5等）
计算方法(就此题而言)：

• 1、小数点后的第一位<5,运算结果为参数值整数部分

• 2、小数点后的第一位>5,运算结果为参数整数部分绝对值+1，符号不变

• 3、小数点后的第一位=5,正数运算结果为整数部分+1，复数运算结果为负数整数部分；若小数点后第二位还有值的话，则运算结果为负数整数部分绝对值加1，再加上符号。

    System.out.println(Math.round(-2.5));  // -2
    System.out.println(Math.round(-2.55)); // -3
    System.out.println(Math.round(2.5));   // 3   
  

三、Arrays.asList()方法

int[] datas = new int[]{1,2,3,4,5};
List list = Arrays.asList(datas);
System.out.println(list.size());

运行结果： 1

Integer[] datas = new Integer[]{1,2,3,4,5};
List list = Arrays.asList(datas);
System.out.println(list.size());

运行结果：5

分析：
asList接收的是一个泛型的参数，再构造一个ArrayList，然而基本类型是不支持泛型化的，但是数组支持，所以采用基本类型的数组转化后是将数组放入了构造的ArrayList中，所以长度为1.

延伸：但是执行list.add(3)的时候，就又会报错了。
原因：返回的ArrayList不是List的子类ArrayList，而是Arrays自己的一个内部类，这个类没有实现add(),remove()等方法，而是直接使用它的父类AbstractList的相应方法，而AbstractList中的add(),remove()方法是直接抛出异常UnsupportedOperationException。
要想添加元素，可以转化为java.util.ArrayList即可：

Integer[] datas = new Integer[]{1,2,3,4,5};
ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(datas));

四、值传递和引用传递

1、StringBuffer

public class TestReference {
	public static void main(String[] args) {
	
		StringBuffer a = new StringBuffer("A");
		StringBuffer b = new StringBuffer("B");
		operate(a, b);
		System.out.println(a +"  "+b);
	}
	
	static void operate(StringBuffer x ,StringBuffer y){
		x.append(y);
		y = x;    //步骤1
		System.out.println("y= " + y);
	}
}

运行结果：AB B
解析：在向operate方法传递参数时，传递的是原变量的副本，这个副本也指向原来的变量堆中的内存地址，所以如果对这个副本进行操作的话，会影响到原来的变量。
但是步骤1的地方，只是两个副本进行了交换，并没有对指向的内存地址进行操作，所以原变量b并没有被改变。

2、String

public class TestReference {
	public static void main(String[] args) {
		
		String aString = new String("A");
		String bString = new String("B");
		operate(aString, bString);
		System.out.println(aString +"  "+bString);
		
	}
	
	static void operate(String x ,String y){
		x = x.concat("1"); // 步骤1
		x = y;  
		y = x + y;
	}

运行结果：A B
解析：因为String值是不可变的，所以每次操作相当于在堆中新建了字符串，改变了参数引用的指向，比如 步骤1 的地方，就是新建字符串“A1”,并将x副本的引用指向这个新的字符串地址。

3、List

public class TestReference {
	public static void main(String[] args) {
		List<List<String>> fatherList = new LinkedList<>();
		List<String> childList = new ArrayList<>();
		childList.add("before and child list");
		fatherList.add(childList);
		childList.add("after add child list");
		for (int i = 0; i < fatherList.size(); i++) {
			System.out.println(fatherList.get(i));
		}
	}
}
运行结果：[before and child list, after add child list]

---

---

【Java面试题与答案】点我☞：一键直达