java常见面试题

HashMap、TreeMap、HashTable区别：

1 HashMap不是线程安全的

           Hashmap是一个接口 是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。HashMap允许null key和null value，而hashtable不允许。

   HashMap的初始化容量为16，装配因子为0.75，默认的threshold（记录实际容量多大时来扩充整体的容量）是16*0.75,如果需要扩充，那么容量是原来的2倍。

put:    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
       for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                         V oldValue = e.value;
                         e.value = value;
                         e.recordAccess(this);
                          return oldValue;
                         }
                  }
                 modCount++;
                 addEntry(hash, key, value, i);
                 return null;
           }

先判断key是否为null，如果为null就执行putForNullKey函数：会在table[0]中找到第一个key为null的Entry，然后用新的value替换掉旧的value。如果没找到，就把这个新的key-value放到table[0]的头结点。如果key不为null，就根据key的hashcode计算机hash值，在根据hash值找到在table中的位置i，遍历这个table[i]，如果找到key一样的，就换掉原来value，如果没有就在table[i]的头结点处插入新的key-value。

2   HashTable是线程安全的一个Collection。

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

3 TreeMap默认是按照key升序排序的，但是可以在构造方法里改变默认的排序方式，例如

public class CollatorComparator implements Comparator {

Collator collator = Collator.getInstance();

public int compare(Object element1, Object element2) {

    CollationKey key1 = collator.getCollationKey(element1.toString());

    CollationKey key2 = collator.getCollationKey(element2.toString());

    return key1.compareTo(key2);

}

    CollatorComparator comparator = new CollatorComparator();

    TreeMap map = new TreeMap(comparator );

ArrayList和LinkedList：

一般大家都知道ArrayList和LinkedList的大致区别： 
     1.ArrayList是实现了基于动态数组的数据结构（初始容量是10，需要扩充时是（旧容量*1.5+1）），LinkedList基于链表的数据结构。 
     2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 
     3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 

ArrayList和LinkedList在性能上各 有优缺点，都有各自所适用的地方，总的说来可以描述如下： 
1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

3．LinkedList不支持高效的随机元素访问。

4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列 数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中 间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

Arrays的sort方法用了什么排序算法：

java中Arrays.sort使用了两种排序方法，快速排序和优化的合并排序。
快速排序主要是对哪些基本类型数据（int,short,long等）排序， 而合并排序用于对对象类型进行排序。
使用不同类型的排序算法主要是由于快速排序是不稳定的，而合并排序是稳定的。这里的稳定是指比较相等的数据在排序之后仍然按照排序之前的前后顺序排列。对于基本数据类型，稳定性没有意义，而对于对象类型，稳定性是比较重要的，因为对象相等的判断可能只是判断关键属性，最好保持相等对象的非关键属性的顺序与排序前一直；另外一个原因是由于合并排序相对而言比较次数比快速排序少，移动（对象引用的移动）次数比快速排序多，而对于对象来说，比较一般比移动耗时。

try finally return以及Systrem.exit(0)的执行顺序

 try{

          System.out.println("hello world");

           return;

       }catch(RuntimeException e){

           e.printStackTrace();

       }finally{

           System.out.println("goodbye world");

       }

输出结果： hello world

           goodbye world

finally 块会在return之前执行

•                

• try{

• System.out.println("hello world");

           System.exit(0);

       }catch(RuntimeException e){

           e.printStackTrace();

       }finally{

           System.out.println("goodbye world");

       }

输出结果： hello world

finally 块不会被执行

Spring构造方法注入和setter注入区别：

如果发现配置了对象的构造注入，那么Spring会在调用构造函数前把构造函数需要的依赖对象都实例化好，然后再把这些实例化后的对象作为参数去调用构造函数。
在使用构造函数和set方法依赖注入时，Spring处理对象和对象依赖的对象的顺序时不一样的。一般把一个Bean设计为构造函数接收依赖对象时，其实是表达了这样一种关系：他们（依赖对象）不存在时我也不存在，即“没有他们就没有我”。
通过构造函数的注入方式其实表达了2个对象间的一种强的聚合关系：组合关系。就比如一辆车如果没有轮子、引擎等部件那么车也就不存在了。而且车是由若干重要部件组成的，在这些部件没有的情况下车也不可能存在。这里车和他的重要部件就时组合的关系。如果你的应用中有这样类似的场景那么你应该使用“构造函数注入”的方式管理他们的关系。“构造函数注入”可以保证合作者先创建，在后在创建自己。
通过set方法注入的方式表达了2个对象间较弱的依赖关系：聚合关系。就像一辆车，如果没有车内音像车也时可以工作的。当你不要求合作者于自己被创建时，“set方法注入”注入比较合适。
虽然在理论上“构造函数注入”和“set方法注入”代表2种不同的依赖强度，但是在spring中，spring并不会把无效的合作者传递给一个 bean。如果合作者无效或不存在spring会抛出异常，这样spring保证一个对象的合作者都是可用的。所以在spring中，“构造函数注入”和 “set方法注入”唯一的区别在于2种方式创建合作者的顺序不同。
使用构造函数依赖注入时，Spring保证所有一个对象所有依赖的对象先实例化后，才实例化这个对象。（没有他们就没有我原则）
使用set方法依赖注入时，Spring首先实例化对象，然后才实例化所有依赖的对象。

for循环List不能删除对象：

List<String> lists = new ArrayList<String>();
lists.add("北京");
lists.add("上海");
lists.add("广东");
lists.add("重庆");
lists.add("天津");
lists.add("深圳");

for(String s: lists){
if(s.equals("上海")){
lists.remove(s);
}
}                                   

这种写法不行，会报出异常，正确写法如下：

for(Iterator<String> iter = lists.iterator();iter.hasNext();){
String s = iter.next();
if(s.equals("上海")){
iter.remove();
}
}

或者：

for(int i=0;i<lists.size();i++){
String s =lists.get(i);
if(s.equals("上海")){
lists.remove(s);
}
}