Java容器类包含、、及、、
ArrayList和HashMap是异步的，Vector和HashTable是同步的，所以Vector和HashTable是安全的，而 ArrayList和HashMap并不是线程安全的。因为同步需要花费机器时间，所以Vector和HashTable的执行效率要低于 ArrayList和HashMap。
Collection
├List 接口
│├LinkedList 链表
│├ArrayList 顺序结构动态数组类
│└Vector 向量
│ └Stack 栈
└Set
Map
├Hashtable
├HashMap
└WeakHashMap List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能
够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个
ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，
还能向前或向后遍历。
实现List接口的常用类
有LinkedList，ArrayList，Vector和。
ArrayList类
ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList
没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为
线性。
每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法
并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
Map接口
请注意，Map没有继承Collection接口，Map提供key到value的映射。一个
Map中不能包含相同的key，每个key只能映射一个
value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。
HashMap类
HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许
null，即null value和null
key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap
的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
Collection接口
Collection是最基本的集合接口，一个Collection代表一组Object，即
Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java
SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个
Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后
一个构造函数允许用户复制一个。
如何遍历Collection中的每一个元素？
不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
Iterator it = collection.iterator(); // 获得一个迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}
由Collection接口派生的两个接口是List和Set。
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时，客户端代码不用
改变。这就是针对抽象编程。
同步性
Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而
ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么
使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。
数据增长
从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中
的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来
一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那
么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。
使用模式
在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末
尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增
长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素
之后的所有元素都要执行位移的操作。这一切意味着什么呢？
这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或
ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都
是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代
替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。
最后，在《Practical Java》一书中Peter
Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组
(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。
在Java中有许多的容器集合。初一看起来有些糊涂，特别是对刚接触Java来说（至少我当初就是这样的）！其实稍微细心，深入一点点就会发现原来一切都是有规律的。我想别的事情也会是如此。
Java中的容器，接口都是由一些接口，抽象类及它们的实现类所组成。而它们全部封装在java.util
包中。
1：Collection接口。
大多数的集合都实现了此接口，它基本方法是add（没有get()方法，实现类中可能有如Arrylist)，添加一对象。添加成功则返回true
,否则返回false。这是与Map不同的地方。还有一些常用的方法如iterator(),size(),toArray()(注：toArray()
是返回一对象----object数组，而Arrays----也是java.util下的一个类，有一个asList方法它们通常认为是各集合之间转换
的桥梁)等等！具体用法可以参考API文档。
2：Map(映射)
Map接口跟Collection接口实际上没有半点关系。集合中的每一个元素都包含一对键对对象和值对象，集合中没有重复的键对象，值对象可以重复。它的有些实现类能对集合中的键对象进行排序。与Collection截然不同的是，它其中所存取的是一些值与名相对应的数据。也就是一个Key对应一个Value的方式来存储。所以它就有与之对应的一些方法如：put (K key, V value)等等，更多可以参考API文档。
3：List(列表)
集合中的对象按索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象
4：Set(集)
集合中的对象中按特定的方式排序，并且没有重复对象。它的有些实现类能对集合中的对象
按特定的方式排序
5：迭代器：Iterator
它是一个接口，只有三个方法hasnext(),next(),remove()只有最后一个是可选的,也就是remove()是可选（在实现的时候）。其可选性也意味着它的实现类中，remove方法是可有可无的。例如，若有一个如下的List 实例。
Arrylist al = new Arrylist();
Object[] ob = al.toArray();
List list = Arrays.asList(ob);
Iterator itor = list.iterator();
itor.remove(); //Error
当调用Ierator itr = list.iterator()方法返回一迭代器的时候，便不支持remove方法，所以当你再使用irt.remove()时程序就是异常！
使用此迭代器要注意的是remove()方法。它所删除的是指指针（暂这么叫着）上次所移经过的位置（Removes from the
underlying collection the last element returned by the iterator
(optional operation).）。我个人觉得有点象在JDBC中的ResultSet rs =
....;rs.last();rowsCount=rs.getRow();类似呢。
前面所讲的，由于clollection提供了iterator()方法，所以迭代器是很容易实现的！
6：常用实现类的一些继承关系：
Collections，它是Java.util下的一个类。它为我们提供了许多有用的方法，如sort(...),max()等其具体用法可以参考API文档，比如sort(List list);中list内的所有元素都必须实现Comparable接口（All elements in the list must implement the Comparable interface）。
Arrylist
，它是List接口的实现类，而List则是继承于Collection。
LinkedList，它也是间接对Colections的实现。用
linkedlist的一些方法如addfirst(),removefirst(),addlast()等等可以用来实现如C中的堆栈，链表。（对于频
繁使用插入与删除操作使用linkedlist是个不错的选择，对于经常进行索引操作则arrylist较好）。
HashSet（散列表），它实现
了Set接口，也就意味着它的元素不能有重复值出现。并且在HashSet中没有get()方法，但可以通过iterator()来实现。要注意的是假如
要在HasSet中存放一些对象，那么你得重定义hashCode()与equals()二个方法来保不可以存放相同的内容的元素。对于
hashcode()所返回的值，hashset用它来计算（通过特定的函数）该对象在内存中的存放位置；后者主要用来判断二个对象的内容是否相等而返回
对应的boolen型。
TreeSet，主要用来对元素进行排序操作，假如要往其中添加对象，则对象得实现Comparable接口。（假如不要对元素排序，则一般可选用HashSet）。
HashMap，主要特点是存放的一个键值对，一些有用的方法是可返回视图（我觉得可以把它理解为一个集合）如：keyset(),values(),entyset()等。
关于对HashMap的小步深入理解：
HashMap是由键值对组成的，关于HashMap有二点要注意：1. 它的键只能是一个Object对象。 2. 当二个HashMap用equals方法比较时，实际的比较是它的Key，而与Value无关。
HashMap的主要特点是其底层的物理存放与查找用到了hash函数相关的
原理。根据java窗口的查找原理，查找最快的应该是由数组经过工具类Arrays的Arrays.sort方法排序后，再用此工具类的
Arrays.binarySearch方法进行查找。对于HashMap的数据查找就是用这个原理实现的，另外由于数组的致命缺点就是它是定长的，而
HashMap却是可以动态增加，所以查找过程其实不是将Key本身放在一个Object[]的数组中，而是将与Key有密切相关的信息做为索引
Object[]数组的下标，然后根据此下标去Object[]数组中查找数据，这个所谓密切相关的信息就是通过Key.hashCode()函数所产生
的数字。可想而知，当HashMap中的Key很多时，各Key所产生的hashCode肯定会有重合的现象发生，为了防止此情况发生，所以根据这个索引
在数组中得到的对象并不是最终要查找的数据，查到的其实是一个list列表，在这列表中列出了由于HashMap中的Key通过散列后具有相同
hashCode的全部对像。可以想像得到，这个列表中的对像应该是相当少的。对于对Object[]数据下下标定位后，就得到了这个列表，接下来
equals函数粉墨登场了，若能返回true则表示此对象已经存在，这时HashMap会用新的值覆盖旧值，若不存在则会做添加操作了。
在HashMap的初始化中，会涉及到二个比较重要的值，也是影响其性能的二
个重要值：Object[]的长度(v1)、Object[]中实际已经存放了多少object对象(v2)。在我们初始化HashMap时会
有：HashMap(int initialCapacity, float loadFactor)
这个方法，initialCapacity表示object[]的初始化长度，loadFactor表示允许此在Object[]存放数据的百分比
(loadFactor＝v2/v1)，系统默认的是0.75（也就是可以存放占object[]数组3/4的数据）。当HashMap里的数据不断增加
时，它会自动地按数量级扩展Object[]的长度（应该尽量阻止Object[]的自动增加，这样不但消费资源对于以后的查找、插入操作也不利）。
HashMap结论：对于Key一定要实现hashCode() and
equals方法，且尽量要让hashCode散布得均匀。这样才能充分利用Object[]数组，不然，会导致Object[]得不到充分利用，而在
Object[index]具体对应的对象list列表中存放很多Key对像，而在list中进行查找操作是比较耗时的。
根据以上原理，HashMap的简单实现：
import java.util.*;
import com.bruceeckel.util.*;
public class SimpleHashMap extends AbstractMap {
// Choose a prime number for the hash table
// size, to achieve a uniform distribution:
private static final int SZ = 997;
private LinkedList[] bucket = new LinkedList[SZ];
public Object put(Object key, Object value) {
Object result = null;
int index = key.hashCode() % SZ;
if(index < 0) index = -index;
if(bucket[index] == null)
bucket[index] = new LinkedList();
LinkedList pairs = bucket[index];
MPair pair = new MPair(key, value);
ListIterator it = pairs.listIterator();
boolean found = false;
while(it.hasNext()) {
Object iPair = it.next();
if(iPair.equals(pair)) {
result = ((MPair)iPair).getValue();
it.set(pair); // Replace old with new
found = true;
break;
}
}
if(!found)
bucket[index].add(pair);
return result;
}
public Object get(Object key) {
int index = key.hashCode() % SZ;
if(index < 0) index = -index;
if(bucket[index] == null) return null;
LinkedList pairs = bucket[index];
MPair match = new MPair(key, null);
ListIterator it = pairs.listIterator();
while(it.hasNext()) {
Object iPair = it.next();
if(iPair.equals(match))
return ((MPair)iPair).getValue();
}
return null;
}
public Set entrySet() {
Set entries = new HashSet();
for(int i = 0; i < bucket.length; i++) {
if(bucket[i] == null) continue;
Iterator it = bucket[i].iterator();
while(it.hasNext())
entries.add(it.next());
}
return entries;
}
public static void main(String[] args) {
SimpleHashMap m = new SimpleHashMap();
Collections2.fill(m, Collections2.geography, 25);
System.out.println(m);
}
} ///:~
TreeMap，它与HashMap差不多，不过是增加了对元素的排序功能，所以运行速度也就当然没有hashmap来得快了。
以下是HashMap的一个实例(在对DB进行操作的时候很有用):
HashMap valueMap;
//this function just get key-value form DB ,defined by yourself
valueMap = commondb.getElementStringValues("COMMENT_ID", "content");
java.util.Set tempkeys = valueMap.entrySet();
java.util.Iterator keys = tempkeys.iterator();
while(keys.hasNext())
{
java.util.Map.Entry me=(java.util.Map.Entry)keys.next();
String value = me.getValue();
int key = me.getKey();
}
要注意的是entrySet()所返回的每一个元素都是Map.Entry类型的!(Returns a collection view of the mappings contained in this map. Each element in the returned collection is a Map.Entry.)
Properties，继承于hashtable。这个东东相信我们比较的喜欢了（在i18n,ant中可以是常见得很），呵呵。它可以从外部导入属性文件。文件中的键值都是String类型。just like this:
company=study
author=Jkallen
copyright=2005-2006
操作如下：
import java.util.*;
import java.io.*;
class PropTest
{
public static void main(String[] args)
{
/**//*Properties pps=System.getProperties();
pps.list(System.out);*/
Properties pps=new Properties();
try
{
pps.load(new FileInputStream("winsun.ini"));
Enumeration enum=pps.propertyNames();
while(enum.hasMoreElements())
{
String strKey=(String)enum.nextElement();
String strValue=pps.getProperty(strKey);
System.out.println(strKey+"="+strValue);
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
其用法可以查看API文档呢。
Java中的集合容器确实不少呢...其中有些我们也许一直都用不到，（我也是查看了些相关的资料再加上自己的一些想法整理了一下，希望对相关朋友有用！）可是重要的是知道我们在实现一个功能时应该选用哪种集合类来实现就OK了。
阅读(534) | 评论(1) | 转发(0) |
