Java集合学习总结

java集合

---

collection

public interface Collection<E> extends Iterable<E>

List

public interface List<E> extends Collection<E> 

特点：线性结构，有序，可重复

LinkedList

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

​ 数据结构：双向链表

​ 特点：非线程安全，查询慢，增删快，逻辑连续的空间内存（物理可不连续），内存利用率高

​ 备注：可把LinkedList当做队列使用，额外实现了Queue接口(非直接实现，通过实现Queue的子接口Deque间接实现Queue)，所以有offer(E)从尾部添加数据，peek()返回第一个元素但不出队，poll()返回第一个元素并出队

ArrayList

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

​ 数据结构：数组

​ 特点：非线程安全，查询快，增删慢，内存利用率低，物理连续的空间内存，可改变大小

​ 备注：性能比Vector好，因为不能同步，只适用单线程

Vector

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

​ 数据结构：数组

​ 特点：线程安全，查询快，增删慢，内存利用率低，物理连续的空间内存，可改变大小

​ 备注：性能弱于ArrayList，需要同步

Stack

public class Stack<E> extends Vector<E> 

​ 数据结构：栈

​ 特点：线程安全，后进先出，last in first out

​ 备注：通过五个操作对类Vector进行了扩展，class Stack extends Vector ，pop()，peek()方法加了synchronized

queue

public interface Queue<E> extends Collection<E>

特点：先进先出，first in first out

PriorityQueue

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable

​ 数据结构：动态数组（类似ArrayList）

​ 特点：非线程安全，确保集合元素处于有序状态，不允许null

​ 备注：优先级队列就是堆，可做小根堆，大根堆使用，性能较高，iterator()中提供的迭代器并不保证以有序的方式遍历PriorityQueue中的元素

Deque

public interface Deque<E> extends Queue<E>

​ 数据结构：双端队列

​ 特点：即可当队列使用，又可以当栈使用，满足FIFO，LIFO，同时具备栈和队列的特点

​ 备注：Stack过于古老，可以用Deque来代替

ArrayDeque

public class ArrayDeque<E> extends AbstractCollection<E>
                           implements Deque<E>, Cloneable, Serializable

​ 数据结构：循环数组

​ 特点：非线程安全，数组内任何一个位置，可当起点，来遍历整个数组，内部维持两个变量，表示ArrayDeque的头和尾，性能：当栈使用时 > Stack；当队列使用时 > LinkedList

​ 备注：需要注意其添加元素和扩容过程，方法有：addFirst(e)，addLast(e)，offerFirst(e)，offerLast(e)，pollFirst()，pollLast()等等，注：平时使用尽量用offer，因为失败不抛出异常，当然也可视情况而定。

BlockingQueue

public interface BlockingQueue<E> extends Queue<E> 

​ 数据结构：一种阻塞的FIFO，队列

​ 特点：线程安全，每一个BlockingQueue都有一个容量，当容量满时，插入元素就会阻塞；当容量为空时，取元素也会阻塞。

​ 备注：其实现类，有很多。ArrayBlockingQueue（基于数组），LinkedBlockingQueue（基于链表），PriorityBlockingQueue（堆），DelayQueue，SynchronousQueue，LinkedTransferQueue，LinkedBlockingDeque。

set

public interface Set<E> extends Collection<E> 

特点：离散结构，无序，不可重复元素，最多包含一个null元素

TreeSet

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

​ 数据结构：红黑树

​ 特点：非线程安全，可排序（有序的），根据红黑树结构来查找元素位置

​ 备注：自然排序（调用集合中元素所属类的Comparable接口来比较元素之间的大小关系），定制排序（通过Comparator接口实现compare(T o1, T o2) 来比较），添加对象到TreeSet一定，则该对象的类一定要实现Comparable接口，否则会出现异常。TreeSet只能添加一种类型的对象，否则会抛出异常。

HashSet

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

​ 数据结构：HashMap

​ 特点：线程不安全，不保证元素的顺序，根据元素的hashCode值决定元素的位置，存取，查询效率高

​ 备注：HashSet基于HashMap实现，判断两个元素相等的标准：equals() & hashCode() 返回值都相等，

LinkedHashSet

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable 

​ 数据结构：HashMap

​ 特点：使用链表维护元素的顺序，使得元素保持插入时的顺序，访问顺序=添加顺序，可以按插入顺序遍历的HashSet

​ 备注：判断元素相等，同HashSet

EnumSet

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    implements Cloneable, java.io.Serializable

​ 数据结构：位向量

​ 特点：非线程安全，集合有序，所有元素必须是指定枚举类型的枚举值

​ 备注：性能高效，以位向量的形式存储，结构紧凑、高效，且只存储枚举类的枚举值

map

public interface Map<K,V> 

特点：键值对，键（唯一），值（可重复）

备注：通过key，可在O（1）的时间内查找到value

HashMap

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

​ 数据结构：数组，单链表，红黑树

​ 特点：线程不安全，插入值是随机乱序的，即插入顺序！=访问顺序，性能最高。key可有一个null。

​ 备注：无特殊要求，优先使用

LinkedHashMap

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>

​ 数据结构：在HashMap的基础上，新增了双向链表

​ 特点：保存了插入时的顺序，在迭代时，维护双向链表以此保证其顺序性，性能弱于HashMap

​ 备注：要求其访问顺序==插入顺序时，使用

TreeMap

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

​ 数据结构：红黑树

​ 特点：可根据key来排序，通过Comparator传入，可自定制的排序，性能最慢

​ 备注：要求排序时，使用

Hashtable

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

​ 数据结构：与HashMap类似

​ 特点：线程安全，key不能为null，性能不如HashMap（因为需要同步）

collections

​ 是一个工具类，提供一系列的静态方法来辅助容器的操作

collections与Arrays的区别：

常用操作方法：

`// 主要功能有：搜索元素、获取最大最小值、排序集合、对象线程安全化、将1个List所有元素复制到另1个 等
// 1. 获取最大最小值
static T max(Collection<? extends T> coll, Comparator<? super T> comp);
static T min(Collection<? extends T> coll, Comparator<? super T> comp);

// 2. 排序
static void sort(List list, Comparator<? super T> c);

// 3. 将线程不安全的Collection转为线程安全的Collection
static Collection synchronizedCollection(Collection c);
static List synchronizedList(List list);
static Map<K,V> synchronizedMap(Map<K,V> m);
static Set synchronizedSet(Set s);

// 交换指定位置的两个元素
static void swap(List<?> list, int i, int j)

// 主要操作对象 = 集合类 = Collection接口的实现类
List list = new ArrayList();
list.add(XXX);
//···
list.add(XXX);

Collectoions.sort(list);`

总结