java集合

List,Set,Map是否继承自Collection接口？ 
答：List，Set是，Map不是。 

Collection {List[LinkedList ArrayList Vector[Stack] ] Set} 
Map {Hashtable HashMap WeakHashMap}
详细介绍：
List特点：元素有放入顺序，元素可重复 
Map特点：元素按键值对存储，无放入顺序 
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） 
List接口有三个实现类：LinkedList，ArrayList，Vector 
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢 
ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低 
Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet 
SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现） 
Query接口有一个实现类：LinkList 
Map接口有三个实现类：HashMap，HashTable，LinkeHashMap 
 HashMap非线程安全，高效，支持null；HashTable线程安全，低效，不支持null 
SortedMap有一个实现类：TreeMap 
其实最主要的是，list是用来处理序列的，而set是用来处理集的。Map是知道的，存储的是键值对 
set 一般无序不重复.map kv 结构 list 有序 　


　


ArrayList、LinkedList、Vector 区别


ArrayList : 
ArrayList是实现了基于动态数组的数据结构,有序的，线程不安全的
ArrayList实现了可变大小的数组。它容许所有元素，包含null。ArrayList没有同步。
ArrayList的内部实现是基于基础的对象数组的，因此，它使用get方法访问列表中的任意一个元素时(random access)，它的速度要比LinkedList快
ArrayList 变成线程安全的 Collections.synchronizedList(list);

LinkList : LinkedList基于链表的数据结构。 
LinkedList中的get方法是按照顺序从列表的一端开始检查，直到另外一端
LinkList中多了一下方法
linkedList.add(0, "11");
linkedList.addFirst("11");
linkedList.addLast("222");
linkedList.getFirst();
linkedList.getLast();
linkedList.element();  //实际调用getFirst()
linkedList.offer("1"); //实际调用add方法
linkedList.offerFirst("22"); // addFirst
linkedList.offerLast("222");// addLast
linkedList.peek(); //getFirst
linkedList.peekFirst(); getFirst
linkedList.peekLast(); getLst
linkedList.removeFirst();
linkedList.removeLast();
linkedList.removeFirstOccurrence("2"); //删除第一个出现的 
linkedList.removeLastOccurrence("22");  //删除最后一个出现的
linkedList.poll();  //removeFirst
linkedList.pollFirst(); //removeFirst
linkedList.pollLast(); //removeLast
linkedList.pop(); //removeFirst
LinkList 变成线程安全的Collections.synchronizedList(linkedList);

ArrayList和LinkedList区别：
 1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，
偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。
 2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。
 3．LinkedList不支持高效的随机元素访问。
 4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间


总结：可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；
当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
 
Vector : 也是实现了基于动态数组的数据结构，有序，并且线程是安全的
Vector类似于ArrayList，只是Vector是线程安全的，ArrayList是线程不安全的。由Vector创建的Iterator和ArrayList创建的Iterator是同一接口, 因为Vector是线程同步的，所以当一个Iterator
 被创建并正在应用时，另一个线程则改变了Vector的状态（比如删除或添加了一些元素）这时候调用Iterator方法时将抛出ConcurrentModificationException异常，是必须要捕获的。
Stack ：继承自Vector
实现一个掉队先出的客栈。Stack提供了5个额外的方法使得Vector得以被算作客栈应用。push添加一个元素,pop栈顶的元素，还有peek办法获得栈顶的元素，
empty办法测试客栈是否为空，search办法检测一个元素在客栈中的位置。Stack刚创建后是空栈。



HashMap HashTable HashSet
HashMap HashTable 
1.HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受一个null做key接受无数个null做value 而HashTable不接受value为null
2.HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。 
即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；
   而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决：Collections.synchronizedMap(Map m)

3.HashTable的Iterator和HashMap的Iterator是同一接口，但是因为Hashtable是线程同步的，，所以当一个Iterator
被创建并正在应用时，另一个线程则改变了HashTable的状态（比如删除或添加了一些元素）这时候调用Iterator方法时将抛出ConcurrentModificationException异常，是必须要捕获的。
4.由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
5.HashMap不能保证随着时间的推移Map中的元素次序是不变的。
6.哈希值的使用不同，HashTable直接使用对象的hashCode,而HashMap重新计算hash值.
    HashSet
1.实现了Set接口，不允许集合中有重复的值，无序的
2.HashSet的底层实现使用了HashMap不过只实现了HashMap的key


java中TreeMap和TreeSet实现（红黑树）


TreeSet详解：
public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable{

//使用 NavigableMap 的 key 来保存 Set 集合的元素
private transient NavigableMap<E,Object> m;

// 使用一个 PRESENT 作为 Map 集合的所有 value。
private static final Object PRESENT = new Object();

// 包访问权限的构造器，以指定的 NavigableMap 对象创建 Set 集合
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}

public TreeSet() {
// 以自然排序方式创建一个新的 TreeMap，
// 根据该 TreeSet 创建一个 TreeSet，
// 使用该 TreeMap 的 key 来保存 Set 集合的元素
this(new TreeMap<E,Object>());
}

public TreeSet(Comparator<? super E> comparator) {
// 以定制排序方式创建一个新的 TreeMap，
// 根据该 TreeSet 创建一个 TreeSet，
// 使用该 TreeMap 的 key 来保存 Set 集合的元素
this(new TreeMap<E,Object>(comparator));
}

public TreeSet(Collection<? extends E> c) {
// 调用默认构造器创建一个TreeSet,底层以 TreeMap 保存集合元素
this();
// 向 TreeSet 中添加 Collection 集合 c 里的所有元素
addAll(c);
}

public TreeSet(SortedSet<E> s) {
// 调用参数为Comparator构造器创建一个 TreeSet，底层以 TreeMap 保存集合元素
this(s.comparator());
// 向 TreeSet 中添加 SortedSet 集合 s 里的所有元素
addAll(s);
}
//TreeSet的addAll方法
public  boolean addAll(Collection<? extends E> c) {
//判断传入的集合
if (m.size()==0 && c.size() > 0 && c instanceof SortedSet && m instanceof TreeMap) {
//将集合强转成SortedSet类型
SortedSet<? extends E> set = (SortedSet<? extends E>) c;
// 把m 集合强制转换为 TreeMap 集合
TreeMap<E,Object> map = (TreeMap<E, Object>) m;
Comparator<? super E> cc = (Comparator<? super E>) set.comparator();
Comparator<? super E> mc = map.comparator();
//如果 cc 和 mc 两个 Comparator 相等
if (cc==mc || (cc != null && cc.equals(mc))) {
// 把 Collection 中所有元素添加成 TreeMap 集合的 key 
map.addAllForTreeSet(set, PRESENT);
return true;
}
}
// 直接调用父类的 addAll() 方法来实现
return super.addAll(c);
}

与 HashSet 完全类似的是，TreeSet 里绝大部分方法都是直接调用 TreeMap 的方法来实现的

TreeMap详解：
TreeMap,它采用一种被称为“红黑树”的排序二叉树来保存 Map 中每个 Entry —— 每个 Entry 都被当成“红黑树”的一个节点对待。
代码：
TreeMap<String, String> treemap = new TreeMap<String, String>();
treemap.put("语文", "145");
treemap.put("数学", "143");
treemap.put("英语", "100");
treemap.put("化学", "100");

System.out.println(treemap);
输出结果
{化学=100, 数学=143, 英语=100, 语文=145}
*******结果集对key进行了由小到大地排序*******


红黑树
红黑树是一种自平衡排序二叉树，树中每个节点的值，都大于或等于在它的左子树中的所有节点的值，并且小于或等于在它的右子树中的所有节点的值，
这确保红黑树运行时可以快速地在树中查找和定位的所需节点。

未完.....