记录一下面试题，自己多学习这方面知识

前几天参加了阿里巴巴的电话面试，把他们问的问题都记录了下来，希望对那些正准备面试的人有用。
一、String,StringBuffer, StringBuilder 的区别是什么？String为什么是不可变的？

参考答案：String,StringBuffer, StringBuilder 的区别
二、VECTOR,ARRAYLIST, LINKEDLIST的区别是什么？

参考答案：ArrayList,LinkedList,Vestor区别
三、HASHTABLE, HASHMAP，TreeMap区别

参考答案：HASHTABLE, HASHMAP，TreeMap区别
四、ConcurrentMap和HashMap的区别
五、Tomcat，apache，jboss的区别
六、GET POST区别
七、SESSION, COOKIE区别
八、Servlet的生命周期

参考答案：Servlet的生命周期
九、HTTP 报文包含内容
十、Statement与PreparedStatement的区别,什么是SQL注入，如何防止SQL注入
十一、redirect, foward区别
十二、关于JAVA内存模型，一个对象（两个属性，四个方法）实例化100次，现在内存中的存储状态，
几个对象，几个属性，几个方法。

参考答案：JAVA内存模型
十三、谈谈Hibernate的理解，一级和二级缓存的作用，在项目中Hibernate都是怎么使用缓存的

参考答案：Hibernate缓存机制以及一级缓存和二级缓存的作用
十四、反射讲一讲，主要是概念,都在哪需要反射机制，反射的性能，如何优化
十五、谈谈Hibernate与Ibatis的区别，哪个性能会更高一些

参考答案：Hibernate与Ibatis的区别
十六、对Spring的理解，项目中都用什么？怎么用的？对IOC、和AOP的理解及实现原理

参考答案：spring原理
十七、线程同步，并发操作怎么控制
十八、描述struts的工作流程。

参考答案：描述struts的工作流程
十九、Tomcat的session处理，如果让你实现一个tomcatserver，如何实现session机制
二十、关于Cache(Ehcache,Memcached)
二一、sql的优化相关问题

参考答案：SQL SERVER性能优化综述
二二、oracle中 rownum与rowid的理解，一千条记录我查200到300的记录怎么查？
二三、如何分析ORACLE的执行计划？
二四、 DB中索引原理，种类，使用索引的好处和问题是什么？
二五、JVM垃圾回收实现原理。垃圾回收的线程优先级。

参考答案：JVM的垃圾回收机制详解和性能调优
二六、jvm 最大内存设置。设置的原理。结合垃圾回收讲讲。

评论

5 楼 zhulin902 2011-03-01  

Servlet的生命周期，Servlet和CGI的区别 http://www.zlmind.com/?p=663

4 楼 zhulin902 2011-03-01  

类 HASHSET<E>

所有已实现的接口：Serializable, Cloneable, Iterable<E>, Collection<E>, Set<E>


此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

此类为基本操作提供了稳定性能，这些基本操作包括 add、remove、contains 和 size，假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小（元素的数量）和底层 HashMap 实例（桶的数量）的“容量”的和成比例。因此，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

注意，此实现不是同步的。如果多个线程同时访问一个哈希 set，而其中至少一个线程修改了该 set，那么它必须 保持外部同步。这通常是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSet 方法来“包装” set。最好在创建时完成这一操作，以防止对该 set 进行意外的不同步访问：

   Set s = Collections.synchronizedSet(new HashSet(...));


类 HASHMAP<K,V>

所有已实现的接口：Serializable, Cloneable, Map<K,V>

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。




类 CONCURRENTHASHMAP<K,V>

所有已实现的接口：

Serializable, ConcurrentMap<K,V>, Map<K,V>



支持获取的完全并发和更新的所期望可调整并发的哈希表。此类遵守与 Hashtable 相同的功能规范，并且包括对应于 Hashtable 的每个方法的方法版本。不过，尽管所有操作都是线程安全的，但获取操作不 必锁定，并且不 支持以某种防止所有访问的方式锁定整个表。此类可以通过程序完全与 Hashtable 进行互操作，这取决于其线程安全，而与其同步细节无关。



此类与 Hashtable 相似，但与 HashMap 不同，它不 允许将 null 用作键或值。

3 楼 zhulin902 2011-03-01  

刚开始看到HashTable，HashMap和TreeMap的时候比较晕，觉得作用差不多，但是到实际运用的时候又发现有许多差别的。于是自己搜索了一些相关资料来学习，以下就是我的学习沉淀。

         java为数据结构中的映射定义了一个接口java.util.Map，而HashMap Hashtable和TreeMap就是它的实现类。Map是将键映射到值的对象，一个映射不能包含重复的键；每个键最多只能映射一个一个值。

          Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力.

          Hashtable 与 HashMap类似,但是主要有6点不同。

         1.HashTable的方法是同步的，HashMap未经同步，所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。  

        2.HashTable不允许null值，key和value都不可以,HashMap允许null值，key和value都可以。HashMap允许 key值只能由一个null值，因为hashmap如果key值相同，新的key, value将替代旧的。  

        3.HashTable有一个contains(Object value)功能和containsValue(Object value)功能一样。  

        4.HashTable使用Enumeration，HashMap使用Iterator。  

        5.HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。  

        6.哈希值的使用不同，HashTable直接使用对象的hashCode。

        TreeMap能够把它保存的记录根据键排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。

        下面是HashTable，HashMap和TreeMap总结的一个经典例子。

package com.taobao.luxiaoting;

import java.util.Map;  

import java.util.HashMap;  

import java.util.Set;  

import java.util.HashSet;  

import java.util.Iterator;  

import java.util.Hashtable;  

import java.util.TreeMap;  

class  HashMaps  

{  

       public static void main(String[] args)   

      {  

            Map map=new HashMap();              

            map.put(“a”, “aaa”);  

            map.put(“b”, “bbb”);  

            map.put(“c”, “ccc”);  

            map.put(“d”, “ddd”);  

             

            Iterator iterator = map.keySet().iterator();              

            while (iterator.hasNext()) {  

             Object key = iterator.next();  

             System.out.println(“map.get(key) is :”+map.get(key));  

            }        

                              

            Hashtable tab=new Hashtable();              

            tab.put(“a”, “aaa”);  

            tab.put(“b”, “bbb”);  

            tab.put(“c”, “ccc”);  

            tab.put(“d”, “ddd”);  

            Iterator iterator_1 = tab.keySet().iterator();  

            while (iterator_1.hasNext()) {  

             Object key = iterator_1.next();  

             System.out.println(“tab.get(key) is :”+tab.get(key));  

            }           

              

            TreeMap tmp=new TreeMap();              

            tmp.put(“a”, “aaa”);  

            tmp.put(“b”, “bbb”);  

            tmp.put(“c”, “ccc”);  

            tmp.put(“d”, “ddd”);  

            Iterator iterator_2 = tmp.keySet().iterator();  

            while (iterator_2.hasNext()) {  

             Object key = iterator_2.next();  

             System.out.println(“tmp.get(key) is :”+tmp.get(key));  

            }           

        }  

    }  

2 楼 zhulin902 2011-03-01  

ArrayList,LinkedList,Vestor这三个类都实现了java.util.List接口，但它们有各自不同的特性，主要如下：

一、同步性

ArrayList,LinkedList是不同步的，而Vestor是的。所以如果要求线程安全的话，可以使用ArrayList或 LinkedList，可以节省为同步而耗费开销。但在多线程的情况下，有时候就不得不使用Vector了。当然，也可以通过一些办法包装 ArrayList,LinkedList，使他们也达到同步，但效率可能会有所降低。

二、数据增长
从内部实现机制来讲ArrayList和Vector都是使用Objec的数组形式来存储的。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。

三、检索、插入、删除对象的效率
ArrayList和Vector中，从指定的位置（用index）检索一个对象，或在集合的末尾插入、删除一个对象的时间是一样的，可表示为O(1)。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行(n-i)个对象的位移操作。

LinkedList中，在插入、删除集合中任何位置的元素所花费的时间都是一样的—O(1)，但它在索引一个元素的时候比较慢，为O(i),其中i是索引的位置。

所以，如果只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是对其它指定位置的插入、删除操作，最好选择LinkedList

1 楼 zhulin902 2011-03-01  

String和StringBuffer的区别，网上资料可以说是数不胜数，但是看到这篇文章，感觉里面做的小例子很有代表性，所以转一下，并自己做了一点总结。



在java中有3个类来负责字符的操作。

1.Character 是进行单个字符操作的，

2.String 对一串字符进行操作。不可变类。

3.StringBuffer 也是对一串字符进行操作，但是可变类。

String:
是对象不是原始类型.
为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
String 是final类,即不能被继承.

StringBuffer:
是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,
StringBuffer sb = new StringBuffer();
note:不能通过付值符号对他进行付值.
sb = "welcome to here!";//error
对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer
中付值的时候可以通过它的append方法.
sb.append("hello");

字符串连接操作中StringBuffer的效率要比String高:

String str = new String("welcome to ");
str += "here";
的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后
再将StringBuffer toSting();
这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣.

并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值.
这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

看看以下代码：
将26个英文字母重复加了5000次，

   1.         String tempstr = "abcdefghijklmnopqrstuvwxyz";
   2.         int times = 5000;
   3.         long lstart1 = System.currentTimeMillis();
   4.         String str = "";
   5.         for (int i = 0; i < times; i++) {
   6.             str += tempstr;
   7.         }
   8.         long lend1 = System.currentTimeMillis();
   9.         long time = (lend1 - lstart1);
  10.         System.out.println(time);

可惜我的计算机不是超级计算机，得到的结果每次不一定一样一般为 46687左右。
也就是46秒。
我们再看看以下代码

   1.         String tempstr = "abcdefghijklmnopqrstuvwxyz";
   2.         int times = 5000;
   3.         long lstart2 = System.currentTimeMillis();
   4.         StringBuffer sb = new StringBuffer();
   5.         for (int i = 0; i < times; i++) {
   6.             sb.append(tempstr);
   7.         }
   8.         long lend2 = System.currentTimeMillis();
   9.         long time2 = (lend2 - lstart2);
  10.         System.out.println(time2);

得到的结果为 16 有时还是 0
所以结论很明显，StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候，差异更大。不信你试试。



根据上面所说：

str += "here";
的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后
再将StringBuffer toSting();

所以str += "here";可以等同于

StringBuffer sb = new StringBuffer(str);

sb.append("here");

str = sb.toString();

所以上面直接利用"+"来连接String的代码可以基本等同于以下代码

   1.         String tempstr = "abcdefghijklmnopqrstuvwxyz";
   2.         int times = 5000;
   3.         long lstart2 = System.currentTimeMillis();
   4.         String str = "";
   5.         for (int i = 0; i < times; i++) {
   6.             StringBuffer sb = new StringBuffer(str);
   7.             sb.append(tempstr);
   8.             str = sb.toString();
   9.         }
  10.         long lend2 = System.currentTimeMillis();
  11.         long time2 = (lend2 - lstart2);
  12.         System.out.println(time2);

平均执行时间为46922左右，也就是46秒。



总结: 如果在程序中需要对字符串进行频繁的修改连接操作的话.使用StringBuffer性能会更高