JAVA集合全解

ArrayList：有序的集合,可重复，允许多个空值

常用方法：add(),addAll(),get(),size()

多个线程访问list时：

同步是指：当一个线程对集合做操作时，另一个线程不能进行操作

ArrayList不是线程同步，故不是线程安全的，但是效率高

注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

        List list = Collections.synchronizedList(new ArrayList(...));

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。

list的遍历问题

for循环每次会重新获取集合长度，所以for循环中可以在尾部添加，并可以在for循环中遍历出来

ListIterator迭代器：

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Integer> list=new ArrayList<>();
		list.add(1);
		list.add(2);
		list.add(3);
		ListIterator<Integer> iterator=list.listIterator();
		while(iterator.hasNext())
		{
//			if(iterator.hasPrevious())
//				iterator.previous();//可以向前遍历
			int i=iterator.next();
			System.out.println(i);//遍历中并不会显示添加元素
			if(i==3)
			iterator.add(3);//可以向集合添加，不会发生并发错误
			
		}
		System.out.println(list);//迭代遍历后list会发生变化
	}

LinkedList集合

模拟队列，堆栈，链表的形式，她又很多类似于堆栈等的操作，例如push(),pollFirst()等等！！注意：不是线程安全的

Vector集合

！！线程安全，同步的

！！！他的操作方法是synchronized的。

同步的体现：由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration 不是快速失败的。

换句话说，迭代器遍历时不可操作集合，而Enumeration elements()可以操作

public static void main(String[] args) {
		
	Vector<String>v=new Vector<>();
	v.add("xiaoming");
	v.add("xiaoli");
	v.add("xiaohua");
	Enumeration<String> em=v.elements();
	while(em.hasMoreElements())
	{
		String e=em.nextElement();
		if(e.equals("xiaoli"))
			v.add("xiaoli2");//在这个遍历中，这种做法是成功的，并且我们会访问到"xiaoli2"
		System.out.println(e);
		/*
		 * xiaoming
		 * xiaoli
         * xiaohua
         * xiaoli2
		 */
	}
	Iterator<String> iter=v.iterator();
	while(iter.hasNext())
	{
		String e=iter.next();
		if(e.equals("xiaoli"))
			v.add("xiaoli2");//在这个遍历中，这种做法是不成功的"
		System.out.println(e);
		/*
		 * Exception in thread "main" java.util.ConcurrentModificationException
		 *at java.util.Vector$Itr.checkForComodification(Unknown Source)
	     *at java.util.Vector$Itr.next(Unknown Source)
	     *at CollectionDemo.Collectiondemo.main(Collectiondemo.java:39)
		 */
	}
}

Set无序，不可以重复，最多允许一个空值元素,不是线程安全的

public static void main(String[] args) {				
		Set<String>set=new HashSet<>();
		set.add("c++");
		set.add("java");
		set.add("c#");
		set.add("c++");
		set.add(null);
		set.add(null);
		System.out.println(set);
		//[c#, null, c++, java]
        //无序，不可重复，最多一个空值
	}

set添加元素时，会调用元素的equals()和hash()判断地址是否相等，所以要注意重写元素的equals()，hash()的方法

LinkedList的方法摘要

方法摘要

boolean add(E e)
将指定元素添加到此列表的结尾。

void add(int index, E element)
在此列表中指定的位置插入指定的元素。

boolean addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

boolean addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素从指定位置开始插入此列表。

void addFirst(E e)
将指定元素插入此列表的开头。

void addLast(E e)
将指定元素添加到此列表的结尾。

void clear()
从此列表中移除所有元素。

Object clone()
返回此 LinkedList 的浅表副本。

boolean contains(Object o)
如果此列表包含指定元素，则返回 true。

Iterator<E> descendingIterator()
返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。

E element()
获取但不移除此列表的头（第一个元素）。

E get(int index)
返回此列表中指定位置处的元素。

E getFirst()
返回此列表的第一个元素。

E getLast()
返回此列表的最后一个元素。

int indexOf(Object o)
返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

ListIterator<E> listIterator(int index)
返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

boolean offer(E e)
将指定元素添加到此列表的末尾（最后一个元素）。

boolean offerFirst(E e)
在此列表的开头插入指定的元素。

boolean offerLast(E e)
在此列表末尾插入指定的元素。

E peek()
获取但不移除此列表的头（第一个元素）。

E peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

E peekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

E poll()
获取并移除此列表的头（第一个元素）

E pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

E pollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

E pop()
从此列表所表示的堆栈处弹出一个元素。

void push(E e)
将元素推入此列表所表示的堆栈。

E remove()
获取并移除此列表的头（第一个元素）。

E remove(int index)
移除此列表中指定位置处的元素。

boolean remove(Object o)
从此列表中移除首次出现的指定元素（如果存在）。

E removeFirst()
移除并返回此列表的第一个元素。

boolean removeFirstOccurrence(Object o)
从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。

E removeLast()
移除并返回此列表的最后一个元素。

boolean removeLastOccurrence(Object o)
从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

E set(int index, E element)
将此列表中指定位置的元素替换为指定的元素。

int size()
返回此列表的元素数。

Object[] toArray()
返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。

<T> T[]

toArray(T[] a)
返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回

ArrayList方法摘要

boolean add(E e)
向列表的尾部添加指定的元素（可选操作）。

void add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。

boolean addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。

boolean addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

void clear()
从列表中移除所有元素（可选操作）。

boolean contains(Object o)
如果列表包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素，则返回 true。

boolean equals(Object o)
比较指定的对象与列表是否相等。

E get(int index)
返回列表中指定位置的元素。

int hashCode()
返回列表的哈希码值。

int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

boolean isEmpty()
如果列表不包含元素，则返回 true。

Iterator<E> iterator()
返回按适当顺序在列表的元素上进行迭代的迭代器。

int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

ListIterator<E> listIterator()
返回此列表元素的列表迭代器（按适当顺序）。

ListIterator<E> listIterator(int index)
返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。

E remove(int index)
移除列表中指定位置的元素（可选操作）。

boolean remove(Object o)
从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。

boolean removeAll(Collection<?> c)
从列表中移除指定 collection 中包含的其所有元素（可选操作）。

boolean retainAll(Collection<?> c)
仅在列表中保留指定 collection 中所包含的元素（可选操作）。

E set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。

int size()
返回列表中的元素数。

List<E> subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。

Object[] toArray()
返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。