集合

集合类的基本接口是Collection接口。

interface Collection<E>{

boolean add(E e);

Iterator<E>  iterator();

}

interface Iterator<E>{

E next();

void remove();

boolean hasNext();

}

interface Iterable<E>{

Iterator<E> iterator();

}

Collection接口扩展了Iterable接口。因此，对于标准类库中的任何集合都可以使用“ for each”循环。
next方法和remove方法的调用具有互相依赖性。如果调用remove之前没有调用next将是不合法的。如果这样做，将会抛出一个IllegalStateException异常。

int size()返回集合大小。

boolean isEmpty()没有元素返回true

boolean contains(Object obj)集合包含obj，返回true

boolean containsAll(Collection<?> other)包含集合other，返回true。

add（），addAll(Collection<?>other)

remove(Obj),remove(Collection<?> other)

void clear()清空集合

retainAll(Collection<?> other)删除和other集合不同的元素

void toArray（）;

T[] toArray(T[] a)如果a大于集合，就返回a，把集合元素填进去，多余填null.a小于集合，把集合填进去，a的长度等于集合长度。

以Map结尾的类实现了Map接口，其他类都实现了Collection接口。

ArrayList 一种可以动态增长和缩减的索引序列
LinkedList 一种可以在任何位置进行高效地插入和删除操作的有序序列
ArrayDeque 一种用循环数组实现的双端队列
HashSet 一种没有重复元素的无序集合
TreeSet 一种有序集
EnumSet 一种包含枚举类型值的集
LinkedHashSet 一种可以记住元素插入次序的集
PriorityQueue 一种允许高效删除最小元素的集合
HashMap 一种存储键/值关联的数据结构
TreeMap 一种键值有序排列的映射表
EnumMap 一种键值属于枚举类型的映射表
LinkedHashMap 一种可以记住键/值项添加次序的映射表
WeakHashMap 一种其值无用武之地后可以被垃圾回收器回收的映射表
IdentityHashMap 一种用==，而不是用equals比较键值的映射表

Arraylist删除慢，因为删除后所有后面的元素要向前移。linkedList查找慢，因为他是从头开始找。

List有序可重复，Set无序不可重复。

链表

ListIterator继承了Iterator里面有E previous,hasPrevioue()可以反向遍历列表。而且也可以调用Iterator的next和hasNext方法.set（OBJ）方法可以修改当前的值。

ListIterator<T> a =xxx.listIterator();
a.next();
a.set(xxx);会把a.next()的那个元素改为xxx 

如果一个在修改，一个在查询可能会报ConcurrentModificationException异常。

int nextIndex()和int previousIndex()会返回位置。

数组

Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象。但是，如果由一个线程访问Vector，代码要在同
步操作上耗费大量的时间。这种情况还是很常见的。而ArrayList方法不是同步的，因此，建议在不需要同步时使用ArrayList，而不要使用Vector。

散列表（hash table）为每个对象计算一个整数，称为散列码（ hash code）。散列码是由对象的实例域产生的一个整数。更准确地说，
具有不同数据域的对象将产生不同的散列码。散列表用链表数组实现。每个列表被称为桶（ bucket）（参看图13-8）。要想查找表中对象的位置，就要先计算它的散列码，然后与桶的总数取余，所得到的结果就是保存这个元素的桶的索引。当然，有时候会遇到桶被占满的情况，这也是不可避免的。这种现象被称为散列冲突（ hash collision）。通常，将桶数设置为预计元素个数的75%~150%。
装填因子（ load factor） 决定何时对散列表进行再散列。例如，如果装填因子为0.75（默认值），而表中超过75%的位置已经填入元素，这个表就会用双倍的桶数自动地进行再散列。

散列表可以用于实现几个重要的数据结构。其中最简单的是set类型。 set是没有重复元素的元素集合。

树集TreeSet是有序的，将一个元素添加到树中要比添加到散列表中慢，但是，与将元素添加到数组或链表的正确位置上相比还是快很多的
在默认情况时，树集假定插入的元素实现了Comparable接口

interface comparator<T>{
     int compareTo(T a,T b);
}

interface comparable<T>{
      int compareTo(T a);
}

实现comparator接口可以自定义比较器。或者实现comparable接口。

在Java SE 6中引入了Deque接口，并由ArrayDeque和LinkedList类实现。这两个类都提供了双端队列，而且在必要时可以增加队列的长度。

优先级队列（ priority queue）中的元素可以按照任意的顺序插入，却总是按照排序的顺序进行检索。也就是说，无论何时调用remove方法，总会获得当前优先级队列中最小的元素。优先级队列使用了一个优雅且高效的数据结构，称为堆（ heap）。堆是一个可以自我调整的二叉树，对树执行添加（ add）和删除（ remore）操作，可以让最小的元素移动到根，而不必花费时间对元素进行排序。

treeSet不能存null，hashSet可以。list可以存null，map可以存null

映射表用来存放键/值对。

散列映射表对键进行散列，树映射表用键的整体顺序对元素进行排序，并将其组织成搜索树。散列或比较函数只能作用于键。与键关联的值不能进行散列或比较。如果在映射表中没有与给定键对应的信息， get将返回null。键必须是惟一的。不能对同一个键存放两个值。如果对同一个键两次调用put方法，第二个值就会取代第一个值。

遍历map

Set<Map.Entry<String,String>> b = a.entrySet();
for(Map.Entry<String,String> c:b){
	c.getKey();
	c.getValue();//效率高
}

Set<String> b = a.keySet();
for(String c:b){
	System.out.println(a.get(c));//效率低
}

map方法

get(key); put(key,value); putAll(map)存入一个集合； containsKey(key)； containsValue(value)； keySet()； entrySet()； value()返回值的集合。

WeakHashMap键不使用就会回收。

LinkedHashSet和LinkedHashMap，访问和插入的顺序一样。
IdentityHashMap。在这个类中，键的散列值不是用hashCode函数计算的，而是用System.identityHashCode方法计算的。这是Object.hashCode方法根据对象的内存地址来计算散列码时所使用的方式。而且，在对两个对象进行比较时， IdentityHashMap类使用==，而不使用equals。也就是说，不同的键对象，即使内容相同，也被视为是不同的对象。在实现对象遍历算法（如对象序列化）时，这个类非常有用，可以用来跟踪每个对象的遍历状况。

RandomAccess。这个接口没有任何方法，但可以用来检测一个特定的集合是否支持高效的随机访问。

if(c instanceof RandomAccess){

}

Arrays.asList(int[])可以把数组变为list<Integer>.toArray可以集合变为数组，toArray()返回Object[]，toArray(new String[xxx])返回String数组。toArray()括号中填什么类型，返回的就是什么类型的数组。

List对象.subList(from,to);可以截取一段list,subSet,subMap

Collections里面方法很多有用，synchronizedSet synchronizedMap可以吧set和map转为线程同步的。

Collections.sort(list,comparator)实现list自定义排序。

Collections.nCopies(int n,value)创建n个值为value的list,不可修改

Collectiona.singleton(value)创建一个单元素集合，不可修改

Collections.checkedxxx返回xxx类型的集合，插入时会判断对象是不是集合存储类型的

Collections.unmodifiablexxxx返回不可修改的集合

Collections.sort(list,Clooection.reverseOrder(排序方法))；会按照排序方法逆序。

如果列表支持set方法，则是可修改的。如果列表支持add和remove方法，则是可改变大小的。满足这两样条件就可以排序，不可改变对象的集合不能排序。

Collections.shuffle（list）会随机的排列list元素。

Collections.binarySearch(list,要查找的值，comparator)返回值在集合中的位置，集合必须排好序。

现在binarySearch方法检查列表参数是否实现了RandomAccess接口。如果实现了这个接口，这个方法将采用二分查找；否则，将采用线性查找。

如果返回值小于等于0，可以利用binarySearch返回值 在-i-1位置上插入。

Collections.min(Collection<T>,comparator)

Collections.max(Collection<T>,comparator)
copy(list to,list from)

fill(list,value)把list所有值设置为value

addAll(Collection,T...value)把所有value添加到集合中

replaceAll(list,old,new)用new替换list中所有old值

indexOfSubList(list 1,list 2)返回list 2在list 1中的位置

listIndexOfSubList(list 1,list 2)返回list 2在list 1中的位置

swap(list ,int i,int j)在list中交换 i和J位置的元素。

reverse(list)逆序

rotate(list,int d)索引I移动到(i+d)%list,size()的位置。

frequency（list,obj）返回list中和obj相同的个数

disjoint（list 1，list 2）两个list没有相同元素就返回true.

自己写算法是要用collection<T>,不要用ArratList<T>或者Linkedlist<T>

Hashtable,t小写，这个是同步的

Enumeration e=table对象.elements;
while(e.hasMoreElements()){
         e.nextElement();
}