java算法常用的容器

容器不需要定义大小，会自动扩容

四个基本容器

基本的容器有四个，分别对应四个接口：

List：按照插入的顺序保存元素，可以有重复的元素。
Set：不可以有重复的元素，可以理解为哈希表。
Queue：按照队列规则先进先出。
Map：将两个元素相关联，可以用键来查找值。

其中List、Set、Queue这三个接口继承了Collection接口。

Map则是自成一家，没有继承别人。

各接口的常用实现类

List：ArrayList、LinkedList
Set：HashSet、TreeSet、LinkedHashSet
Map：HashMap、TreeMap、LinkedHashMap
Queue：PriorityQueue、LinkedList

ArrayList和LinkedList这两个是实现类，实现了List接口，这两个类可能会增加一些接口没有的新方法（刷题时一般用不到）。

同理、Set、Queue、Map的实现类也一样。

注意：

如果需要用到一个List容器可以像下面这样子定义

ArrayList<Integer> list = new ArrayList<>();
LinkedList<Integer> list = new LinkedList<>();

List<Integer> list = new ArrayList<>();//接口实现的对象方法少一点
ArrayList<Integer> list = new ArrayList<>()//类实现的对象多一点

Set和Map和Queue的定义也和list一样。

List接口的实现类有ArrayList、LinkedList

ArrayList：底层使用数组实现的，查找快，插入数据和删除数据慢（常用）
LinkedList：底层使用链表实现的，查找慢，插入数据和删除数据快(常用)

创建一个List容器

List<Integer> list = new ArrayList<>()；
ArrayList<Character> hui=new ArrayList<>();

 ArrayList<String> ans=new ArrayList<>();
 ans.add("qiao ben zhong.\n");//可以实现加入回车
 
 ArrayList[] arrayList = new ArrayList[n];
 //每一个一维数组都要实例化
 for(int i=0;i<n;i++)
		{
			a[i]=new ArrayList<>();
		}
 for (int j = 0; j < arrayList[i].size(); j++) 

List(可用arraylist也可以用linkedlist)常用方法有

arrayList[i].get(j)//二维数组
list.add(int element)//添加元素（常用）
list.get(int index)//根据索引查找元素
list.size()//反回元素的数量（常用）
list.isEmpty()//判断是否为空（常用）
list.remove()//根据下标删除元素
list.clear();//清空元素

模拟栈：

		LinkedList<Integer> a=new LinkedList<>();
		a.add(12);a.add(13);a.add(133);a.add(21);
		int z=a.get(a.size()-1);//返回栈顶元素
		a.remove(a.size()-1);//清除栈顶元素
		System.out.println(a);

模拟队列：

		LinkedList<Integer> b=new LinkedList<>();//队列
		b.add(1);b.add(3);b.add(12);
		int x=b.poll();//返回队首元素，删除队首元素
		int y=b.peek();//返回队首元素
		b.removeFirst();//直接删除队首元素
		System.out.println(b);

创建一个Set容器

Set接口实现类有
HashSet:使用散列函数查找快速（也就是常说的哈希查找）(常用)
TreeSet:排序默认从小到大
LinkedHashSet：使用链表维护元素的插入顺序
Set set = new HashSet<>()；

Set常用方法有

set.add()//添加元素
set.remove(Object o)//删除一个对象的引用
set.clear()//清空容器
set.isEmpty()//判断容器是否为空
set.contains(Object o)//判断容器是否包含o(常用)
set.size()//返回容器中元素的数目

创建一个Map容器

Map接口实现类有
HashMap：用于快速访问,常用与哈希有关的(常用)
TreeMap：键处于排序状态
LinkedHashMap：保持元素插入的顺序

Map<String,Integer> map = new HashMap<>()；

Map常用方法有
map.put()//添加键值对
map.get()//取数据
map.remove(Object key)//删除键值对
map.remove(Object key,Object value)//删除键值对
map.size()//返回元素的数量
map.clear()//清空容器
map.isEmpty()//判断容器是否为空
map.containsKey()//判断容器是否包含某键
map.containsValue()//判断容器是否包含某值
```java

Queue接口实现类

PriorityQueue:优先队列(常用)
LinkedList:普通队列(常用)

有些人可能有疑问
怎么Queue还和LinkedList联系起来了，其实Queue的添加队尾和删除队头不就是相等于插入链表的尾结点，和删除链表的头结点吗，所以说不需要在定义一个Queue的实现类了。

Queue常用方法有
offer()添加元素（常用）
peek()返回第一个元素（常用）
poll()返回第一个元素并删除（常用）
add()添加元素
element()返回第一个元素
remove()返回第一个元素并删除
put()添加元素
take()返回第一个元素并删除

使用迭代器：
方法：
it.hasnext()是否有下一个结点（
temp.contains(obj)某temp容器是否包含obj

Iterator it=list.iterator();
while(it.hasNext())
{
		Object obj=it.next();//会自动迭代到下一个结点）
		if(!temp.contains(obj)) temp.add(obj);	
	}

其他技巧

复制容器：

方法1：

这个方法有缺点，当原容器变化时，c也会变化

LinkedList<Integer> a=new LinkedList<>();
LinkedList< Integer> c=a;

方法2：

最常用的，不会改变容器的方法

LinkedList< Integer> c=new LinkedList<>();
c.addAll(a);
System.out.println(c);