java基础---集合框架
一、集合与数组 区别
数组（可以存储基本数据类型）是用来存现对象的一种容器，但是数组的长度固定，不适合在对象数量未知的情况下使用。
集合（只能存储对象，对象类型可以不一样）的长度可变，可在多数情况下使用。
二、集合类结构
Java中的集合包含多种数据结构，如链表、队列、哈希表等。从类的继承结构来说，可以分为两大类，一类是继承自Collection接口，这类集合包含List、Set和Queue等集合类。另一类是继承自Map接口，这主要包 含了哈希表相关的集合类。下面我们看一下这两大类的继承结构图：
图中的绿色的虚线代表实现，绿色实线代表接口之间的继承，蓝色实线代表类之间的继承。
三、集合详解
collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了 按索 引访问的方式。
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刚创建后是空栈。
自定义的集合arraylist
package cn.bjsxt.collection; /** * 自己实现一个ArrayList，帮助我们更好的理解ArrayList类的底层结构！ * */ public class SxtArrayList /*implements List*/ { private Object[] elementData; private int size; public int size(){ return size; } public boolean isEmpty(){ return size==0; } public SxtArrayList(){ this(10); } public SxtArrayList(int initialCapacity){ if(initialCapacity<0){ try { throw new Exception(); } catch (Exception e) { e.printStackTrace(); } } elementData = new Object[initialCapacity]; } public void add(Object obj){ //数组扩容和数据的拷贝 if(size==elementData.length){ Object[] newArray = new Object[size*2+1]; System.arraycopy(elementData, 0, newArray, 0, elementData.length); // for(int i=0;i<elementData.length;i++){ // newArray[i] = elementData[i]; // } elementData = newArray; } elementData[size++]=obj; // size++; } public Object get(int index){ rangeCheck(index); return elementData[index]; } public void remove(int index){ rangeCheck(index); //删除指定位置的对象 //a b d e int numMoved = size - index - 1; if (numMoved > 0){ System.arraycopy(elementData, index+1, elementData, index, numMoved); } elementData[--size] = null; // Let gc do its work } public void remove(Object obj){ for(int i=0;i<size;i++){ if(get(i).equals(obj)){ //注意：底层调用的equals方法而不是==. remove(i); } } } public Object set(int index,Object obj){ rangeCheck(index); Object oldValue = elementData[index]; elementData[index] = obj; return oldValue; } public void add(int index,Object obj){ rangeCheck(index); ensureCapacity(); //数组扩容 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = obj; size++; } private void ensureCapacity(){ //数组扩容和数据的拷贝 if(size==elementData.length){ Object[] newArray = new Object[size*2+1]; System.arraycopy(elementData, 0, newArray, 0, elementData.length); // for(int i=0;i<elementData.length;i++){ // newArray[i] = elementData[i]; // } elementData = newArray; } } private void rangeCheck(int index){ if(index<0||index>=size){ try { throw new Exception(); } catch (Exception e) { e.printStackTrace(); } } } public static void main(String[] args) { SxtArrayList list = new SxtArrayList(3); list.add("333"); list.add("444"); list.add("5"); list.add("344433"); list.add("333"); list.add("333"); System.out.println(list.size()); // System.out.println(list.get(6)); list.remove("444"); System.out.println(list.size()); } }
自定义linkedlist
package com.bdqn; //用来表示一个节点 public class Node { Node previous; //上一个节点 Object obj; Node next; //下一个节点 public Node() { } public Node(Node previous, Object obj, Node next) { super(); this.previous = previous; this.obj = obj; this.next = next; } public Node getPrevious() { return previous; } public void setPrevious(Node previous) { this.previous = previous; } public Object getObj() { return obj; } public void setObj(Object obj) { this.obj = obj; } public Node getNext() { return next; } public void setNext(Node next) { this.next = next; } }
package com.bdqn; import java.util.LinkedList; public class SxtLinkedList /*implements List*/ { private Node first; private Node last; private int size; public void add(Object obj){ Node n = new Node(); if(first==null){ n.setPrevious(null); n.setObj(obj); n.setNext(null); first = n; last = n; }else{ //直接往last节点后增加新的节点 n.setPrevious(last); n.setObj(obj); n.setNext(null); last.setNext(n); last = n; } size++; } public int size(){ return size; } private void rangeCheck(int index){ if(index<0||index>=size){ try { throw new Exception(); } catch (Exception e) { e.printStackTrace(); } } } public Object get(int index){ //2 rangeCheck(index); // 0 1 2 3 4 Node temp = node(index); if(temp!=null){ return temp.obj; } return null; } public Node node(int index){ Node temp = null; if(first!=null){ temp = first; for(int i=0;i<index;i++){ temp = temp.next; } } LinkedList l; return temp; } public void remove(int index){ Node temp = node(index); if(temp!=null){ Node up = temp.previous; Node down = temp.next; up.next = down; down.previous = up; size--; } } public void add(int index,Object obj){ Node temp = node(index); Node newNode = new Node(); newNode.obj = obj; if(temp!=null){ Node up = temp.previous; up.next = newNode; newNode.previous = up; newNode.next = temp; temp.previous = newNode; size++; } } public static void main(String[] args) { SxtLinkedList list = new SxtLinkedList(); list.add("aaa"); list.add("bbb"); list.add(1,"BBBB"); list.add("ccc"); // list.remove(1); System.out.println(list.get(1)); } }
Set接口
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
HashSet
HashSet有以下特点
不能保证元素的排列顺序，顺序有可能发生变化
不是同步的
集合元素可以是null,但只能放入一个null
当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。
简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相 等
注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对 象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。
TreeSet类
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
自然排序
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法。
最重要：
1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。
2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。
3、HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的 String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。
自定义hashset
package cn.bjsxt.collection; import java.util.HashMap; /** * 自定义自己的HashSet * @author Administrator * */ public class SxtHashSet { HashMap map; private static final Object PRESENT = new Object(); public SxtHashSet(){ map = new HashMap(); } public int size(){ return map.size(); } public void add(Object o){ map.put(o, PRESENT); //set的不可重复就是利用了map里面键对象的不可重复！ } public static void main(String[] args) { SxtHashSet s = new SxtHashSet(); s.add("aaa"); s.add(new String("aaa")); System.out.println(s.size()); } }
hashSet使用
package com.zwj.set; public class Food { private String name; private double price; public Food() { // TODO Auto-generated constructor stub } public Food(String name, double price) { super(); this.name = name; this.price = price; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); long temp; temp = Double.doubleToLongBits(price); result = prime * result + (int) (temp ^ (temp >>> 32)); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Food other = (Food) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (Double.doubleToLongBits(price) != Double .doubleToLongBits(other.price)) return false; return true; } }
package com.zwj.set; import java.util.HashSet; import java.util.Iterator; import java.util.Set; /** * 默认的hashcode时地址转换码，需要重写 * 先比较hashcode * 再比较equals * * @author Administrator * */ public class SetDemo01 { /** * @param args */ public static void main(String[] args) { Food food1 = new Food("瓜子",5); Food food2 = new Food("糖果",10); Food food3 = new Food("瓜子",5); Food food4 = new Food("瓜子2",5); Set<Food> set = new HashSet<Food>(); set.add(food1); set.add(food1); set.add(food2); set.add(food3); set.add(food4); System.out.println(set.size()); System.out.println("===foreach====="); for(Food temp:set){ System.out.println(temp.getPrice()+"-->"+temp.getName()); } System.out.println("======iterator========="); Iterator<Food> it =set.iterator(); while(it.hasNext()){ //判断，不会移动游标 |指针 Food temp =it.next(); //一次移动一个游标 不能移动多次 //System.out.println(it.next().getPrice()+"-->"+it.next().getName()); System.out.println(temp.getPrice()+"-->"+temp.getName()); } } } /* 3 ===foreach===== 10.0-->糖果 5.0-->瓜子2 5.0-->瓜子 ======iterator========= 10.0-->糖果 5.0-->瓜子2 5.0-->瓜子 */
使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中点名:遍历输出名单
package com.zwj.set; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashSet; import java.util.Iterator; import java.util.Scanner; import java.util.Set; /** * 使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中 点名:遍历输出名单 * @author Administrator * */ public class SetDemo04 { private Scanner sc ; private Set<Member> members; SetDemo04(){ sc = new Scanner(System.in); members= new HashSet<Member>(); } public String getStringFromConsole(){ return sc.nextLine(); } //签名: public void addMemeber(Member mem){ members.add(mem); } //点名:遍历输出名单 public void showMemeber(){ Iterator<Member> it = members.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } /** * @param args */ public static void main(String[] args) { SetDemo04 demo = new SetDemo04(); System.out.println("====签名======"); while(true){ String name =demo.getStringFromConsole(); if(name.equalsIgnoreCase("over")){ break; } Member m =new Member(name); demo.addMemeber(m); } System.out.println("=========参会人员有===="); demo.showMemeber(); /*====签名====== in am me over =========参会人员有==== 名单:me,签名时间:2017-11-18 18:00:39 名单:am,签名时间:2017-11-18 18:00:36 名单:in,签名时间:2017-11-18 18:00:33 */ } } class Member{ private String name; private Date attendTime; public Member() { attendTime = new Date(); } public Member(String name) { this(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Date getAttendTime() { return attendTime; } public void setAttendTime(Date attendTime) { this.attendTime = attendTime; } public Member(String name, Date attendTime) { super(); this.name = name; this.attendTime = attendTime; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Member other = (Member) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return "名单:"+name+",签名时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(attendTime); } }
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时，客户端代码不用改变。这就是针对抽象编程。
自定义集合sxtHashMap
package com.bdqn; import java.util.LinkedList; /** * 自定义Map的升级版： * 1. 提高查询的效率 * * */ public class SxtMap002 { LinkedList[] arr = new LinkedList[9]; //Map的底层结构就是：数组+链表! int size; public void put(Object key,Object value){ SxtEntry e = new SxtEntry(key,value); int a = key.hashCode()%arr.length; if(arr[a]==null){ LinkedList list = new LinkedList(); arr[a] = list; list.add(e); }else{ LinkedList list = arr[a]; for(int i=0;i<list.size();i++){ SxtEntry e2 = (SxtEntry) list.get(i); if(e2.key.equals(key)){ e2.value = value; //键值重复直接覆盖！ return; } } arr[a].add(e); } //a:1000-->1 b:10000-->13 } public Object get(Object key){ int a = key.hashCode()%arr.length; if(arr[a]!=null){ LinkedList list = arr[a]; for(int i=0;i<list.size();i++){ SxtEntry e = (SxtEntry) list.get(i); if(e.key.equals(key)){ return e.value; } } } return null; } public static void main(String[] args) { SxtMap002 m = new SxtMap002(); m.put("高琪", new Wife("杨幂")); m.put("高琪", new Wife("李四")); Wife w = (Wife) m.get("高琪"); System.out.println(w.name); } } class SxtEntry { Object key; Object value; public SxtEntry(Object key, Object value) { super(); this.key = key; this.value = value; } } class Wife{ public static String name; public Wife(String name) { this.name = name; } public Wife() {} }
四、遍历
在类集中提供了以下四种的常见输出方式：
1）Iterator：迭代输出，是使用最多的输出方式。
2）ListIterator：是Iterator的子接口，专门用于输出List中的内容。
3）foreach输出：JDK1.5之后提供的新功能，可以输出数组或集合。
4）for循环
代码示例如下：
for的形式：for（int i=0;i<arr.size();i++）{...}
foreach的形式： for（int i：arr）{...}
iterator的形式：
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); ...}
package com.bdqn; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Dmeo { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); //第一种遍历list 集合 for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } //第二种遍历list集合 for (String str : list) { System.out.println(str); } //第三种遍历list集合 Iterator<String> stu=list.iterator(); while (stu.hasNext()) { //String string = (String) stu.next(); System.out.println( stu.next()); } } }
package com.bdqn; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class Dmeo { public static void main(String[] args) { Set<String> set=new HashSet<String>(); set.add("a"); set.add("b"); set.add("c"); set.add("d"); //iterrator 迭代 Iterator<String> iterator=set.iterator(); while (iterator.hasNext()) { String string = (String) iterator.next(); System.out.println(string); } //用增强for循环去遍历 for (String string1 : set) { System.out.println(string1); } } }
package com.bdqn; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Dmeo { public static void main(String[] args) { Map<Integer, String> map = new HashMap<Integer, String>(); map.put(1, "a"); map.put(2, "b"); map.put(3, "c"); map.put(4, "d"); map.put(5, "e"); System.out.println("第一种遍历map集合 "); Iterator<Integer> iterator=map.keySet().iterator(); while (iterator.hasNext()) { Integer integer = (Integer) iterator.next(); System.out.println(integer+":"+map.get(integer)); } System.out.println("第二种for循环遍历 前兩中都是先得到key的集合，在得到values"); for (Integer integer : map.keySet()) { System.out.println(integer+":"+map.get(integer)); } System.out.println("第三种遍历的方式 iterraotr直接得到key values集合"); Iterator<Map.Entry<Integer, String>> iterator2=map.entrySet().iterator(); while (iterator2.hasNext()) { Map.Entry<java.lang.Integer, java.lang.String> entry = (Map.Entry<java.lang.Integer, java.lang.String>) iterator2 .next(); System.out.println(entry.getKey()+":"+entry.getValue()); } System.out.println("第四种遍历的方式 for直接得到key values集合"); for (Map.Entry<Integer, String> entry2 : map.entrySet()) { System.out.println(entry2.getKey()+":"+entry2.getValue()); } } }
五、主要实现类区别
Vector和ArrayList
1，vector是线程同步的，所以它也是线程安全的，而arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。
2，如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%，而arraylist增长率为目前数组长度的50%。如果在集合中使用数据量比较大的数据，用vector有一定的优势。
3，如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，如果频繁的访问数据，这个时候使用vector和arraylist都可以。而如果移动一个指定位置会导致后面的元素都发生移动，这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据时其它元素不移动。
ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要涉及到数组元素移动等内存操作，所以索引数据快，插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快。
arraylist和linkedlist
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。
HashMap与TreeMap
1、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。
2、在Map 中插入、删除和定位元素，HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。
两个map中的元素一样，但顺序不一样，导致hashCode()不一样。
同样做测试：
在HashMap中，同样的值的map,顺序不同，equals时，false;
而在treeMap中，同样的值的map,顺序不同,equals时，true，说明，treeMap在equals()时是整理了顺序了的。
HashTable与HashMap
1、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
2、HashMap允许存在一个为null的key，多个为null的value 。
3、hashtable的key和value都不允许为null。
