Java中的集合类解析和一些有深入的面试题

Java集合类解析

List、Map、Set三个接口，存取元素时，各有什么特点？

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

Hashtable和HashMap的区别： 

1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类； 
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决： 
Map Collections.synchronizedMap(Map m)  
这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。 
3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。 

Vector、ArrayList和List的异同  
线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。 
Collection 
├List 
│├LinkedList 
│├ArrayList 
│└Vector 
│　└Stack 
└Set 
Map 
├Hashtable 
├HashMap 
└WeakHashMap 
Collection接口 
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。 
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下： 
　　　　Iterator it = collection.iterator(); // 获得一个迭代子 
　　　　while(it.hasNext()) { 
　　　　　　Object obj = it.next(); // 得到下一个元素 
　　　　} 
　　由Collection接口派生的两个接口是List和Set。 
List接口 
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。 
和下面要提到的Set不同，List允许有相同的元素。 
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。 
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。 
LinkedList类 
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。 
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List： 
　　　　List list = Collections.synchronizedList(new LinkedList(...)); 
ArrayList类 
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。 
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。 
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。 
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。 
Vector类 
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。 
Stack 类 
　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。 
Set接口 
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。 
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。 
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。 
Map接口 
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。 
Hashtable类 
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。 
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。 
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。 
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”： 
　　　　Hashtable numbers = new Hashtable(); 
　　　　numbers.put(“one”, new Integer(1)); 
　　　　numbers.put(“two”, new Integer(2)); 
　　　　numbers.put(“three”, new Integer(3)); 
　　要取出一个数，比如2，用相应的key： 
　　　　Integer n = (Integer)numbers.get(“two”); 
　　　　System.out.println(“two = ” + n); 
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。 
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。 
　　Hashtable是同步的。 
HashMap类 
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。 
WeakHashMap类 
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。 
总结 
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。 
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。 
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。 

　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

Java面试题一

 第一章：Java基础篇

1、谈谈你对java的认识

     这个问题很大，很抽象，要回答好确实不容易。宏观上面来说，从C语言面向过程到C++面向对象到java语言纯面向对象这一发展过程都是为了提高公用性、重用性、可读性，降低耦合性。java程序是对象的集合，是一系列带有方法的对象组合，这些方法以其他对象为参数，并发送消息给其他对象。这样由于java中的对象是由状态、行为和标识组成。状态可以认为是对象存在的具体值；行为可认为是对象所能做的操作；而标识是对象在内存中的唯一地址。通常在程序中只能看到对象的前两个属性。在java中所有的代码都必须写在class里，而每个对象都是某个类(class)的一个实例(instance)，也就是说java中的所有操作都是由对象完成的。

   java有许多优良的特性，使得Java应用具有无比的健壮性和可靠性，这也减少了应用系统的维护费用。Java对对象技术的全面支持和Java平台内嵌的API能缩短应用系统的开发时间并降低成本。Java的编译一次，到处可运行的特性使得它能够提供一个随处可用的开放结构和在多平台之间传递信息的低成本方式。java的优良特性说明如下：

 1)简单。Java丢弃了C++ 中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别是，Java语言不使用指针，并提供了自动的垃圾回收机制，使得程序员不必为内存管理而担忧。

 2)面向对象。Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制。Java语言全面支持动态绑定，而C++ 语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。

 3)分布式。Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java.net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、 ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。

 4)健壮。Java的强类型机制、异常处理、废料的自动收集等是Java程序健壮性的重要保证，Java的安全检查机制使得Java更具健壮性。

 5)安全。Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以外，Java对通过网络下载的类具有一个安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。

 6)体系结构中立。Java程序在Java平台上被编译为体系结构中立的字节码格式, 然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。 
 7)可移植性。任意一个JAVA程序，不论它运行在何种CPU、操作系统或JAVA编译器上，都将产生同样的结果。人们使用C、C++也可以产生同样的效果。但C或C++在许多细节上它都没有严格定义，如：未初始化变量的值、对已释放的内存的存取、浮点运算的尾数值等等。所以除非你一开始就严格按照系统无关的概念来进行设计，否则这种可移植性只能是一种理论上的设想而不能形成实践。而JAVA定义了严密的语意结构，它的特性能够减小在不同平台上运行的JAVA程序之间的差异，也使得JAVA具有即使没有JAVA虚拟机的存在的情况下比C和C++更好的平台无关性。
 8)解释型。Java程序在Java平台上被编译为字节码格式， 然后可以在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
 9)高性能。与那些解释型的高级脚本语言相比，Java的确是高性能的。事实上，Java的运行速度随着JIT(Just-In-Time)编译器技术的发展越来越接近于C++。 
  10)多态。Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

   注：在回答这个问题时，应该先从宏观方面说出java面向对象的特点，然后从java特性展开说明。其中1)、2)、3)、4)、5)能说出来最好，其他几点相对来说无关紧要。

2、抽象类与接口

   抽象类：抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象，我们不能把它们实例化（拿不出一个具体的东西）所以称之为抽象。在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为这个抽象类的所有派生类。

   接口：Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

     区别：1)从设计理念层面上：abstract class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a"关系，即父类和派生类在概念本质上应该是相同的。对于interface来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已，接口与实现类 之间的关系是"like-a"的关系。(举例：class AlarmDoor extends Door implements Alarm)；2)从语法定义层面上：在abstract class方式中，抽象类可以有自己的数据成员，也可以有非 abstract的成员方法，而在interface方式的实现中，只能有有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的 abstract class。abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑。在abstract class的定义中，我们可以赋予方法的默认行为。但是在interface的定义中，方法却不能拥有默认行为。

3、overload和override的区别 

    overload是重载，是同一个类中有相同的方法名，但参数类型或个数彼此不同。1)参数类型、个数、顺序至少有一个不相同。2)不能重载只有返回值不同的方法名。3)存在于父类和子类、同类中。

      override是重写，是在子类与父类中，子类中的方法的方法名，参数个数、类型都与父类中的完全一样，在子类中覆盖掉了父类的改方法 。1)方法名、参数、返回值相同。2)子类方法不能缩小父类方法的访问权限。3)子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。4)存在于父类和子类之间。5)方法被定义为final不能被重写。

4、String与StringBuffer的区别 

     JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(newStringBuffer(“abc”)的结果为false。 
接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。

 StringBuffer sbf = new StringBuffer();
 for(int i=0;i<100;i++)
 {
        sbf.append(i);
 }

上面的代码效率很高，因为 只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象 。

 String str = new String();
 for(int i=0;i<100;i++)
 {
        str = str + i;
 }

String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。  

5、java集合框架结构(Map,List,Set......)

1）类结构图

简化图

详细图

2）ArrayList,Vector容量相关问题

ArrayList:如果以new ArrayList()方式创建时，初始容量为10个；如果以new ArrayList(Collection c)初始化时，容量为c.size()*1.1，即增加10%的容量；当向ArrayList中添加一个元素时，先进行容器的容量调整，如果容量不够时，则增加至原来的1.5倍加1，再然后把元素加入到容器中，即以原始容量的0.5倍比率增加。

Vector:初始化时容量可以设定，如果以new Vector()方式创建时，则初始容量为10，超过容量时以2倍容量增加。如果以new Vector(Collection c)方式创建时，初始容量为c.size()*1.1，超过时以2倍容量增加。如果以new Vector(int initialCapacity, int capacityIncrement)，则以capacityIncrement容量增加。

3）集合特点 

• List：保证以某种特定插入顺序来维护元素顺序，即保持插入的顺序，另外元素可以重复。
• ArrayList：是用数组实现的，读取速度快，插入与删除速度慢（因为插入与删除时要移动后面的元素），适合于随机访问。
• Vector：功能与ArrayList几乎相同，也是以数组实现，添加，删除，读取，设置都是基于线程同步的。
• LinkedList：双向链表来实现，删除与插入速度快，读取速度较慢，因为它读取时是从头向尾（如果节点在链的前半部分），或尾向头（如果节点在链的后半部分）查找元素。因此适合于元素的插入与删除操作。
• Set：维持它自己的内部排序，随机访问不具有意义。另外元素不可重复。
• HashSet：是最常用的，查询速度最快，因为 内部以HashMap来实现，所以插入元素不能保持插入次序。
• LinkedHashSet：继承了HashSet，保持元素的插入次序，因为内部使用LinkedHashMap实现，所以能保持元素插入次序。
• TreeSet：基于TreeMap，生成一个总是处于排序状态的set，它实现了SortedSet接口，内部以 TreeMap来实现
• TreeMap：键以某种排序规则排序，内部以red-black（红-黑）树数据结构实现，实现了SortedMap接口，具体可参《RED-BLACK(红黑)树的实现TreeMap源码阅读 》
• HashMap: 以哈希表数据结构实现，查找对象时通过哈希函数计算其位置，它是为快速查询而设计的，其内部定义了一个hash表数组（Entry[] table），元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引，如果有冲突，则使用散列链表的形式将所有相同哈希地址的元素串起来，可能通过查看HashMap.Entry的源码它是一个单链表结构。
• Hashtable:也是以哈希表数据结构实现的，解决冲突时与HashMap也一样也是采用了散列链表的形式，不过性能比HashMap要低。
• LinkedHashMap:继承HashMap，内部实体LinkedHashMap.Entry继承自HashMap.Entry，LinkedHashMap.Entry在HashMap.Entry的基础上新增了两个实体引用（Entry before, after），这样实体可以相互串链起来形成链，并且在LinkedHashMap中就定义了一个头节点（Entry header）用来指向循环双向链的第一个元素（通过after指向）与最后一个元素（通过before指向）。在添加一个元素时，先会通过父类HashMap将元素加入到hash表数组里，然后再会在链尾（header.before指向位置）添加（当然这一过程只是调整LinkedHashMap.Entry对象内部的before, after而已，而不是真真创建一个什么新的链表结构向里加那样）；删除先从hash表数组中删除，再将被删除的元素彻底的从双向链中断开。其实在链中添加与删除操作与LinkedList是一样的，可以参考《Java集合框架之LinkedList及ListIterator实现源码分析 》 

4）HashMap与HashTable的区别 

• Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。在多线程应用程序中，我们应该使用Hashtable；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决：Map Collections.synchronizedMap(Map m)，当然与可以自己在使用地方加锁。
• 在HashMap中，可以允许null作为键，且只可以有一个，否则覆盖，但可以有一个或多个值为null。因为当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null，所以HashMap不能由get()方法来判断否存在某个键，而应该用containsKey()方法来判断；而Hashtable不允许null键与null值。
• HashTable使用Enumeration，HashMap使用Iterator。
• Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；
• HashTable中hash table数组默认大小是11，增加的方式是 int newCapacity = oldCapacity * 2 + 1;,即增加至2倍（而不是2倍加1，因为扩容是在增加元素前进行的，在扩容后会将新增元素放入容器中）。HashMap中hash数组的默认大小是16，而且一定是2的多少次方;另外两者的默认负载因子都是0.75。
• 求哈希地址与哈希地址转hash数组（Entry table[]）索引方法不同：
• HashTable直接使用对象的hashCode：

   int hash = key.hashCode();//直接使用键的hashCode方法求哈希值
   //哈希地址转hash数组索引，先使用最大正int数与，这样将负转正数，再与数组长度求模得到存入的hash数组索引位置
   int index = (hash & 0x7FFFFFFF) % tab.length;

  而HashMap重新计算hash值，而且用位运算&代替求模：

   int hash = hash(k);
   int i = indexFor(hash, table.length);
  
   static int hash(Object x) {
   //以键本身的hash码为基础求哈希地址，但看不懂是什么意思
   　　int h = x.hashCode();
   　　h += ~(h << 9);
   　　h ^= (h >>> 14);
   　　h += (h << 4);
   　　h ^= (h >>> 10);
   　　return h;
   }
   static int indexFor(int h, int length) {
   　　return h & (length-1);//将哈希地址转换成哈希数组中存入的索引号
   }

  HashMap实现图：
  

5） 集合中键值是否允许null小结

• List：可以有多个null，可以有重复值
• HashSet：能插入一个null（因为内部是以 HashMap实现 ），忽略不插入重复元素。
• TreeSet：不能插入null （因为内部是以 TreeMap 实现 ） ，元素不能重复，如果待插入的元素存在，则忽略不插入，对元素进行排序。
• HashMap：允许一个null键与多个null值，若重复键，则覆盖以前值。
• TreeMap：不允许null键(实际上可以插入一个null键，如果这个Map里只有一个元素是不会报错的，因为一个元素时没有进行排序操作，也就不会报空指针异常，但如果插入第二个时就会立即报错)，但允许多个null值，覆盖已有键值。
• HashTable：不允许null键与null值(否则运行进报空指针异常)。也会覆盖以重复值。基于线程同步。

6） 对List的选择

• 对于随机查询与迭代遍历操作，数组比所有的容器都要快。
• 从中间的位置插入和删除元素，LinkedList要比ArrayList快，特别是删除操作。
• Vector通常不如ArrayList快，则且应该避免使用，它目前仍然存在于类库中的原因是为了支持过去的代码。
• 最佳实践：将ArrayList作为默认首选，只有当程序的性能因为经常从list中间进行插入和删除而变差的时候，才去选择LinkedList。当然了，如果只是使用固定数量的元素，就应该选择数组了。

7） 对Set的选择

• HashSet的性能总比TreeSet好(特别是最常用的添加和查找元素操作)。
• TreeSet存在的唯一原因是，它可以维持元素的排序状态，所以只有当你需要一个排好序的Set时，才应该使用TreeSet。
• 对于插入操作，LinkedHashSet比HashSet略微慢一点：这是由于维护链表所带来额外开销造成的。不过，因为有了链表，遍历LinkedHashSet会比HashSet更快。

8） 对Map的选择

• Hashtable和HashMap的效率大致相同(通常HashMap更快一点，所以HashMap有意取代Hashtable)。
• TreeMap通常比HashMap慢，因为要维护排序。
• HashMap正是为快速查询而设计的。
• LinkedHashMap比HashMap慢一点，因为它维护散列数据结构的同时还要维护链表。

9） Stack,Vector:Stack基于线程安全，Stack类是用Vector来实现的(public　class Stack extends Vector)，但最好不要用集合API里的这个实现栈，因为它继承于Vector，本就是一个错误的设计，应该是一个组合的设计关系。

10） Iterator对ArrayList(LinkedList)的操作限制：

• 刚实例化的迭代器如果还没有进行后移(next)操作是不能马上进行删除与修改操作的。。
• 可以用ListIterator对集合连续添加与修改，但不能连续删除。。
• 进行添加操作后是不能立即进行删除与修改操作的。。
• 进行删除操作后可以进行添加，但不能进行修改操作。
• 进行修改后是可以立即进行删除与添加操作的。

11） hashCode(),equals()方法:当以自己的对象做为HashMap、HashTable、LinkedHashMap、HashSet 、LinkedHashSet 的键时，一定要重写hashCode ()与equals ()方法，因为Object的hashCode()是返回内存地址，且equals()方法也是比较内存地址，所以当要在这些hash集合中查找时，如果是另外new出的新对象是查不到的，除非重写这两个方法。因为AbstractMap类的containsKey(Object key)方法实现如下:

 if (e.hash == hash && eq(k, e.key))//先比对hashcode，再使用equals
     return true;
 static boolean eq(Object x, Object y) {
     return x == y || x.equals(y);
 }

String对象是可以准确做为键的，因为已重写了这两个方法。因此，Java中的集合框架中的哈希是以一个对象查找另外一个对象，所以重写hasCode与equals方法很重要。 重写hashCode()与equals()这两个方法是针对哈希类，至于其它集合，如果要用public boolean contains(Object o)或containsValue(Object value)查找时，只需要实现equals()方法即可，他们都只使用对象的 equals方法进行比对，没有使用 hashCode方法。

12） TreeMap,TreeSet:放入其中的元素一定要具有自然比较能力(即要实现java.lang.Comparable接口)或者在构造TreeMap/TreeSet时传入一个比较器(实现java.util.Comparator接口)，如果在创建时没有传入比较器，而放入的元素也没有自然比较能力时，会出现类型转换错误(因为在没有较器时，会试着转成Comparable型)。

 //自然比较器
 public interface java.lang.Comparable {
     public int compareTo(Object o);
 }
 public interface java.util.Comparator {
     int compare(Object o1, Object o2);
     boolean equals(Object obj);
 }

13） TreeMap,TreeSet: Collection或Map的同步控制：可以使用Collections类的相应静态方法来包装相应的集合类，使他们具线程安全，如public static Collection synchronizedCollection (Collection c)方法实质返回的是包装后的SynchronizedCollection子类，当然你也可以使用Collections的synchronizedList、synchronizedMap、synchronizedSet方法来获取不同的经过包装了的同步集合，其代码片断:

 public class Collections {
       static Collection synchronizedCollection(Collection c, Object mutex) {
         return new SynchronizedCollection(c, mutex);
     }
     public static List synchronizedList(List list) {

     }
     static Set synchronizedSet(Set s, Object mutex) {

     }
     public static Map synchronizedMap(Map m) {
         return new SynchronizedMap(m);
     }
     static class SynchronizedCollection implements Collection, Serializable {
         Collection c; // 对哪个集合进行同步（包装）
         Object mutex; // 对象锁，可以自己设置
         SynchronizedCollection(Collection c, Object mutex) {
             this.c = c;
             this.mutex = mutex;
         }
         public int size() {
             synchronized (mutex) {
                 return c.size();
             }
         }
         public boolean isEmpty() {
             synchronized (mutex) {
                 return c.isEmpty();
             }
         }
     }

     static class SynchronizedList extends SynchronizedCollection implements List {
         List list;
         SynchronizedList(List list, Object mutex) {
             super(list, mutex);
             this.list = list;
         }
         public Object get(int index) {
             synchronized (mutex) {
                 return list.get(index);
             }
         }
     }
     static class SynchronizedSet extends SynchronizedCollection implements Set {
         SynchronizedSet(Set s) {
             super(s);
         }
     }
 }

由包装的代码可以看出只是把原集合的相应方法放在同步块里调用罢了。

14） 通过迭代器修改集合结构:通过迭代器修改集合结构在使用迭代器遍历集合时，我们不能通过集合本身来修改集合的结构（添加、删除），只能通过迭代器来操作，下面是拿对HashMap删除操作的测试，其它集合也是这样：

 public static void main(String[] args) {
  Map map = new HashMap();
  map.put(1, 1);
  map.put(2, 3);
  Set entrySet = map.entrySet();
  Iterator it = entrySet.iterator();
  while (it.hasNext()) {
   Entry entry = (Entry) it.next();
   /*
    * 可以通过迭代器来修改集合结构，但前提是要在已执行过 next 或
    * 前移操作，否则会抛异常：IllegalStateException
    */
   // it.remove();
   /*
    * 抛异常：ConcurrentModificationException 因为通过 迭代 器操
    * 作时，不能使用集合本身来修
    * 改集合的结构
    */
   // map.remove(entry.getKey());
  }
  System.out.println(map);
 }

6、java io流

     1)java io流相关概念

输出流：

 

输入流：

因此输入和输出都是从程序的角度来说的。

字节流：一次读入或读出是8位二进制。

字符流：一次读入或读出是16位二进制。

字节流和字符流的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。 

节点流：直接与数据源相连，读入或读出。

直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

处理流：与节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。

     2)java io流的分类

按流向分:
输入流: 程序可以从中读取数据的流。
输出流: 程序能向其中写入数据的流。
按数据传输单位分:
字节流: 以字节为单位传输数据的流
字符流: 以字符为单位传输数据的流
按功能分:
节点流: 用于直接操作目标设备的流
过滤流: 是对一个已存在的流的链接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能。

     3)java io类结构图

     流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。Java把这些不同来源和目标的数据都统一抽象为数据流，在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流，java io 类结构如下：

[1]输入字节流InputStream：InputStream 是所有的输入字节流的父类，它是一个抽象类；ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据；PipedInputStream 是从与其它线程共用的管道中读取数据；ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。

[2]输出字节流OutputStream：OutputStream 是所有的输出字节流的父类，它是一个抽象类。
ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据，ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

[3]字节流的输入与输出的对应

图中蓝色的为主要的对应部分，红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。从上面的图中可以看出Java IO 中的字节流是极其对称的。

不对称的类介绍如下：

1>LineNumberInputStream 主要完成从流中读取数据时，会得到相应的行号，至于什么时候分行、在哪里分行是由改类主动确定的，并不是在原始中有这样一个行号。在输出部分没有对应的部分，我们完全可以自己建立一个LineNumberOutputStream，在最初写入时会有一个基准的行号，以后每次遇到换行时会在下一行添加一个行号，看起来也是可以的。好像更不入流了。
2>PushbackInputStream 的功能是查看最后一个字节，不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream 几乎实现相近的功能。
3>StringBufferInputStream 已经被Deprecated，本身就不应该出现在InputStream 部分，主要因为String 应该属于字符流的范围。已经被废弃了，当然输出部分也没有必要需要它了！还允许它存在只是为了保持版本的向下兼容而已。
4>SequenceInputStream 可以认为是一个工具类，将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除，还完全不影响IO 包的结构，却让其更“纯洁”――纯洁的Decorator 模式。
5>PrintStream 也可以认为是一个辅助工具。主要可以向其他输出流，或者FileInputStream 写入数据，本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO 包！System.out 和System.out 就是PrintStream 的实例！

[4]字符输入流Reader：Reader 是所有的输入字符流的父类，它是一个抽象类;CharReader、StringReader 是两种基本的介质流，它们分别将Char 数组、String中读取数据;PipedReader 是从与其它线程共用的管道中读取数据;BufferedReader 很明显就是一个装饰器，它和其子类负责装饰其它Reader 对象;FilterReader 是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号;InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。

[5]字符输出流Writer：Writer 是所有的输出字符流的父类，它是一个抽象类；CharArrayWriter、StringWriter 是两种基本的介质流，它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据，BufferedWriter 是一个装饰器为Writer 提供缓冲功能；PrintWriter 和PrintStream 极其类似，功能和使用也非常相似；
OutputStreamWriter 是OutputStream 到Writer 转换的桥梁，它的子类FileWriter 其实就是一个实现此功能的具体类（具体可以研究一SourceCode）。

[6]字符流的输入与输出的对应

[8]字符流与字节流转换

转换流的特点：
其是字符流和字节流之间的桥梁
可对读取到的字节数据经过指定编码转换成字符
可对读取到的字符数据经过指定编码转换成字节
何时使用转换流？
当字节和字符之间有转换动作时；
流操作的数据需要编码或解码时。
具体的对象体现：
InputStreamReader:字节到字符的桥梁
OutputStreamWriter:字符到字节的桥梁
这两个流对象是字符体系中的成员，它们有转换作用，本身又是字符流，所以在构造的时候需要传入字节流对象进来。

     4)java 管道通信

     Java提供管道功能，实现管道通信的类有两组：PipedInputStream和PipedOutputStream或者是PipedReader和PipedWriter。管道通信主要用于不同线程间的通信。
一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道。PipedOutputStream向管道中写入数据，PipedIntputStream读取PipedOutputStream向管道中写入的数据。一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据。

  //Sender类
 package pipeCommu;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 public class Sender extendsThread{
    private PipedOutputStream out=new PipedOutputStream();//发送者创建PipedOutputStream向外写数据;
    public PipedOutputStream getOut(){
        return out;
    }
    public void run(){
        String strInfo="hello,receiver";
        try{
            out.write(strInfo.getBytes());//写入数据
            out.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
 }
  //Reader类，负责接收数据
 package pipeCommu;
 import java.io.PipedInputStream;
 public class Reader extends Thread{
    private PipedInputStream in=new PipedInputStream();//发送者创建PipedOutputStream向外写数据
    public PipedInputStream getIn(){
        returnin;
    }
    public void run(){
        byte[] buf=new byte[1024];//声明字节数组
        try{
            int len=in.read(buf);//读取数据，并返回实际读到的字节数
            System.out.println("receive from sender:"+newString(buf,0,len));
            in.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
 }
 package pipeCommu;
 import java.io.*;
 public class PipedStream {
     public static void main(String[] args) throws Exception{
        Sender send=new Sender();
        Reader read=new Reader();
        PipedOutputStream out=send.getOut();
        PipedInputStream in=read.getIn();
        out.connect(in);//或者也可以用in.connect(out);
        send.start();
        read.start();
    }
 }
 package pipeCommu;
 import java.io.*;
 public class PipedCommu {
     public static void main(String[] args) {
         // TODOAuto-generatedmethodstub
         try{
              PipedReader reader=new PipedReader();
              PipedWriter writer=new PipedWriter(reader);
              Thread a=new Send(writer);
              Thread b=new Read(reader);
              a.start();
              Thread.sleep(1000);
              b.start();
         }catch(IOException e){
              e.printStackTrace();

         }catch(InterruptedException e1){
              e1.printStackTrace();
         }
     }
 }
     class Send extends Thread{
         PipedWriter writer;
         public Send(PipedWriter writer){
              this.writer=writer;
         }
         public void run(){
              try{
                   writer.write("this is a.hello world".toCharArray());
                   writer.close();
              }catch(IOException e){
                   e.printStackTrace();
              }
         }
     }
     class Read extends Thread{
         PipedReader reader;
         public Read(PipedReader reader){
              this.reader=reader;
         }
         public void run(){
              System.out.println("this is B");
              try{
                   char[] buf=new char[1000];
                   reader.read(buf,0,100);
                   System.out.println(new String(buf));
              }catch(Exception e){
                   e.printStackTrace();
              }
         }
     }

     5)java 对象序列化

     对于一个存在Java虚拟机中的对象来说，其内部的状态只是保存在内存中。JVM退出之后，内存资源也就被释放，Java对象的内部状态也就丢失了。而在很多情况下，对象内部状态是需要被持久化的，将运行中的对象状态保存下来(最直接的方式就是保存到文件系统中)，在需要的时候可以还原，即使是在Java虚拟机退出的情况下。 
     对象序列化机制是Java内建的一种对象持久化方式，可以很容易实现在JVM中的活动对象与字节数组(流)之间进行转换，使用得Java对象可以被存储，可以被网络传输，在网络的一端将对象序列化成字节流，经过网络传输到网络的另一端，可以从字节流重新还原为Java虚拟机中的运行状态中的对象。 

     对于任何需要被序列化的对象，都必须要实现接口Serializable，它只是一个标识接口，本身没有任何成员，只是用来标识说明当前的实现类的对象可以被序列化。

     如果在类中的一些属性，希望在对象序列化过程中不被序列化，使用关键字transient标注修饰就可以。当对象被序列化时，标注为transient的成员属性将会自动跳过。

     注：

      [1].当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法,静态的成员变量和transient标注的成员变量。 
　  [2].如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存还原，而且会是递归的方式。
　  [3].如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。可以将这个引用标记transient,那么对象仍然可以序列化。

       java对象序列化示例代码：

实体类：

 class Student implements Serializable{
     private String name;
     private transient int age;
     private Course course;
     public void setCourse(Course course){
         this.course = course;
     }
     public Course getCourse(){
         return course;
     }
     public Student(String name, int age){
         this.name = name;
         this.age = age;
     }
     public String  toString(){
         return "Student Object name:"+this.name+" age:"+this.age;
     }
 }

 class Course implements Serializable{
     private static String courseName;
     private int credit;
     public Course(String courseName, int credit){
         this.courseName  = courseName;
         this.credit = credit;
     }
     public String toString(){
         return "Course Object courseName:"+courseName
                +" credit:"+credit;
     }
 }

将对象写入文件序列化

 public class TestWriteObject{
     public static void main(String[] args) {
         String filePath = "C://obj.txt";
         ObjectOutputStream objOutput = null;
         Course c1 = new Course("C language", 3);
         Course c2 = new Course("OS", 4);
         Student s1 = new Student("king", 25);
         s1.setCourse(c1);
         Student s2 = new Student("jason", 23);
         s2.setCourse(c2);
         try {
             objOutput = new ObjectOutputStream(new FileOutputStream(filePath));
             objOutput.writeObject(s1);
             objOutput.writeObject(s2);
             objOutput.writeInt(123);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             try {
                 objOutput.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         System.out.println("Info:对象被写入"+filePath);
     }

从文件中读取对象，反序列化

 public class TestReadObject  {

     public static void main(String[] args) {

         String filePath = "C://obj.txt";
         ObjectInputStream objInput = null;
         Student s1 = null,s2 = null;
         int intVal = 0;

         try {
             objInput = new ObjectInputStream(new FileInputStream(filePath));
             s1 = (Student)objInput.readObject();
             s2 = (Student)objInput.readObject();
             intVal = objInput.readInt();

         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }catch(ClassNotFoundException cnfe){
             cnfe.printStackTrace();
         }finally{

             try {
                 objInput.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         System.out.println("Info:文件"+filePath+"中读取对象");
         System.out.println(s1);
         System.out.println(s1.getCourse());
         System.out.println(s2);
         System.out.println(s2.getCourse());
         System.out.println(intVal);
     }
 }

     7、java  nio

    1)java nio简介

     nio 是 java New IO 的简称，在 jdk1.4 里提供的新 api 。 Sun 官方标榜的特性如有：为所有的原始类型提供 (Buffer) 缓存支持；字符集编码解码解决方案；Channel ：一个新的原始 I/O 抽象；支持锁和内存映射文件的文件访问接口；提供多路 (non-bloking) 非阻塞式的高伸缩性网络 I/O 。

    2)java nio非阻塞原理

     一个常见的网络 IO 通讯流程如下 :

     从该网络通讯过程来理解一下何为阻塞 :在以上过程中若连接还没到来，那么 accept 会阻塞 , 程序运行到这里不得不挂起， CPU 转而执行其他线程。在以上过程中若数据还没准备好， read 会一样也会阻塞。阻塞式网络 IO 的特点：多线程处理多个连接。每个线程拥有自己的栈空间并且占用一些 CPU 时间。每个线程遇到外部未准备好的时候，都会阻塞掉。阻塞的结果就是会带来大量的进程上下文切换。且大部分进程上下文切换可能是无意义的。比如假设一个线程监听一个端口，一天只会有几次请求进来，但是该 cpu 不得不为该线程不断做上下文切换尝试，大部分的切换以阻塞告终。

     何为非阻塞？
     下面有个隐喻：
      一辆从 A 开往 B 的公共汽车上，路上有很多点可能会有人下车。司机不知道哪些点会有哪些人会下车，对于需要下车的人，如何处理更好？
      1. 司机过程中定时询问每个乘客是否到达目的地，若有人说到了，那么司机停车，乘客下车。 ( 类似阻塞式 )
      2. 每个人告诉售票员自己的目的地，然后睡觉，司机只和售票员交互，到了某个点由售票员通知乘客下车。 ( 类似非阻塞 )
     很显然，每个人要到达某个目的地可以认为是一个线程，司机可以认为是 CPU 。在阻塞式里面，每个线程需要不断的轮询，上下文切换，以达到找到目的地的结果。而在非阻塞方式里，每个乘客 ( 线程 ) 都在睡觉 ( 休眠 ) ，只在真正外部环境准备好了才唤醒，这样的唤醒肯定不会阻塞。
     非阻塞的原理
     把整个过程切换成小的任务，通过任务间协作完成。由一个专门的线程来处理所有的 IO 事件，并负责分发。事件驱动机制：事件到的时候触发，而不是同步的去监视事件。线程通讯：线程之间通过 wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的进程切换。

     以下是异步 IO 的结构：

    Reactor 就是上面隐喻的售票员角色。每个线程的处理流程大概都是读取数据、解码、计算处理、编码、发送响应。
    异步 IO 核心 API：

    Selector：异步 IO 的核心类，它能检测一个或多个通道 (channel) 上的事件，并将事件分发出去。使用一个 select 线程就能监听多个通道上的事件，并基于事件驱动触发相应的响应。而不需要为每个 channel 去分配一个线程。
    SelectionKey：包含了事件的状态信息和时间对应的通道的绑定。

    3)Buffer结构、主要方法

     Buffer内部结构如图：

    一个 buffer 主要由 position,limit,capacity 三个变量来控制读写的过程。此三个变量的含义见如下表格：    

参数	写模式	读模式
position	当前写入的单位数据数量。	当前读取的单位数据位置。
limit	代表最多能写多少单位数据和容量是一样的。	代表最多能读多少单位数据，和之前写入的单位数据量一致。
capacity	buffer 容量	buffer 容量

    Buffer 常见方法：
    flip(): 写模式转换成读模式
    rewind() ：将 position 重置为 0 ，一般用于重复读。
    clear() ：清空 buffer ，准备再次被写入 (position 变成 0 ， limit 变成 capacity) 。
    compact(): 将未读取的数据拷贝到 buffer 的头部位。
    mark() 、 reset():mark 可以标记一个位置， reset 可以重置到该位置。
    Buffer 常见类型： ByteBuffer 、 MappedByteBuffer 、 CharBuffer 、 DoubleBuffer 、 FloatBuffer 、 IntBuffer 、 LongBuffer 、ShortBuffer 。
    channel 常见类型 :FileChannel 、 DatagramChannel(UDP) 、 SocketChannel(TCP) 、 ServerSocketChannel(TCP)

     4)Buffer、Chanel

     Channel 和 buffer 是 NIO 是两个最基本的数据类型抽象。Buffer:是一块连续的内存块，是 NIO 数据读或写的中转地；Channel:数据的源头或者数据的目的地，用于向 buffer 提供数据或者读取 buffer 数据，buffer 对象的唯一接口，支持异步 I/O 。chanel与Buffer关系如下：

    Buffer、Chanel使用例子：CopyFile.java

 package sample;

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;

 public class CopyFile {
     public static void main(String[] args) throws Exception {
         String infile = "C:\\copy.sql";
         String outfile = "C:\\copy.txt";
         // 获取源文件和目标文件的输入输出流
         FileInputStream fin = new FileInputStream(infile);
         FileOutputStream fout = new FileOutputStream(outfile);
         // 获取输入输出通道
         FileChannel fcin = fin.getChannel();
         FileChannel fcout = fout.getChannel();
         // 创建缓冲区
         ByteBuffer buffer = ByteBuffer.allocate(1024);
         while (true) {
             // clear方法重设缓冲区，使它可以接受读入的数据
             buffer.clear();
             // 从输入通道中将数据读到缓冲区
             int r = fcin.read(buffer);
             // read方法返回读取的字节数，可能为零，如果该通道已到达流的末尾，则返回-1
             if (r == -1) {
                 break;
             }
             // flip方法让缓冲区可以将新读入的数据写入另一个通道
             buffer.flip();
             // 从输出通道中将数据写入缓冲区
             fcout.write(buffer);
         }
     }
 }

     5)nio.charset

     字符编码解码 : 字节码本身只是一些数字，放到正确的上下文中被正确被解析。向 ByteBuffer 中存放数据时需要考虑字符集的编码方式，读取展示 ByteBuffer 数据时涉及对字符集解码。Java.nio.charset 提供了编码解码一套解决方案。
     以我们最常见的 http 请求为例，在请求的时候必须对请求进行正确的编码。在得到响应时必须对响应进行正确的解码。
     以下代码向 baidu 发一次请求，并获取结果进行显示。例子演示到了 charset 的使用。

 package nio.readpage;

 import java.nio.ByteBuffer;
 import java.nio.channels.SocketChannel;
 import java.nio.charset.Charset;
 import java.net.InetSocketAddress;
 import java.io.IOException;
 public class BaiduReader {
     private Charset charset = Charset.forName("GBK");// 创建GBK字符集
     private SocketChannel channel;
     public void readHTMLContent() {
         try {
             InetSocketAddress socketAddress = new InetSocketAddress(
 "www.baidu.com", 80);
 //step1:打开连接
             channel = SocketChannel.open(socketAddress);
         //step2:发送请求，使用GBK编码
             channel.write(charset.encode("GET " + "/ HTTP/1.1" + "\r\n\r\n"));
             //step3:读取数据
             ByteBuffer buffer = ByteBuffer.allocate(1024);// 创建1024字节的缓冲
             while (channel.read(buffer) != -1) {
                 buffer.flip();// flip方法在读缓冲区字节操作之前调用。
                 System.out.println(charset.decode(buffer));
                 // 使用Charset.decode方法将字节转换为字符串
                 buffer.clear();// 清空缓冲
             }
         } catch (IOException e) {
             System.err.println(e.toString());
         } finally {
             if (channel != null) {
                 try {
                     channel.close();
                 } catch (IOException e) {
                 }
             }
         }
     }
     public static void main(String[] args) {
         new BaiduReader().readHTMLContent();
     }
 }

注：本文java io流部分内容参考博客：《java io流分析整理》http://blog.csdn.net/llhhyy1989/article/details/7388059、《java Io流学习总结》http://blog.csdn.net/heliteng/article/details/12812715、《java Io简介》http://sishuok.com/forum/blogPost/list/468.html、《java 对象序列化》http://yuyiming.iteye.com/blog/1277089

 8、java 线程

    1）线程概念，线程与进程

     线程：线程是“进程”中某个单一顺序的控制流。也被称为轻量进程。线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；它与父进程的其它线程共享该进程所拥有的全部资源。进程可以创建和撤消线程，从而实现程序的并发执行。

    进程：进程是操作系统结构的基础；是一个正在执行的程序；计算机中正在运行的程序实例；可以分配给处理器并由处理器执行的一个实体；由单一顺序的执行显示，一个当前状态和一组相关的系统资源所描述的活动单元。

    线程与进程：有时候，线程也称作轻量级进程。就象进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存、文件句柄和其它每个进程应有的状态。进程可以支持多个线程，它们看似同时执行，但互相之间并不同步。一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。进程是资源分配的基本单位。所有与该进程有关的资源，都被记录在进程控制块PCB中。以表示该进程拥有这些资源或正在使用它们。另外，进程也是抢占处理机的调度单位，它拥有一个完整的虚拟地址空间。与进程相对应，线程与资源分配无关，它属于某一个进程，并与进程内的其他线程一起共享进程的资源。当进程发生调度时，不同的进程拥有不同的虚拟地址空间，而同一进程内的不同线程共享同一地址空间。线程只由相关堆栈（系统栈或用户栈）寄存器和线程控制表TCB组成。寄存器可被用来存储线程内的局部变量，但不能存储其他线程的相关变量。发生进程切换与发生线程切换时相比较，进程切换时涉及到有关资源指针的保存以及地址空间的变化等问题；线程切换时，由于同不进程内的线程共享资源和地址空间，将不涉及资源信息的保存和地址变化问题，从而减少了操作系统的开销时间。而且，进程的调度与切换都是由操作系统内核完成，而线程则既可由操作系统内核完成，也可由用户程序进行。

   守护线程：在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程) 
    Daemon的作用是为其他线程的运行提供便利服务，比如垃圾回收线程就是一个很称职的守护者。User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。 
    值得一提的是，守护线程并非只有虚拟机内部提供，用户在编写程序时也可以自己设置守护线程。下面的方法就是用来设置守护线程的。 
    public final void setDaemon(boolean on) 

    2）线程的生命周期

    派生：线程在进程内派生出来，它即可由进程派生，也可由线程派生。
    阻塞（Block）：如果一个线程在执行过程中需要等待某个事件发生，则被阻塞。
    激活（unblock）：如果阻塞线程的事件发生，则该线程被激活并进入就绪队列。
    调度（schedule）：选择一个就绪线程进入执行状态。
    结束（Finish）：如果一个线程执行结束，它的寄存器上下文以及堆栈内容等将被释放。

    3）线程同步与死锁

     同步：许多线程在执行中必须考虑与其他线程之间共享数据或协调执行状态。这就需要同步机制。在Java中每个对象都有一把锁与之对应。但Java不提供单独的lock和unlock操作。它由高层的结构隐式实现, 来保证操作的对应。(然而,我们注意到Java虚拟机提供单独的monito renter和monitorexit指令来实现lock和unlock操作。) 

synchronized语句计算一个对象引用,试图对该对象完成锁操作, 并且在完成锁操作前停止处理。当锁操作完成synchronized语句体得到执行。当语句体执行完毕(无论正常或异常),解锁操作自动完成。作为面向对象的语言,synchronized经常与方法连用。一种比较好的办法是,如果某个变量由一个线程赋值并由别的线程引用或赋值,那么所有对该变量的访问都必须在某个synchromized语句或synchronized方法内。

   死锁：是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。如果程序中有几个竞争资源的并发线程,那么保证均衡是很重要的。系统均衡是指每个线程在执行过程中都能充分访问有限的资源。系统中没有饿死和死锁的线程。Java并不提供对死锁的检测机制。对大多数的Java程序员来说防止死锁是一种较好的选择。最简单的防止死锁的方法是对竞争的资源引入序号,如果一个线程需要几个资源,那么它必须先得到小序号的资源,再申请大序号的资源。

    4）java线程创建与启动

     两种方式创建线程：扩展java.lang.Thread类、实现java.lang.Runnable接口。

    启动线程：在线程的Thread对象上调用start()方法，而不是run()或者别的方法。在调用start()方法之前：线程处于新状态中，新状态指有一个Thread对象，但还没有一个真正的线程。在调用start()方法之后：发生了一系列复杂的事情：启动新的执行线程（具有新的调用栈）；该线程从新状态转移到可运行状态；当该线程获得机会执行时，其目标run()方法将运行。

    线程的名字：一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，并且主线程的名字总是main，非主线程的名字不确定。线程都可以设置名字，也可以通过Thread.currentThread()获取线程的名字。

    5）java的优先级

    线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的并非没机会执行。线程的优先级用1-10之间的整数表示，数值越大优先级越高，默认的优先级为5。在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。

 Thread t1 = new MyThread1();
 Thread t2 = new Thread(new MyRunnable());
 t1.setPriority(10);
 t2.setPriority(1);

   6） wait()，sleep()，yield()，join()，notify()，notifyAll()

    wait():是Object 类的方法，对此对象调用wait 方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify 方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。 
     sleep():是Thread类的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep() 不会释放对象锁。
     yield():方法只是把线程的状态有执行状态打回准备就绪状态，所以，执行这个方法后，有可能马上又开始运行，有可能等待很长时间，yield()方法只能让同优先级的线程有执行的机会，调用yield()不会释放对象锁。 yield()方法先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程。

    join()： join()方法使调用该方法的线程在此之前执行完毕，也就是等待调用该方法的线程执行完毕后再往下继续执行。 join() 方法主要是让调用该方法的thread完成run方法里面的东西后， 在执行join()方法后面的代码。

    t.join():表示当前线程停止执行直到t线程运行完毕；
    t.join(1000): 表示当前线程等待t线程运行1000后执行；

   notify()/notifyAll()：notify和notifyAll都是把某个对象上休息区内的线程唤醒，notify只能唤醒一个，但究竟是哪一个不能确定，而notifyAll则唤醒这个对象上的休息室中所有的线程。

    7）volatile关键字

    用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。

   Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的，如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。
    要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：对变量的写操作不依赖于当前值；该变量没有包含在具有其他变量的不变式中。
    第一个条件的限制使 volatile 变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。实现正确的操作需要使 x 的值在操作期间保持不变，而 volatile 变量无法实现这点。

    每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。

     

    read and load 从主存复制变量到当前工作内存
    use and assign  执行代码，改变共享变量值 
    store and write 用工作内存数据刷新主存相关内容
   其中use and assign 可以多次出现，但是这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样。

说出ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

Collection 和 Collections的区别。

　　Collection是集合类的上级接口，继承与他的接口主要有Set 和List.。Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

17、abstract class和interface有什么区别?

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

1、abstract类可以有包含实体的方法 但是接口不可以

2、接口定义的变量都是final的   而abstract类定义的可以不是final的

3、abstract类可以通过get....()方法实现类的实例 但是接口不可以

4、“抽象类”是一种不能实例化而必须从中继承的类。抽象类可以完全实现，但更常见的是部分实现或者根本不实现，从而封装继承类的通用功能。

 

18、heap和stack有什么区别。

栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。

堆是栈的一个组成元素

heap：是由malloc之类函数分配的空间所在地。地址是由低向高增长的。

stack：是自动分配变量，以及函数调用的时候所使用的一些空间。地址是由高向低减少的。

 

19、forward 和redirect的区别

forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。

redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。

forward 另一个连接的时候。request变量是在其生命周期内的。另一个页面也可以使用
但是redirect则，重新开始一个request。原页面的request生命周期结束。

tatic Nested Class 和 Inner Class的不同。

Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。静态内部类（Inner Class）意味着：1创建一个static内部类的对象，不需要一个外部类对象，2：不能从一个static内部类的一个对象访问一个外部类对象。

设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。

public class ThreadTest1{

 private int j;

 public static void main(String args[]){

ThreadTest1 tt=new ThreadTest1();

Inc inc=tt.new Inc();

Dec dec=tt.new Dec();

for(int i=0;i<2;i++){

Thread t=new Thread(inc);

t.start();

t=new Thread(dec);

t.start();

}

}

 private synchronized void inc(){

j++;

System.out.println(Thread.currentThread().getName()+"-inc:"+j);

 }

 private synchronized void dec(){

j--;

System.out.println(Thread.currentThread().getName()+"-dec:"+j);

 }

 class Inc implements Runnable{

public void run(){

for(int i=0;i<100;i++){

inc();

}

}

 }

 class Dec implements Runnable{

public void run(){

for(int i=0;i<100;i++){

dec();

}

 }

 }

}

70、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？

a: 两种形式 dtd schema，b: 本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)，c:有

DOM,SAX,STAX等

    DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之

前把整个文档装入内存,适合对XML的随机访问

SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标

签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问

    STAX:Streaming API for XML (StAX)

 

71、简述synchronized和java.util.concurrent.locks.Lock的异同？

主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

什么是java序列化，如何实现java序列化？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

 

Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。
    equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

40、构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

45、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
不对，有相同的hash code。

46、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 
是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

多线程并发应用的3个高级面试题

第一题：

      现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序中增加4个线程去调用parseLog()方法来分头打印

      这16个日志对象，程序只需要运行4秒即可打印完这些日志对象。

原始代码：

 public class Test {

         public static void main(String[] args){

             System.out.println("begin:"+(System.currentTimeMillis()/1000));
             /*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。
             修改程序代码，开四个线程让这16个对象在4秒钟打完。
             */
             for(int i=0;i<16;i++){  //这行代码不能改动
                 final String log = ""+(i+1);   //这行代码不能改动
                 {
                         Test.parseLog(log);
                 }
             }
         }

         //parseLog方法内部的代码不能改动
         public static void parseLog(String log){
             System.out.println(log+":"+(System.currentTimeMillis()/1000));

             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

实现：通过阻塞队列实现线程间的通信

 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;

 //BlockingQueue
 public class Test {

     public static void main(String[] args){

         //创建一个空间大小为16的阻塞队列，空间大小可以任意，因为每次打印都要1秒，在此期间，
         //4个线程足以不断去从队列中取数据，然后打印,即在1秒内打印4条日志信息
         final BlockingQueue queue = new ArrayBlockingQueue(16);

         //开启4个线程打印
         for(int i=0;i<4;i++){
             new Thread(new Runnable(){
                 @Override
                 public void run() {
                     while(true){
                         try {
                             String log = queue.take();  //开始没有数据，阻塞，一旦有其中一个线程就去取
                                             //数据，即不再阻塞，就开始打印
                             parseLog(log);
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                 }

             }).start();
         }

                //打印秒数
         System.out.println("begin:"+(System.currentTimeMillis()/1000));


         for(int i=0;i<16;i++){  //这行代码不能改动
             final String log = ""+(i+1);//这行代码不能改动
             {
                     try {
                         queue.put(log);     //向队列中存储数据
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     //Test.parseLog(log);
             }
         }
     }

     //parseLog方法内部的代码不能改动
     public static void parseLog(String log){
         System.out.println(log+":"+(System.currentTimeMillis()/1000));

         try {
             Thread.sleep(1000);     //模拟每条日志打印需要1秒
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

 }

 第二题：

         现成程序中的Test类中的代码在不断地产生数据，然后交给TestDo.doSome()方法去处理，就好像生产者在不断地产生数据，消费者在不断消费数据。

        请将程序改造成有10个线程来消费生成者产生的数据，这些消费者都调用TestDo.doSome()方法去进行处理，故每个消费者都需要一秒才能处理完，程

        序应保证这些消费者线程依次有序地消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以，但要保证这些消

        费者线程拿到的数据是有顺序的。

原始代码：

 public class Test {

         public static void main(String[] args) {

             System.out.println("begin:"+(System.currentTimeMillis()/1000));
             for(int i=0;i<10;i++){  //这行不能改动
                 String input = i+"";  //这行不能改动
                 String output = TestDo.doSome(input);
                 System.out.println(Thread.currentThread().getName()+ ":" + output);
             }
         }
     }

     //不能改动此TestDo类
     class TestDo {
         public static String doSome(String input){

             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             String output = input + ":"+ (System.currentTimeMillis() / 1000);
             return output;
         }
     }

在实现之前先介绍一个阻塞队列：SynchronousQuene   

      一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。

      同步队列没有任何内部容量，甚至连一个队列的容量都没有。除非另一个线程试图移除某个元素，否则也不能（使用任何方法）插入元素；

      也不能迭代队列，因为其中没有元素可用于迭代。

应用：

     它非常适合于传递性设计，在这种设计中，在一个线程中运行的对象要将某些信息、事件或任务传递给在另一个线程中运行的对象，

      它就必须与该对象同步。 

代码实现：

 import java.util.concurrent.SynchronousQueue;

 /*Semaphore与SynchronousQueue的混合使用。
     由于Semaphore只有1个许可权，所以谁先拿到谁执行，然后释放，保证依次执行,
     用锁也行，只要保证一个线程执行即可
     SynchronousQueue是必须有其他线程取的动作，这样一一对应
 */
 public class Test {

     public static void main(String[] args) {

         //定义一个许可权为1的信号灯
         final Semaphore semaphore = new Semaphore(1);

         //产生的结果无序
         final SynchronousQueue queue = new SynchronousQueue();

         //产生10个线程
         for(int i=0;i<10;i++){
             new Thread(new Runnable(){
                 @Override
                 public void run() {
                     try {
                         semaphore.acquire();    //获取许可
                         String input = queue.take();    //获取并移除此队列的头
                         String output = TestDo.doSome(input);
                         System.out.println(Thread.currentThread().getName()+ ":" + output);
                         semaphore.release();    //释放许可
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                 }
             }).start();
         }

         System.out.println("begin:"+(System.currentTimeMillis()/1000));
         for(int i=0;i<10;i++){  //这行不能改动
             String input = i+"";  //这行不能改动
             try {
                 queue.put(input);       //将指定元素添加到此队列
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
     }
 }

 //不能改动此TestDo类
 class TestDo {
     public static String doSome(String input){

         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         String output = input + ":"+ (System.currentTimeMillis() / 1000);
         return output;
     }
 }

 第三题：

        现有程序同时启动了4个线程去调用TestDo.doSome(key, value)方法，由于TestDo.doSome(key, value)方法内的代码是先暂停1秒，然后再输出以秒为

       单位的当前时间值，所以，会打印出4个相同的时间值，如下所示：
4:4:1258199615
1:1:1258199615
3:3:1258199615
1:2:1258199615
        请修改代码，如果有几个线程调用TestDo.doSome(key, value)方法时，传递进去的key相等（equals比较为true），则这几个线程应互斥排队输出结果，

       即当有两个线程的key都是"1"时，它们中的一个要比另外其他线程晚1秒输出结果，如下所示：
4:4:1258199615
1:1:1258199615
3:3:1258199615
1:2:1258199616
 总之，当每个线程中指定的key相等时，这些相等key的线程应每隔一秒依次输出时间值（要用互斥），如果key不同，则并行执行（相互之间不互斥）。

原始代码：

 //不能改动此Test类
     public class Test extends Thread{

         private TestDo testDo;
         private String key;
         private String value;

         public Test(String key,String key2,String value){
             this.testDo = TestDo.getInstance();
             /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，
             以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/
             this.key = key+key2;
             this.value = value;
         }


         public static void main(String[] args) throws InterruptedException{
             Test a = new Test("1","","1");
             Test b = new Test("1","","2");
             Test c = new Test("3","","3");
             Test d = new Test("4","","4");
             System.out.println("begin:"+(System.currentTimeMillis()/1000));
             a.start();
             b.start();
             c.start();
             d.start();

         }

         public void run(){
             testDo.doSome(key, value);
         }
     }

     class TestDo {

         private TestDo() {}
         private static TestDo _instance = new TestDo();
         public static TestDo getInstance() {
             return _instance;
         }

         public void doSome(Object key, String value) {

             // 以大括号内的是需要局部同步的代码，不能改动!
             {
                 try {
                     Thread.sleep(1000);
                     System.out.println(key+":"+value + ":"
                             + (System.currentTimeMillis() / 1000));
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }

     }

对于源代码中关于实现值相同而对象不同的效果进行解释：

    对于：

         a = "1"+"";
         b = "1"+""
    编译器自动优化，所以a和b是同一个对象

   而对于：key = key+key2;  

     由于是变量，编译器无法识别，这时a和b把“1”和“”赋值给key和key2时会得到两个不同的对象

思想：

     将集合中的对象作为同步代码块的锁，即this锁，每次将对象存入集合中的时候，就判断是否原集合中已经存在一个与将要存入集合的对象值相同

    的对象，即用equals比较，如果有，那么就获取原来的这个对象，把这个对象作为将要存入对象的锁，这样它们持有的就是同一把锁，即可实现互

    斥，这样就可以实现值相同的对象在不同的时刻打印的效果

代码中出现的问题：

     在遍历ArrayList集合查找与要存入值相同元素的时候，进行了添加的动作，所以会出现并发修改异常，因此使用并发的CopyOnWriteArrayList

代码实现：

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.concurrent.CopyOnWriteArrayList;


 //不能改动此Test类
 public class Test extends Thread{

     private TestDo testDo;
     private String key;
     private String value;

     public Test(String key,String key2,String value){
         this.testDo = TestDo.getInstance();
         /*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，
         以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/

         this.key = key+key2;    //这里是变量，所以不会优化
 /*      a = "1"+"";
         b = "1"+""
         编译器自动优化，所以a和b是同一个对象
 */
         this.value = value;
     }


     public static void main(String[] args) throws InterruptedException{
         Test a = new Test("1","","1");
         Test b = new Test("1","","2");
         Test c = new Test("3","","3");
         Test d = new Test("4","","4");
         System.out.println("begin:"+(System.currentTimeMillis()/1000));
         a.start();
         b.start();
         c.start();
         d.start();

     }

     public void run(){
         testDo.doSome(key, value);
     }
 }

 class TestDo {

     private TestDo() {}
     private static TestDo _instance = new TestDo();
     public static TestDo getInstance() {
         return _instance;
     }

     //private ArrayList keys = new ArrayList();
     //迭代的时候不能修改数据，所以使用同步的ArrayList
     private CopyOnWriteArrayList keys = new CopyOnWriteArrayList();
     public void doSome(Object key, String value) {
         Object o = key;
         if(!keys.contains(o)){  //比较是否已经存入了一个相同值的对象
             keys.add(o);
         }else{

             //迭代，找出原集合里和传进来的值相同的对象
             for(Iterator iter=keys.iterator();iter.hasNext();){
                 try {
                     Thread.sleep(20);   //迭代的时候休息一会，在ArrayList下演示并发修改异常
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 Object oo = iter.next();
                 if(oo.equals(o)){   //如果两个对象的值相同
                     o = oo;     //就让原集合中的那个相等值的对象作为锁对象，由于原对象之前做的就是锁
                             //这样两个锁就相同了，就可以实现互斥
                     break;
                 }
             }
         }
         synchronized(o)
         // 以大括号内的是需要局部同步的代码，不能改动!
         {
             try {
                 Thread.sleep(1000);
                 System.out.println(key+":"+value + ":"
                         + (System.currentTimeMillis() / 1000));
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

 }