集合：
父接口:
Collection 集合
所有集合的根接口,Collection 表示一组对象，这些对象也称为 collection 的元素。
重点子接口:
List:列表,每个元素都有索引,可以重复
重点实现的类:
ArrayList：动态数组
LinkedList：双向链表
Set:集,没有索引号，不允许重复，要重写hashcode（）和equals（）方法
TreeSet：自然排序，不可以添加null和空对象，自己定义的集合时要实现 Comparable<E>接口
HashSet：不排序，可以添加null和空对象
SortedSet：元素排序的接口,是set子接口
Map 映射
TreeMap : 自然排序，不可以添加null和空对象，自己定义的集合时要实现 Comparable<E>接口
HasMap : 不排序，可以添加null和空对象
Set和List的区别?
1.都Collection的子接口
2.Set不重复(元素类有没有重写hashCode(),equals()),List可以重复
3.Set集合中的元素没有索引号,List可以根据索引号获取或设计元素
Collection
Set
HashSet:散列集合，不保证顺序
TreeSet:自然排序(元素类型实现了Comparable接口),不允许null元素存在
List
ArrayList:动态数组,对于set(),get()效率高于LinkedList
LinkedList:链表列表,对于remove(),add()效率高于ArrayList,扩展一些对首尾元素操作的方法addFirst(),removeLast(),pop()...
Collection常用方法:
size(),add(), clear(), remove(),contains()...
List扩展常用方法:
get(),set(),indexOf()
Map集合(映射)
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
某些映射实现可明确保证其顺序，如 TreeMap 类；
另一些映射实现则不保证顺序，如 HashMap 类。
使用键-值对(Key-Value)保存一系列的元素
2.List与Set的区别?
1、List,Set都是继承自Collection接口
2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）3、List接口有三个实现类：LinkedList，ArrayList，Vector ，Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet
3.HashSet与TreeSet的区别?
自然排序，不可以添加null和空对象，自己定义的集合时要实现 Comparable<E>接口
不排序，可以添加null和空对象
如何创建一个集合对象?
Collection<元素的类型> 名称 = new 实现类的对象<元素的类型>();
ArrayList动态数组
List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）
Collection：方法
boolean add(E e)
确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void clear()
移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。
注:
元素的类型如果没有重写hashCode()和equals()方法，不保证结果的正确性。
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean equals(Object o)
比较此 collection 与指定对象是否相等。
int hashCode()
返回此 collection 的哈希码值。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。
如果返回true,说明元素的个数是0,并不是null.
Iterator<E> iterator()
返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int size()
返回此 collection 中的元素数。
Object[] toArray()
返回包含此 collection 中所有元素的数组。
<T> T[]
toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
toArray()
toArray(T[] t)
add(E)：添加一个元素
addAll(c)：添加一组元素
clear() 移除此 collection 中的所有元素（可选操作）。
contains(E)是否指定元素
containsAll(C)是否指定子集合
equals()
hashCode()
int size()返回元素个数
boolean isEmpty()元素个数是不是0
remove(Object obj)：删除指定元素
removeAll(Collection c)：删除当前集合与指定集合的交集
retainAll(Collection c)：保留当前集合与指定集合 的交集
iterator()：获取迭代器
ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦
LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要丛第一个索引开始
ArrayList和LinkedList。ArrayList是一种顺序存储的线性表，其底层是采用数组实现的，而LinkedList是链式存储的线性表。其本质就是一个双向链表。对于随机存储比较频繁的元素操作应选用ArrayList，对于经常需要增加、删除元素应该选用LinkedList。但总的来说ArrayList的总体性能还是优于LinkedList。
ArrayList:使用改（set）查（get）效率高
LinkedList:使用增（add）删（remove）效率高
LinkedList:
ArrayList与LinkedList的区别?
1.ArrayList和LinkedList都存放对象的引用,都是List接口的实现类。
2.ArrayList是以动态数组（线性）方式保存，LinkedList是以链表方式保存
3.ArrayList操作中对象get和set方法效率高于LinkedList
4.LinkedList操作中对象add和remove方法效率高于ArrayList
ArrayList:方法
boolean add(E e)
将指定的元素添加到此列表的尾部。
void add(int index, E element)
将指定的元素插入此列表中的指定位置。
boolean addAll(Collection<? extends E> c)
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
boolean addAll(int index, Collection<? extends E> c)
从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
void clear()
移除此列表中的所有元素。
Object clone()
返回此 ArrayList 实例的浅表副本。
boolean contains(Object o)
如果此列表中包含指定的元素，则返回 true。
void ensureCapacity(int minCapacity)
如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
E get(int index)
返回此列表中指定位置上的元素。
int indexOf(Object o)
返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
boolean isEmpty()
如果此列表中没有元素，则返回 true
int lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
E remove(int index)
移除此列表中指定位置上的元素。
boolean remove(Object o)
移除此列表中首次出现的指定元素（如果存在）。
protected void removeRange(int fromIndex, int toIndex)
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。
int size()
返回此列表中的元素数。
Object[] toArray()
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[]
toArray(T[] a)
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void trimToSize()
将此 ArrayList 实例的容量调整为列表的当前大小。
从类 java.util.AbstractList 继承的方法
equals, hashCode, iterator, listIterator, listIterator, subList
从类 java.util.AbstractCollection 继承的方法
containsAll, removeAll, retainAll, toString
从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait
从接口 java.util.List 继承的方法
containsAll, equals, hashCode, iterator, listIterator, listIterator, removeAll, retainAll, subList
常见题型及答案
1.Collection 和 Collections的区别。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口。
2.List, Set, Map是否继承自Collection接口?
List，Set是 Map不是
3.ArrayList和LinkedList的区别。
一.同步性:LinkedList是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,LinkedList默认增长为原来一培，而ArrayList却是原来的一半
4.HashMap和Hashtable的区别
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
CollectionListArrayListLinkedListSetHashSetTreeSetMapHashMapHashTableTreeMap
Java Collection框架详解经常会看到程序中使用了集合或记录集，常用的有Collection、HashMap、HashSet、ArrayList，因为分不清楚它们之间的关系，所以在使用时经常会混淆，以至于不知道从何下手。在这儿作了一个小例子，希望有助于帮大家理顺思路。首先看一下它们的关系：Collection--List：-----------------------以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。---ArrayList---LinkedList---Vector--Set ：----------------------- 不含有重复的元素--- HashSet--- TreeSetMap---HashMap---HashTable---TreeMap补充：List，Set，Map将存入的数据一律视为Object类型。Collection、List、Set、Map都是接口，不能实例化。继承自它们的 ArrayList, Vector, HashTable,HashMap是具象class，这些才可被实例化。vector不进行边界检查。接下来看一下具体的实例：Collection定义一个Collection对象，指向其子类一个新创建的实例：Collection c = new ArrayList()此即所谓的"父类引用指向子类对象"，后面只要使用c即可代表新创建的ArrayList。接下来给它赋值。c.add("06S030014");c.add("hit");c.add("cs");c.add("wh");然后如何取出来哪，实现了Collection接口的子类都有一个iterator()方法，通过调用该方法可以返回Iterator类型的一个对象，使用该对象即可取出所要的值。代码如下：Iterator it=c.iterator()String s = (String)it.next();这只是取出其中的一条数据，要想把所有的都取出来，可以用循环for(Iterator it=c.iterator();it.hasNext();){String s = (String)it.next();}实现了Collection接口的子类都可以用类似上述的方法存取数据。HashMapHashMap不同于Collection，它的对象没有iterator()方法，但它有一个values()方法，调用此方法后返回的是Collection对象，通过返回的对象可调用iterator()方法，从而实现取数据。还有一个get()方法也可以获得数据，但只能取出单条记录。看下面的例子HashMap hm1 = new HashMap();book bk1 = new book("001","java学习","高等教育");book bk2 = new book("002","tomcat配置","清华大学出版社");book bk3 = new book("003","jsp","机械工业");hm1.put("book1",bk1);hm1.put("book2",bk2);hm1.put("book3",bk3);其中book是书籍类，有三个属性：bookid，bookname，bookpub。具体代码见附件。调用put()方法将book的三个对象存入HashMap中，对应的名字分别为book1，book2，book3取数据的两种方法第一种Iterator itt = hm1.values().iterator();book bkex = (book) itt.next();取出的是第一条记录，在此注意的是后存的先取[至于为什么我也说不清楚]第二种book tempbook =(book)hm1.get("book3");这样可以直接根据名字取出对应的记录。以上是我得出来的一些经验，希望能对大家有所帮助。也欢迎大家进一步探讨！附件是例子的完整代码。一下是关于线性表，链表，哈希表的详细介绍，资料来源于互联网。看了之后会更有助于加深对他们的了解！线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。Collection├List│├LinkedList│├ArrayList│└Vector│ └Stack└SetMap├Hashtable├HashMap└WeakHashMapCollection接口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时，客户端代码不用改变。这就是针对抽象编程