面试总结1

面试题1：

          ==和equals()的区别?
            A:==
                基本类型：比较的是值是否相同
                引用类型：比较的是地址值是否相同
            B:equals()
                只能比较引用类型。默认情况下，比较的是地址值是否相同。
                但是，我们可以根据自己的需要重写该方法。

 

           1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　　如果作用于引用类型的变量，则比较的是所指向的对象的地址

 

　     　2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量

 

　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容

  面试题 2

            String StringBuffer StringBuilder 之间的区别

          

　　最近学习到StringBuffer，心中有好些疑问，搜索了一些关于String，StringBuffer，StringBuilder的东西，现在整理一下。

关于这三个类在字符串处理中的位置不言而喻，那么他们到底有什么优缺点，到底什么时候该用谁呢？下面我们从以下几点说明一下

　　1.三者在执行速度方面的比较：StringBuilder >  StringBuffer  >  String

　　2.String <（StringBuffer，StringBuilder）的原因

　　　　String：字符串常量

　　　　StringBuffer：字符创变量

　　　　StringBuilder：字符创变量

　　　　从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问  ，比如这段代码：

1 String s = "abcd";
2 s = s+1;
3 System.out.print(s);// result : abcd1

 

 　　　   我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来　　　　执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。

　　　  而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

　　3.一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

 

　　

　　　　你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：

　　　　String str = “This is only a” + “ simple” + “test”;

　　　　其实就是：

　　　　String str = “This is only a simple test”;

　　　　所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：

　　　　String str2 = “This is only a”;

　　　　String str3 = “ simple”;

　　　　String str4 = “ test”;

　　　　String str1 = str2 +str3 + str4;

　　　　这时候JVM会规规矩矩的按照原来的方式去做。

　　4.StringBuilder与 StringBuffer

　　　　StringBuilder：线程非安全的

　　　　StringBuffer：线程安全的

　　　　当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。

 

           对于三者使用的总结： 1.如果要操作少量的数据用 = String

　　　　　　　　　　              2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

　　　　　　　　　　              3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

 

  面试题3  integer 的缓存区

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的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱。

 

 

 

实例分析

 

 

 

先看一个例子。

 

 

 

public class Test {

	public static void main(String[] args) {
		
		Integer i = new Integer(128);
		Integer i2 = 128;
		
		System.out.println(i == i2);
		
		Integer i3 = new Integer(127);
		Integer i4 = 127;
		System.out.println(i3 == i4);
		
		Integer i5 = 128;
		Integer i6 = 128;
		System.out.println(i5 == i6);
		
		Integer i7 = 127;
		Integer i8 = 127;
		System.out.println(i7 == i8);
	}
}

输出的结果为

 

 

false
false
false
true

 

 

我们一个一个的进行分析。

第一个情况：

 

 

 

Integer i = new Integer(128);
Integer i2 = 128;

i 是创建的一个Integer的对象，取值是128。
i2 是进行自动装箱的实例，因为这里超出了-128--127的范围，所以是创建了新的Integer对象。

那么i和i2都是Integer的对象咯。存储在堆中，分配的地址不同，在使用==进行判读的时候，由于双方都是对象，所以比较对象的地址是不是相同，这里的地址是不同的，因为new的时候会在堆中重新分配存储空间。

 

 

 

第二个情况：

 

 

 

Integer i3 = new Integer(127);
Integer i4 = 127;

i3 是创建的一个Integer的对象，取值是127.

i4 是进行自动装箱后生成的Integer的对象，其值-128<= i4 <= 127，所以在这里会与第一种情况有所不同，这个i4对象直接取缓存IntegerCache中的对应的对象，当然了也是对象。

 

那么i3和i4也都是对象咯，而且一个是缓存中的，一个自己new的，既然是对象那么==会比较其地址，因为都new出来的对象（一个是自己new出来的，一个是IntegerCache中new出来的对象），那么自然这两种情况下，在堆中分配的地址是不同的。

 

 

 

第三种情况：

 

 

 

Integer i5 = 128;
Integer i6 = 128;

 

i5是自动装箱产生的Integer的对象，但是其大小超过了范围：-128<=A <=127，那么，这里会直接自己创建该对象即：new Integer(128);

 

i6和i5类似的原理。

 

显然这两个对象都是new出来，在堆中的地址值是不同的，那么==的时候判读其地址是不是相等，也就不一样了。

 

 

 

第四种情况：

 

 

 

Integer i7 = 127;
Integer i8 = 127;

i7、i8是自动装箱产生的对象，其值都是127，那么这里很特殊的是127正好在-128<=i7<=127这个范围内的，那么会去IntegerCache中取，既然都是去IntegerCache中去取，那么自然该对象应该是一个对象，那么再堆中的地址应该是一样的，所以在判读两个对象是不是== 的时候，会输出true

 

 

源码解析

 

下面看下，Integer中的装箱的代码

 

 

 

 

当不用new Integer的时候，构造方法会通过这个方法来构造对象并返回。那么你看if中的代码就知道了，i>=IntegerCache.low&&i<=IntegerCache.high的时候，从IntegerCache中获取的实例，否则，直接new Integer(i);

 

 

 

下面就是IntegerCache的代码，其中low就是-128,high是默认的127,不过可以进行设置。

 

通过静态代码块直接创建了256个Integer的对象，从-128到127之间。

 

所以在第四种情况中，取出来的时候，都是经过了上面的return IntegerCache.cache[i + (-IntegerCache.low)]得到的最终的对象，因为在IntegerCache中是创建好的，不会从新new了，所以地址值是一样的，也就是同一个对象，所以为true。