集合：
数学里的概念把若干数据放在一起，看成一个整体；而在面向对象的世界里，为了方便对对象的操作，体现了其如何以哪种方式储存（数据结构），集合是储存对象的 容器！
1、相比与数组：
数组：是JAVA语言内置的数据类型， 它是一个线性的序列，所以它可以快速的访问其他的元素。 但是速度是要有代价的，当你创建了一个数组之后，它的容量就固定了 如果发现有越界现象，会报RuntimeException异常错误 数组与集合的一点区别： 1：数组是固定长度的；集合可变长度的（自由添加）。 2：数组可以存储基本数据类型，也可以存储引用数据类型； 集合只能存储引用数据类型。（对象的引用） 3：数组存储的元素必须是同一个数据类型； 集合存储的对象可以是不同数据类型。
2、集合体系：
1. Collection 接口:
有了集合就要对其操作，那么具体操作有哪些？为此，抽取各个容器之共性，将其封装为一个接口，可以从面向对象的概念来理解；
接口方法看帮助文档：Collection家族中 两个主要下属，List，Set，（同为接口）
2. Iterator 接口: (迭代器)
因为不同容器对于对象的储存细节不同，但是有两点还是相同的：判断是否有，取出来，为此也抽取为接口用来规定这种取出集合的方式；各个集合对接口的实现，其遍历时对外提供 iterator()方法；此返回 iterator 接口的一个直接实现，
如： abstractList 中，内部类实现了接口 Iterator
public Iterator<E> iterator() {
return new Itr(); // 内部类 实现了Iterator
}
3. list接口:
有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复
具体实现类：
(1) ArrayList：【查询性】
底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快
(2) LinkedList：【增删性】
底层的数据结构是链表，线程不同步，增删元素的速度非常快。
(3) Vector：
底层的数据结构就是数组，线程同步的，Vector无论查询和增删都巨慢
注意：
对于list集合，底层判断元素是否相同，其实用的是元素自身的equals方法完成的。
所以建议元素都要复写equals方法，建立元素对象自己的比较相同的条件依据。
List 的示例：
package com.collection; import java.util.*; public class MethodOfList { public static void main(String args[]) { method1(); method2(); method3(); methdoOfLinkedList(); selfHasEquals(); } public static void method1(){ ArrayList al = new ArrayList(); al.add("abc0"); al.add("abc1"); al.add("abc3"); al.add(0, "abc5"); //表明是从 index = 0 时存取的： al.set(2, "替代"); _iterator(al); /* abc5 abc0 替代 abc3 */ } private static void method2(){ ArrayList al = new ArrayList(); al.add("abc0"); al.add("abc1"); al.add("abc3"); ArrayList all = new ArrayList(); all.add("abc0"); all.add("abc1"); all.add("abc5"); all.retainAll(al); // 交集 _iterator(all); /* abc0 abc1 */ } private static void method3(){ ArrayList al = new ArrayList(); al.add("abc0"); al.add("abc1"); al.add("abc2"); al.add("abc3"); al.add("abc1"); al.remove("abc1"); //只会remove()最先找到的 _iterator(al); System.out.println("4:"+al.get(3)); /* 4:abc1 由此方法我们可以用for循环来迭代，不用迭代器, 但是时间比迭代器慢多了， List集合因为角标有了自己的获取元素的方式, */ for(int i = 0; i < al.size(); i++) { // System.out.println(al.toString()); System.out.println(al.get(i)) ; if(i==0) al.add("临死添加"); if(i==1) al.set(2, "零食修改"); } /*abc0 abc2 零食修改 abc1 临死添加 */ } private static void _iterator(Collection coll) { /* 当然：如果嫌弃方法不够的话，可以获得 ListIterator （List集合特有的迭代器， 该列表迭代器接口具备了对元素的增、删、改、查的动作） */ for(Iterator iterator = coll.iterator(); iterator.hasNext() ;) { /*String s = (String)iterator.next(); System.out.println(s);*/ /* 假如add(2); ----装箱为Integer，不能转为String jdk1.5增加了泛型，在编译时期动态查询引用数据类型， 达到与实际主观add的效果（） 就是集合内类型一致 */ System.out.println(iterator.next()); } System.out.println(); } public static void methdoOfLinkedList(){ LinkedList<String> ld = new LinkedList<String>(); ld.add("1"); ld.add("2"); ld.add("3"); ld.add(null); ld.addFirst("addfirst"); ld.addLast("不就是add么？"); _iterator(ld); /* 新增方法： 获得： getFirst() getLast() ; 获取链表中的第一个元素。如果链表为空， 抛出NoSuchElementException; peekFirst(); 获取链表中的第一个元素。如果链表为空，返回null。 peekLast(); public E getFirst() { if (size==0) throw new NoSuchElementException(); return header.next.element; } 移除： removeFirst() NoSuchElementException; removeLast(); pollFirst();获取链表中的第一个元素，但是会删除链表中的第一个元素。 如果链表为空，返回null。 pollLast(); */ ld.removeAll(ld); //全部移除 _iterator(ld); // System.out.println(ld.getFirst()); System.out.println(ld.peek()); // null } public static void selfHasEquals() { ArrayList<Str> al = new ArrayList<Str>(); Str temp = new Str("2"); al.add(new Str("1")); al.add(new Str("2")); //如果没有覆写equals,,,是不会找到，返回false System.out.println(al.contains(temp)); } } class Str{ String s ; Str(String s){ this.s = s; } /*public boolean equals(Object t){ return this.s.equals(((Str)t).s); }*/ }
4. Set接口：
无序(存入和取出顺序有可能不一致)，不可以存储重复元素。必须保证元素唯一性
(1) HashSet：【唯一性】
底层数据结构是哈希表，线程是不同步的。无序，高效；对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。
为什么由这两个实现呢？？：
查类库： HashSet<E> private transient HashMap<E,Object> map; private static final Object PRESENT = new Object(); ----> public boolean add(E e) { return map.put(e, PRESENT)==null; } ---> HashMap<K,V> ----public V put(K key, V value) public V put(K key, V value) { if (key == null) return putForNullKey(value); int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(hash, key, value, i); return null; } 由上我们也可以知道，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。
(2) TreeSet: 【 排序性】
用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。如果元素不具备比较性，在运行时会发生ClassCastException异常。
Set 的示例：
package com.collection; import java.util.HashSet; import java.util.Iterator; import java.util.Set; import java.util.TreeSet; public class MethodOfSet { public static void main(String args[]) { testMethodOfHashSet(); testMethodOfTreeSet(); testTime(); } private static void testMethodOfHashSet() { HashSet<Object> hs = new HashSet<Object>(); hs.add("a"); hs.add("b"); hs.add("a"); _iterator(hs); /* b a 体现无序性 和 唯一性 */ } private static void testMethodOfTreeSet() { TreeSet<Object> ts = new TreeSet<Object>(); ts.add("x"); ts.add("z"); ts.add("y"); ts.add("y"); _iterator(ts); /* x y z*/ } private static void _iterator(Set<Object> hs) { for(Iterator<Object> i = hs.iterator(); i.hasNext();) { System.out.println(i.next()); } System.out.println(); } private static void testTime() { long start ,end ; int temp ; Set<Integer> st = new HashSet<Integer>(); for(int i = 0; i < 1008611;i++) { st.add(i); } start = System.currentTimeMillis(); for(Iterator<Integer> i = st.iterator();i.hasNext();) { temp = i.next(); } end = System.currentTimeMillis(); System.out.println("---iterator:"+(end-start)); start = System.currentTimeMillis(); for(Integer t:st) { temp = t ; } end = System.currentTimeMillis(); System.out.println("---增强 for:"+(end-start)); /* ---iterator:25 ---增强 for:24 二者不相上下： */ } }
5、map接口：
public interface Map<K,V>
所有键值对构成的集合，对此种集合集成为一个接口，便于扩展，Map集合存储和Collection有着很大不同：
- Collection一次存一个元素；Map一次存一对元素(一对元素也可以看做一个整体，封装为对象，)。
- Collection是单列集合；Map是双列集合。
- Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
总之，要保证map集合中键的唯一性。
----------------------
Map.Entry<K,V>
一对键值本身看做一个对象，由于有获得键，获得值，两种共性，因此抽离出此接口；getKey() ；getValue() ：setValue(V value)
map的实现类中，含有内部实现类：
Entry: static class Entry<K,V> implements Map.Entry<K,V>
so ,entry是访问键值关系的入口，是map的入口，访问的是map中的键值对，
但由于内部类无法导入，故使用接口回调
转换：
map中的所有Entry 转化 为 entrySet （返回：set<Map.Entry<k,v>>
也可以将所有键值转为： Set keySet();
Map 的示例：
package com.collection; import java.util.*; public class MethodOfMap { public static void main(String args[]) { methodOfHashMap(); methodOfTreeMap(); Example(); } private static void methodOfHashMap() { Map<Integer,String> m = new HashMap<Integer,String>(); m.put(1, "a"); m.put(2, "a"); m.put(3, "a"); m.put(2, "b"); // //出map集合中所有元素 Set<Map.Entry<Integer, String>> s1 = m.entrySet(); for(Iterator<Map.Entry<Integer, String>> i = s1.iterator(); i.hasNext(); ) { Map.Entry<Integer, String> e = i.next(); System.out.println(e.getKey()+" ： "+e.getValue()); e.setValue(e.getKey()+""+e.getValue()); //根据键值来修改： } System.out.println(); Set<Integer> s2 = m.keySet(); for(Iterator<Integer> i = s2.iterator(); i.hasNext(); ) { Object k = i.next(); Object v = m.get(k); System.out.println(k+" ： "+v); } /* 1 ： a 2 ： b 3 ： a 1 ： 1a 2 ： 2b 3 ： 3a */ } private static void methodOfTreeMap() { Map<Integer,String> m = new TreeMap<Integer,String>(); m.put(51, "v"); m.put(72, "e"); m.put(33, "l"); m.put(42, "o"); Set<Integer> s = m.keySet(); Iterator<Integer> i = s.iterator(); while(i.hasNext()){ Integer k = i.next(); String v = m.get(k); System.out.println(k+"-"+v); } /* 33-l 42-o 51-v 72-e*/ } public static void Example() { /* 一字符串：String str="1,1,0"; 数字使用逗号隔开，统计出每个数字出现的次数。使用map<数字，次数>;*/ String target = "10,16,10,16,17,11,16,10,16,10,17,11,16,13,13,11,16,10"; String s[] = target.split(","); Map<String ,Integer> m = new HashMap<String ,Integer>(); for(int i = 0 ;i <s.length ;i++) { if(m.containsKey(s[i])) { m.put(s[i],m.get(s[i])+1); } else{ m.put(s[i], 1); } } for(Iterator<Map.Entry<String ,Integer>> i = m.entrySet().iterator() ;i.hasNext();) { Map.Entry<String, Integer> me = i.next(); System.out.println(me.getKey()+":"+me.getValue()); /* 10:5 17:2 16:6 13:2 11:3 */ } } }