Java持有对象(容器小结)

本文主要是介绍Java持有对象(容器小结)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

如果一个程序只包含固定数量的且其生命期都是已知的对象，那么这是一个非常简单的程序。

-------<Thinking in Java>

通常，程序总是根据运行时才知道的某些条件去创建新对象。对象数量，对象类型尚且不能确定。为了解决这个问题，满足程序员需要在任意时刻和任意位置创建任意数量对象的要求。Java实用类库提供了一套相当完整的容器类来解决这个问题(因为数组受到固定尺寸的左右)。其中基本的类型是List，Set，Queue和Map。这些对象类型也称为集合类，但由于java的类库中实用了collection这个名字来指代类库的一个特殊子集，所以我使用了范围更广的术语“容器”称呼他们。

11.1 泛型和类型安全的容器

要想定义用来保存Apple对象的ArrayList，你可以申明ArrayList<Apple>，而不仅仅只是ArrayList，其中尖括号括起来的是类型参数（可以有多个），它指定了这个容器实例可以保存的类型。此时将元素从List中取出来时，类型转换也不再是必须的了。因为List知道它保存的是什么类型，因此它会在get()时替你执行转型。

11.2 基本概念

容器类类型库的用途是“保存对象”，并将其划分为两个不同的概念：

1）Collection：一个独立元素的序列，这些元素都服从一条或多条规则。

2）Map：一组成对的“键值对”对象，允许你使用键来查找值。


名称	类型	实现	优点	缺点	排序	可重复	迭代性	同步
Iterable	接口				F	T	T	F
Collection	接口				F	T	T	F
Queue	接口				F	T	T	F
PriorityQueue		堆（一种二叉树）	优先级队列		T	T	T	F
List	接口	按索引排序			T	T	T	F
LinkedList	类	双向循环链表			T	T	T	F
ArrayList	类	数组	查找	增删	T	T	T	F
Vector	类	数组	增删	查找	T	T	T	T
Stack	类	栈			T	T	T	T
Set	接口				F	F	T	F
TreeSet	类				T	F	T	F
HashSet	类				F	F	T	F
Map	接口				F	F	T	F
HashMap	类		查找		F	F	T	F
TreeMap	类		排序		T	F	T	F
HashTable					F	F	T	T
Properties		HashTable的子类，表示了一个持久的属性集。

11.2.1 Collection接口（省略常用的方法）

[java]  view plain copy  
 boolean add(Object obj) 添加一个Object元素  
 boolean addAll(Collection c)  
 boolean contains(Object obj)  判断obj是否是调用类集的一个元素（属于）  
 boolean containsAll(Collection c)  判断c是否是调用类集的子集（包含）  
 boolean equals(Collection c) 判断c是否与调用类集相等  
 int hashCode() 返回调用类集的hash码  
 Iterator iterator() 返回调用类集的迭代程序  
 boolean removeAll(Collection c) 从调用类集中去掉所有c中包含的元素（差集）  
 boolean retainAll(Collection c) 从调用类集中去掉包含在c中以外的元素（补集）  
 Object[] toArray() 返回类集的元素组成的数组  
    
 void clear()  
 boolean isEmpty()  
 int size()  
   
 //类集包含一个add(Object obj)方法，因此可以包含任意Object数据，但是不能直接存储：int，char,double等数据。可以使用下面的方法实现：  
 ArrayList a=new ArrayList();  
 a.add(new Integer(1));  
 a.add(new Integer(2));  
 //……  
   
 //当类集不能被修改时，可能引发 UnsupportedOperationException异常。企图将一个不兼容的对象加入到一个类集中时可能引发ClassCastException//异常。  

11.3 添加一组元素

[java]  view plain copy  
 //: holding/AddingGroups.java  
 // Adding groups of elements to Collection objects.  
 import java.util.*;  
   
 public class AddingGroups {  
   public static void main(String[] args) {  
     Collection<Integer> collection =  
       new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));  
     Integer[] moreInts = { 6, 7, 8, 9, 10 };  
     collection.addAll(Arrays.asList(moreInts));  
     // Runs significantly faster, but you can't  
     // construct a Collection this way:  
     Collections.addAll(collection, 11, 12, 13, 14, 15);  
     Collections.addAll(collection, moreInts);  
     // Produces a list "backed by" an array:  
     List<Integer> list = Arrays.asList(16, 17, 18, 19, 20);  
     list.set(1, 99); // OK -- modify an element  
     // list.add(21); // Runtime error because the  
                      // underlying array cannot be resized.  
   }  
 } ///:~  

你也可以直接使用Arrays.asList()的输出，将其当作List，但是在这种情况下，其底层表示的是数组，因此不能调整尺寸。
Arrays.asList()方法的限制是它对所产生的List的类型做出了最理想的假设，而并没有注意你会对它赋予什么样的类型。

[java]  view plain copy  
 //: holding/AsListInference.java  
 // Arrays.asList() makes its best guess about type.  
 import java.util.*;  
   
 class Snow {}  
 class Powder extends Snow {}  
 class Light extends Powder {}  
 class Heavy extends Powder {}  
 class Crusty extends Snow {}  
 class Slush extends Snow {}  
   
 public class AsListInference {  
   public static void main(String[] args) {  
     List<Snow> snow1 = Arrays.asList(  
       new Crusty(), new Slush(), new Powder());  
   
     // Won't compile:  
     // List<Snow> snow2 = Arrays.asList(  
     //   new Light(), new Heavy());  
     // Compiler says:  
     // found   : java.util.List<Powder>  
     // required: java.util.List<Snow>  
   
     // Collections.addAll() doesn't get confused:  
     List<Snow> snow3 = new ArrayList<Snow>();  
     Collections.addAll(snow3, new Light(), new Heavy());  
   
     // Give a hint using an  
     // explicit type argument specification:  
     List<Snow> snow4 = Arrays.<Snow>asList(  
        new Light(), new Heavy());  
   }  
 } ///:~  

11.4 容器的打印

[java]  view plain copy  
 //: holding/PrintingContainers.java  
 // Containers print themselves automatically.  
 import java.util.*;  
 import static net.mindview.util.Print.*;  
   
 public class PrintingContainers {  
   static Collection fill(Collection<String> collection) {  
     collection.add("rat");  
     collection.add("cat");  
     collection.add("dog");  
     collection.add("dog");  
     return collection;  
   }  
   static Map fill(Map<String,String> map) {  
     map.put("rat", "Fuzzy");  
     map.put("cat", "Rags");  
     map.put("dog", "Bosco");  
     map.put("dog", "Spot");  
     return map;  
   }   
   public static void main(String[] args) {  
     print(fill(new ArrayList<String>()));  
     print(fill(new LinkedList<String>()));  
     print(fill(new HashSet<String>()));  
     print(fill(new TreeSet<String>()));  
     print(fill(new LinkedHashSet<String>()));  
     print(fill(new HashMap<String,String>()));  
     print(fill(new TreeMap<String,String>()));  
     print(fill(new LinkedHashMap<String,String>()));  
   }  
 } /* Output: 
 [rat, cat, dog, dog] 
 [rat, cat, dog, dog] 
 [dog, cat, rat] 
 [cat, dog, rat] 
 [rat, cat, dog] 
 {dog=Spot, cat=Rags, rat=Fuzzy} 
 {cat=Rags, dog=Spot, rat=Fuzzy} 
 {rat=Fuzzy, cat=Rags, dog=Spot} 
 *///:~  

ArrayList和LinkedList都是List类型，从输出可以看出，它们都是按照被插入的顺序保存元素。两者不同之处不仅在于执行某些类型的操作时的性能，而且LinkedList包含的操作也多余ArrayList。

HashSet，TreeSet和LinkedHashSet都是Set类型，输出显示在Set中，每个相同的项只保存一次，但是输出也显示了不同的Set实现存储元素的方式也不同。

你不需要指定Map的尺寸，因为它会自动地调整尺寸。

HashMap提供了最快的查找技术，也没有按照任何明显的顺序来保存其元素。TreeMap按照比较结果的升序保存键，而LinkedHashMap则按照插入顺序保存键，同时还保留了HashMap的查询速度。

11.5 List

List接口（从Collection继承而来，使用基于0的下标）

[java]  view plain copy  
 void add(int index,Object obj) 插入点以后的元素将后移  
 boolean addAll(int index,Collection c) 如果调用列表改变了，返回true,否则返回false  
 Object get(int index)  
 int indexOf(Object obj) 返回obj对象在列表中的索引，不存在返回-1  
 int lastIndexOf(Object obj) 返回obj在列表中的最后一个实例的下标，不存在返回-1  
 ListIterator listIterator()  
 ListIterator listIterator(int index) 返回index开始的迭代程序  
 Object set(int index,Object obj) 对列表index处的值进行修改  
 List subList(int start,int end) 从start到end-1  

11.6 迭代器

iterator实现Iterator接口或者ListIterator接口。
Iterator接口

[java]  view plain copy  
 boolean hasNext()  
 Object next() 如果没有下一个元素则引发NoSuchElementException异常。  
 void remove() 删除当前元素，如果试图在调用next()方法后调用remove()方法则引发IllegalStateException异常。  
  ListIterator接口  
 void add(Object obj) 将一个元素插入到当前元素之前，调用next()方法将返回该元素。  
 boolean hasNext()  
 boolean hasPrevious()  
 Object next() 如果不存在引发NoSuchElementException  
 int nextIndex() 如果不存在返回列表的大小  
 void remove()  
 void set(Object obj) 修改当前元素  
   
 public void test1() {  
         ArrayList al = new ArrayList();  
         for (int i = 1; i < 10; i ) {  
             al.add("ArrayList Element:" i);  
         }  
         Iterator itr = al.listIterator();  
         while (itr.hasNext()) {  
             Object obj = itr.next();  
             System.out.println(obj);  
         }  
     }  
   
 public void test2() {  
         HashSet hs = new HashSet();  
         System.out.println("HashSet");  
         for (int i = 1; i < 10; i ) {  
             hs.add("HashSet Element:" i);  
         }  
         Iterator itr = hs.iterator();  
         while (itr.hasNext()) {  
             Object obj = itr.next();  
             System.out.println(obj);  
         }  
     }  
   
     public void test3() {  
         TreeSet ts = new TreeSet();  
         System.out.println("TreeSet");  
         for (int i = 1; i < 10; i ) {  
             ts.add("TreeSet Element:" i);  
         }  
         Iterator itr = ts.iterator();  
         while (itr.hasNext()) {  
             Object obj = itr.next();  
             System.out.println(obj);  
         }  
     }  
   
     public void test4()  
     {  
         HashMap hm=new HashMap();  
         for ( int i=0;i<10;i )  
         {  
             hm.put("item" i,"value" i);  
         }  
   
         Set set=hm.entrySet();  
         Iterator itr=set.iterator();  
         while (itr.hasNext())  
         {  
             Map.Entry me=(Map.Entry)itr.next();  

11.7 LinkedList

LinkedList还添加了可以使其用作栈、队列或双端队列的方法。

11.8 Stack

[java]  view plain copy  
 //: net/mindview/util/Stack.java  
 // Making a stack from a LinkedList.  
 package net.mindview.util;  
 import java.util.LinkedList;  
   
 public class Stack<T> {  
   private LinkedList<T> storage = new LinkedList<T>();  
   public void push(T v) { storage.addFirst(v); }  
   public T peek() { return storage.getFirst(); }  
   public T pop() { return storage.removeFirst(); }  
   public boolean empty() { return storage.isEmpty(); }  
   public String toString() { return storage.toString(); }  
 } ///:~  

11.9 Set

Set接口（从Collection派生，没有定义新的方法）

Set不允许有重复的元素,用Iterator()方法来区分重复与否。
对Set调用add（Object obj）方法，如果obj已经存在集合中，将返回false。

11.9.1 SortedSet接口

[java]  view plain copy  
 Comparator comparator() 返回调用排序集合的比较函数，如果改集合使用自然顺序，则返回null  
 Object first() 返回被排序集合的第一个元素  
 SortedSet headSet(Object end) 返回一个包含小于end元素的SortedSet  
 Object last() 返回调用排序集合的最后一个元素  
 SortedSet subSet(Object start,Object end) 包括从start到end-1  
 SortedSet tailSet(Object start) 返回包含大于等于start的元素  
  ArrayList扩展AstractList类，并执行List接口。ArrayList支持动态长度的数组。  
 LinkList扩展了AbstractSequentialList，执行List接口。提供连接列表。  
 HashSet扩展AbstractSet实现Set接口，元素没有顺序。对于大集合提供常量级基本操作。  
 TreeSet使用树来存储的Set，对象按升序存储。访问和检索非常快。  

11.10 Map

[java]  view plain copy  
 (1) 添加、删除操作：  
 　　Object put(Object key, Object value): 将互相关联的一个关键字与一个值放入该映像。如果该关键字已经存在，那么与此关键字相关的新值将取代旧值。方法返回关键字的旧值，如果关键字原先并不存在，则返回null  
 　　Object remove(Object key): 从映像中删除与key相关的映射  
 　　void putAll(Map t): 将来自特定映像的所有元素添加给该映像  
 　　void clear(): 从映像中删除所有映射  
 　　“键和值都可以为null。但是，您不能把Map作为一个键或值添加给自身。”  
 　　(2) 查询操作：  
 　　Object get(Object key): 获得与关键字key相关的值，并且返回与关键字key相关的对象，如果没有在该映像中找到该关键字，则返回null  
 　　boolean containsKey(Object key): 判断映像中是否存在关键字key  
 　　boolean containsValue(Object value): 判断映像中是否存在值value  
 　　int size(): 返回当前映像中映射的数量  
 　　boolean isEmpty() ：判断映像中是否有任何映射  
 　　(3) 视图操作 ：处理映像中键/值对组  
 　　Set keySet(): 返回映像中所有关键字的视图集  
 　　“因为映射中键的集合必须是唯一的，您用Set支持。你还可以从视图中删除元素，同时，关键字和它相关的值将从源映像中被删除，但是你不能添加任何元素。”  
 　　Collection values():返回映像中所有值的视图集  
 　　“因为映射中值的集合不是唯一的，您用Collection支持。你还可以从视图中删除元素，同时，值和它的关键字将从源映像中被删除，但是你不能添加任何元素。”  
 　　Set entrySet(): 返回Map.Entry对象的视图集，即映像中的关键字/值对  
 　　“因为映射是唯一的，您用Set支持。你还可以从视图中删除元素，同时，这些元素将从源映像中被删除，但是你不能添加任何元素。”  

11.11 Queue

11.12 Collection和Iterator

11.13 Foreach与迭代器

之所以能够工作，是因为java SE5引入了新的被称为Iterable的接口，该接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动。因此如果你创建了任何实现Iterable的类，都可以将它用于foreach语句中：

[java]  view plain copy  
 //: holding/IterableClass.java  
 // Anything Iterable works with foreach.  
 import java.util.*;  
   
 public class IterableClass implements Iterable<String> {  
   protected String[] words = ("And that is how " +  
     "we know the Earth to be banana-shaped.").split(" ");  
   public Iterator<String> iterator() {  
     return new Iterator<String>() {  
       private int index = 0;  
       public boolean hasNext() {  
         return index < words.length;  
       }  
       public String next() { return words[index++]; }  
       public void remove() { // Not implemented  
         throw new UnsupportedOperationException();  
       }  
     };  
   }   
   public static void main(String[] args) {  
     for(String s : new IterableClass())  
       System.out.print(s + " ");  
   }  
 } /* Output: 
 And that is how we know the Earth to be banana-shaped. 
 *///:~  

11.4 总结

简单容器分类：

补充：来自转载

Java容器集合类的区别用法

Set,List,Map,Vector,ArrayList的区别

JAVA的容器---List,Map,Set
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 集合类 map set list arraylist hashmap hashtable(转)

Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。
当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。
Hashtable和HashMap
它们的性能方面的比较类似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。
ArrayList和LinkedList
对于处理一列数据项,Java提供了两个类ArrayList和LinkedList,ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但LinkedList的内部实现是基于一组连接的记录,所以,它更象一个链表结构，所以,它们在性能上有很大的差别。
（1）从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能。
（2）而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，所以,当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
（3）如果在编程中,1，2两种情形交替出现,这时,你可以考虑使用List这样的通用接口,而不用关心具体的实现，在具体的情形下,它的性能由具体的实现来保证。
设置集合类的初始大小
在Java 集合框架中的大部分类的大小是可以随着元素个数的增加而相应的增加的，我们似乎不用关心它的初始大小,但如果我们考虑类的性能问题时,就一定要考虑尽可能地设置好集合对象的初始大小,这将大大提高代码的性能，比如,Hashtable缺省的初始大小为101,载入因子为0.75,即如果其中的元素个数超过 75个,它就必须增加大小并重新组织元素，所以,如果你知道在创建一个新的Hashtable对象时就知道元素的确切数目如为110,那么,就应将其初始大小设为110/0.75=148,这样,就可以避免重新组织内存并增加大小。
特别要理解的：
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过低。
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，因此必须捕获该异常。