Java 集合（初稿）
|
关于集合的详细介绍，推荐Java集合系列，以下是上面博客做的总结
Java集合工具包框架图：
简化图：
Collection（接口）
Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作和属性； Collection接口的基本API： abstract boolean add(E object) abstract boolean addAll(Collection<? extends E> collection) abstract void clear() abstract boolean contains(Object object) abstract boolean containsAll(Collection<?> collection) abstract boolean equals(Object object) abstract int hashCode() abstract boolean isEmpty() abstract Iterator<E> iterator() abstract boolean remove(Object object) abstract boolean removeAll(Collection<?> collection) abstract boolean retainAll(Collection<?> collection) abstract int size() abstract <T> T[] toArray(T[] array) abstract Object[] toArray() 为了方便，抽象出了AbstractCollection抽象类，它实现了Collection接口中绝大部分方法。 它的主要两个分支是： List 和 Set ，同样，这两个接口也有着自己的抽象类 List（接口）继承了Collection接口，是有序的一个队列，也称为序列。 List中的每一个元素都有一个索引，索引从0开始然后依次递增1，因此可以对列表中每个元素进行精确控制和访问。 和Set不同，List允许有重复的元素 除了Collection中已有的API，新增的有： abstract void add(int location,E object) abstract boolean addAll(int location,Collection<? extends E> collection) abstract E get(int location) abstract int indexOf(Object object) abstract int lastIndexOf(Object object) abstract ListIterator<E> listIterator(int location) abstract ListIterator<E> listIterator() abstract E remove(int location) abstract E set(int location,E object) abstract List<E> subList(int start,int end) ArrayListArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。 它继承于AbstractList，实现了的接口有：
ArrayList的API： boolean add(E object) boolean addAll(Collection<? extends E> collection) void clear() boolean contains(Object object) boolean containsAll(Collection<?> collection) boolean equals(Object object) int hashCode() boolean isEmpty() Iterator<E> iterator() boolean remove(Object object) boolean removeAll(Collection<?> collection) boolean retainAll(Collection<?> collection) int size() <T> T[] toArray(T[] array) Object[] toArray() void add(int location,E object) boolean addAll(int location,Collection<? extends E> collection) E get(int location) int indexOf(Object object) int lastIndexOf(Object object) ListIterator<E> listIterator(int location) ListIterator<E> listIterator() E remove(int location) E set(int location,E object) List<E> subList(int start,int end) Object clone() void ensureCapacity(int minimumCapacity) void trimToSize() void removeRange(int fromIndex,int toIndex) ArrayList数据结构是数组结构，默认容量大小是10，当容量不够的时候会自动扩容，新的容量=(原始容量*3)/2 + 1 ArrayList最大的特点：查找快，增删慢 ArrayList遍历方式
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}
Integer value = null;
for (Integer integ:list) {
value = integ;
}
Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
value = (Integer)list.get(i);
}
VectorVector 是矢量队列，有相关增删改查等功能 和ArrayList不同，Vector中的操作是线程安全的 它继承于AbstractList，实现了的接口有：
Vector的API： synchronized boolean add(E object)
void add(int location,E object)
synchronized boolean addAll(Collection<? extends E> collection)
synchronized boolean addAll(int location,Collection<? extends E> collection)
synchronized void addElement(E object)
synchronized int capacity()
void clear()
synchronized Object clone()
boolean contains(Object object)
synchronized boolean containsAll(Collection<?> collection)
synchronized void copyInto(Object[] elements)
synchronized E elementAt(int location)
Enumeration<E> elements()
synchronized void ensureCapacity(int minimumCapacity)
synchronized boolean equals(Object object)
synchronized E firstElement()
E get(int location)
synchronized int hashCode()
synchronized int indexOf(Object object,int location)
int indexOf(Object object)
synchronized void insertElementAt(E object,int location)
synchronized boolean isEmpty()
synchronized E lastElement()
synchronized int lastIndexOf(Object object,int location)
synchronized int lastIndexOf(Object object)
synchronized E remove(int location)
boolean remove(Object object)
synchronized boolean removeAll(Collection<?> collection)
synchronized void removeAllElements()
synchronized boolean removeElement(Object object)
synchronized void removeElementAt(int location)
synchronized boolean retainAll(Collection<?> collection)
synchronized E set(int location,E object)
synchronized void setElementAt(E object,int location)
synchronized void setSize(int length)
synchronized int size()
synchronized List<E> subList(int start,int end)
synchronized <T> T[] toArray(T[] contents)
synchronized Object[] toArray()
synchronized String toString()
synchronized void trimToSize()
Vector的数据结构和ArrayList差不多，默认容量大小是10，当容量不够的时候会自动扩容，若容量增加系数 >0，则将容量的值增加“容量增加系数”；否则，将容量大小增加一倍 Vector遍历方式
Integer value = null;
int size = vec.size();
for (int i=0; i<size; i++) {
value = (Integer)vec.get(i);
}
Integer value = null;
Enumeration enu = vec.elements();
while (enu.hasMoreElements()) {
value = (Integer)enu.nextElement();
}
Integer value = null;
for (Integer integ:vec) {
value = integ;
}
Integer value = null;
int size = vec.size();
for (int i=0; i<size; i++) {
value = (Integer)vec.get(i);
}
LinkedListLinkedList 是一个双向链表，也可以被当作堆栈、队列或双端队列。 它继承于AbstractSequentialList，实现了的接口有：
LinkedList的API： boolean add(E object) void add(int location,E object) boolean addAll(Collection<? extends E> collection) boolean addAll(int location,Collection<? extends E> collection) void addFirst(E object) void addLast(E object) void clear() Object clone() boolean contains(Object object) Iterator<E> descendingIterator() E element() E get(int location) E getFirst() E getLast() int indexOf(Object object) int lastIndexOf(Object object) ListIterator<E> listIterator(int location) boolean offer(E o) boolean offerFirst(E e) boolean offerLast(E e) E peek() E peekFirst() E peekLast() E poll() E pollFirst() E pollLast() E pop() void push(E e) E remove() E remove(int location) boolean remove(Object object) E removeFirst() boolean removeFirstOccurrence(Object o) E removeLast() boolean removeLastOccurrence(Object o) E set(int location,E object) int size() <T> T[] toArray(T[] contents) Object[] toArray() LinkedList数据结构是双向链表结构，没有初始大小，也没有扩容的机制，只在前面或后面新增就行 ArrayList最大的特点：增删快，查找慢 LinkedList遍历方式：
for (Integer integ:list) {
value = integ;
}
try {
while(list.removeLast() != null);
while(list.removeFirst() != null);
} catch (NoSuchElementException e) {
}
while(list.pollLast() != null); 或 while(list.pollFirst() != null);
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}
int size = list.size();
for (int i=0; i<size; i++) {
list.get(i);
}
Set（接口）Set 是继承于Collection的接口。它是一个不允许有重复元素的集合 AbstractSet 是一个抽象类，它继承于AbstractCollection，AbstractCollection实现了Set中的绝大部分函数，为Set的实现类提供了便利 HashSet
HashSet的主要API： boolean add(E object) void clear() Object clone() boolean contains(Object object) boolean isEmpty() Iterator<E> iterator() boolean remove(Object object) int size() HashSet遍历方式：
for(Iterator iterator = Iterator<String> it = set.iterator();
while (it.hasNext()) {
String str = it.next();
}
for (String str : set) {
System.out.println(str);
}
HashSet保证不重复的原理equals、hashcode LinkedHashSet属于HashSet的子类，是链表和哈希表相组合的数据存储结构 链表同时保证顺序一致 TreeSetTreeSet是一个有序的集合，从创建或插入的时候就已经排好序。 TreeSet基于TreeMap实现，元素支持2种排序方式：
关于Comparator与Comparableable是排序接口，若一个类实现该接口，则代表该类支持排序（相当于内部比较器） 当自定义排序写好之后，可以用sort进行排序 Collections.sort(list) 它会根据集合类型选择comparTo方法 当需要再倒序的时候，可以用reverSEOrder()方法 Comparator<Student> c = Collections.reverSEOrder(); Collections.sort(list,c); TreeSet继承于AbstractSet，实现了的接口有：
TreeSet的主要API： boolean add(E object) boolean addAll(Collection<? extends E> collection) void clear() Object clone() boolean contains(Object object) E first() boolean isEmpty() E last() E pollFirst() E pollLast() E lower(E e) E floor(E e) E ceiling(E e) E higher(E e) boolean remove(Object object) int size() Comparator<? super E> comparator() Iterator<E> iterator() Iterator<E> descendingIterator() SortedSet<E> headSet(E end) NavigableSet<E> descendingSet() NavigableSet<E> headSet(E end,boolean endInclusive) SortedSet<E> subSet(E start,E end) NavigableSet<E> subSet(E start,boolean startInclusive,E end,boolean endInclusive) NavigableSet<E> tailSet(E start,boolean startInclusive) SortedSet<E> tailSet(E start) TreeSet遍历方式：
for(Iterator iterator = Iterator<String> it = set.iterator();
while (it.hasNext()) {
String str = it.next();
}
for (String str : set) {
System.out.println(str);
}
TreeSet保证不重复的原理compareTo Map（接口）
Map是一个键值对映射接口，每个元素都由键与值两部分组成 在映射中不能包含重复的键，一个键只能映射一个值 Collection接口的基本API： abstract void clear() abstract boolean containsKey(Object key) abstract boolean containsValue(Object value) abstract Set<Entry<K,V>> entrySet() abstract boolean equals(Object object) abstract V get(Object key) abstract int hashCode() abstract boolean isEmpty() abstract Set<K> keySet() abstract V put(K key,V value) abstract void putAll(Map<? extends K,? extends V> map) abstract V remove(Object key) abstract int size() abstract Collection<V> values()
同样，Map接口有一个骨干实现：AbstractMap类，以最大限度地减少实现此接口所需的工作 遍历set的方式：
Set< E > sets = maps.keySet();
//遍历
Iterator<String> it = sets.iterator();
while(it.hasNext()){
String key = it.next();//得到每一个key
String value = map.get(key);//通过key获取对应的value
System.out.println(key+"="+value);
}
Collection< E > collections = maps.values();
Set< Map.Entry<K,V> > entries = maps.entrySet();
//遍历
Iterator< Map.Entry<K,V> > it = entries.iterator();
while(it.hasNext()){
//得到每一对对应关系
Map.Entry<K,V> entry = it.next();
//通过对应关系获取对应的key
String key = entry.getKey();
//通过对应关系获取对应的value
String value = entry.getValue();
System.out.println(key+"="+value);
}
其中，大部分适用的entrySet的遍历方式为： Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for (Map.Entry<Integer,Integer> entry : map.entrySet()) {
System.out.println("Key = " + entry.getKey() + ",Value = " + entry.getValue());
}
HashMapHashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 HashMap 继承于AbstractMap，实现了:Map、Cloneable、erializable接口。 HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。 HashMap的API： void clear() Object clone() boolean containsKey(Object key) boolean containsValue(Object value) Set<Entry<K,V>> entrySet() V get(Object key) boolean isEmpty() Set<K> keySet() V put(K key,V value) void putAll(Map<? extends K,? extends V> map) V remove(Object key) int size() Collection<V> values() HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。 通常，默认加载因子是 0.75,这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。 LinkedHashMap属于HashMap的子类，是链表和哈希表相组合的数据存储结构 保证顺序一致 TreeMapTreeMap 是一个有序的key-value集合，它是通过红黑树实现的。 该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。 TreeMap的API： Entry<K,V> ceilingEntry(K key) K ceilingKey(K key) void clear() Object clone() Comparator<? super K> comparator() boolean containsKey(Object key) NavigableSet<K> descendingKeySet() NavigableMap<K,V> descendingMap() Set<Entry<K,V>> entrySet() Entry<K,V> firstEntry() K firstKey() Entry<K,V> floorEntry(K key) K floorKey(K key) V get(Object key) NavigableMap<K,V> headMap(K to,boolean inclusive) SortedMap<K,V> headMap(K toExclusive) Entry<K,V> higherEntry(K key) K higherKey(K key) boolean isEmpty() Set<K> keySet() Entry<K,V> lastEntry() K lastKey() Entry<K,V> lowerEntry(K key) K lowerKey(K key) NavigableSet<K> navigableKeySet() Entry<K,V> pollFirstEntry() Entry<K,V> pollLastEntry() V put(K key,V value) V remove(Object key) int size() SortedMap<K,V> subMap(K fromInclusive,K toExclusive) NavigableMap<K,V> subMap(K from,boolean fromInclusive,K to,boolean toInclusive) NavigableMap<K,V> tailMap(K from,V> tailMap(K fromInclusive) 扩容总结
（编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |
