本文主要记录Java容器相关的内容。
更多详细Java学习记录，请看我的另一篇文章：链接点我

1.容器关系图

如图所示：
Java容器关系图

2.Iterator迭代器

主要用于遍历Collection中的元素。由于Java没有指针，所以迭代器的使用相比C++更复杂一点。

2.1 常用方法

import java.util.Iterator;
public E next()：返回迭代的下一个元素。
public boolean hasNext()：如果仍有元素可以迭代，返回true。
public void remove()： 删除当前指针所指向的元素，一般和next方法一起用，这时候的作用就是删除next方法返回的元素。

2.2 使用实例

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class test 
{
    
    
	public static void main(String[] args)
	{
    
    
		Collection<Integer> t1 = new ArrayList<>();
		t1.add(1);
		t1.add(2);
		t1.add(3);
		t1.add(4);
		t1.add(5);
		//while循环遍历
		Iterator<Integer> iter1 = t1.iterator();
		while(iter1.hasNext())
		{
    
    
			int temp = iter1.next();
			System.out.println(temp);
		}
		//for循环遍历
		for(Iterator<Integer> iter2 = t1.iterator();iter2.hasNext();)
		{
    
    
			int temp = iter2.next();
			System.out.println(temp);
		}
	}
}

2.3 增强for循环

增强for循环，用来遍历集合和数组。
是JDK1.5之后出现的新特性，底层使用的也是迭代器，但是简化了使用方法。(不用导Iterator包)

格式：

for(集合/数组的数据类型 变量名 : 集合名/数组名)
{
    
    
	System.out.println(变量名);
}

实例：

import java.util.Collection;
import java.util.ArrayList;
public class test 
{
    
    
	public static void main(String[] args)
	{
    
    
		Collection<Integer> t1 = new ArrayList<>();
		t1.add(1);
		t1.add(2);
		t1.add(3);
		t1.add(4);
		t1.add(5);
		//增强for循环
		for(int i : t1)
		{
    
    
			System.out.println(i);
		}
	}
}

3.Collection（单列集合）

Collection是所有单列集合的父接口，其中定义了单列集合(List和Set)通用的一些方法，这些方法可以用于操作所有的单列集合。

import java.util.Collection;
public boolean add(E e)：把给定的对象添加到当前集合中。
public void clear()：清空集合中的所有元素。
public boolean remove(E e)：把给定的对象在当前集合中删除。
public boolean contains(E e)：判断当前集合中是否包含给定的对象。
public boolean isEmpty()：判断当前集合是否为空。
public int size()：返回集合中元素的个数。
public Object[] toarray()：把集合中的元素，储存到数组中。
public Iterator iterator()：获取集合所依赖的迭代器对象。

3.1 List（列表）

List接口为有序的集合，并且存在索引，包含了一些带索引的方法(特有)。List接口中允许存储重复的元素。

import java.util.List;
public void add(int index, E element)：将指定的元素，添加到该集合指定的位置上。
public E get(int index)：返回集合中指定位置的元素。
public E remove(int index)：移除列表中指定的元素，返回的为被移除的元素。
public E set(int index, E element)：用指定的元素替换集合中指定位置的元素，返回值为更新前的元素。

3.1.1 ArrayList

ArrayList储存结构为数组结构，通过List接口实现大小可变的数组。元素增删慢，查找快。
ArrayList的实现是多线程的，也就是实现不是同步的，效率高，但是存在线程安全问题。

import java.util.ArrayList;

3.1.2 LinkedList

LinkedList储存结构为链表结构，通过List接口实现双向链表。元素增删快，查找慢。
LinkedList提供了大量首尾操作的特有方法，跟C++的STL队列方法思路都差不多。

import java.util.LinkedList;
public void addFirst(E e)：将指定元素添加到列表的开头。
public void addLast(E e)：将指定元素添加到列表的结尾。
public E getFirst()：返回此列表的第一个元素。
public E getLast()：返回此列表的最后一个元素。
public E removeFirst()：移除并返回列表的第一个元素。
public E removeLast()：移除并返回列表的最后一个元素。
public E pop()：从此列表的堆栈处弹出一个元素。此处等效于removeFirst();
public void push(E e)：将元素推入列表的堆栈。此处等效于addFirst();
public boolean isEmpty()：如果列表不包含元素，返回true。

3.1.3 Vector

Vector储存结构为数组结构，通过List接口实现大小可变的数组。元素增删慢，查找快。
Vector的实现是单线程的，即实现是同步的，所以效率比ArrayList要低，但是不存在线程安全问题。

import java.util.Vector;

3.2 Set（集合）

Set接口与Collection接口中的方法基本一致，没有对Collection进行功能上的扩充，但是比Collection接口更加严格。
Set接口中元素无序，且都会以某种规则保证存入的元素不出现重复。也不能通过普通的for循环进行遍历。 (参考C++中的set即可)

import java.util.Set;

3.2.1 HashSet

底层为一个哈希表(数组加红黑树)，查询的速度非常快。且为一个无序的集合，存储和取出元素的顺序不一定一样。
在进行数据add存储时，首先使用hashCode()方法获取哈希值进行比较，如果无重复则直接填入。如果存在哈希冲突，则使用equals()方法进行判重，如果不存在重复则填入。

import java.util.HashSet;
在HashSet存储自定义类型元素时，需重写对象的hashCode方法和equals方法，建立自己的比较方式，从而保证集合中对象唯一。

3.2.2 LinkedHashSet

底层为一个哈希表+链表，多的这条链表用来记录元素的存储顺序，保证元素有序，即存储和取出元素的顺序一样。

import java.util.LinkedHashSet;

4.Map（双列集合/图）

Map为双列集合，一个元素里有两个值(key和value)。key不可重复，value可重复。

import java.util.Map;
public V put(K key, V value)：把指定的键与指定的值添加到Map集合中。
public V remove(Object key)：把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
public V get(Object key)：根据指定的键，在Map集合中获取对应的值。
boolean containsKey(Object key)：判断集合中是否包含指定的键。
public Set<K> keySet()：获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet()：获取到Map集合中所有的键值对对象的集合(Set集合)。

实例：

import java.util.Set;
import java.util.Map;
import java.util.HashMap;
public class test 
{
    
    
	public static void main(String[] args)
	{
    
    
		Integer temp;
		Map<String,Integer> map = new HashMap<>();
		//put添加元素 如果key不重复返回值为null;如果key重复,替换value,返回值是老value
		temp = map.put("张三", 18);//temp = null
		temp = map.put("张三", 19);//temp = 18
		System.out.println(temp);
		//remove删除元素 key存在,返回value值;key不存在,返回null
		map.put("李四", 20);
		temp = map.remove("李四");//temp = 20
		temp = map.remove("王五");//temp = null
		System.out.println(temp);
		//get获取元素 key存在,返回value值;key不存在,返回null
		temp = map.get("张三");//temp = 19
		temp = map.get("赵六");//temp = null
		System.out.println(temp);
		//containsKey通过key判断集合中是否包含指定元素 存在返回true
		boolean bool = map.containsKey("张三");//true
		bool = map.containsKey("赵六");//false
		System.out.println(bool);
		
		//keySet 获取一个set,其中储存了map的所有key值
		Set<String> set = map.keySet();
		for(String i : set)//随后就可以根据set使用增强for或者迭代器进行遍历
		{
    
    
			temp = map.get(i);
			System.out.println(i+" "+temp);
		}
		
		//entrySet 返回一个set,其中储存了map中的所有Entry对象
		Set<Map.Entry<String,Integer>> set1 = map.entrySet();
		for(Map.Entry<String,Integer> i : set1)//遍历set集合,获取每一个Entry对象
		{
    
    
			//通过Entry对象中的方法获取key和value
			String key = i.getKey();
			Integer value = i.getValue();
			System.out.println(key+" "+value);
		}
	}
}

4.1 HashMap

底层为哈希表(数组+链表/红黑树)，查询速度很快。且为一个无序的集合，存储和取出元素的顺序不一定一样。

import java.util.HashMap;
在HashMap存储自定义类型元素时，需重写key元素的hashCode方法和equals方法，从而保证key唯一。

4.2 LinkedHashMap

底层为哈希表+链表，多的这条链表用来记录元素的存储顺序，保证元素有序，即存储和取出元素的顺序一样。

import java.util.LinkedHashMap;

4.3 Hashtable

底层为哈希表，与HashMap基本一致。其与HashMap的关系，类似Vector与ArrayList的关系。

区别：

HashMap键值可以为null，但是Hashtable的键值都不能为空。
Hashtable为单线程，线程安全但是速度慢。

import java.util.Hashtable;

5.Collections集合工具类

import java.util.Collections;
public static <T> boolean addAll(Collection<T> c, T…elements)：往集合中添加一些元素。
public static void shuffle(List<?> list) ：打乱集合顺序。
public static <T> void sort(List<T> list)：将集合中元素按照默认规则排序。(默认为升序)
public static <T> void sort(List<T> list, Comparator<? super T> )：将集合中元素按照指定规则排序。