本文总结容器（Collection）（包括List、Set、Queue、Map）的常用方法和特点。

一、Collection

package com.wllfengshu.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

import org.junit.Test;

/**
 * 测试Collection
 * @author Administrator
 *
 */
public class Test1Collection {
	//Collection是List、Set、Queue的根接口
	//测试Collection常用方法
	@Test
	public void test1(){
		Collection<String> a=new ArrayList<String>();
		a.add("A");//添加元素
		String[] bArr={"B","C","D"};
		a.addAll(Arrays.asList(bArr));//把参数中所有元素添加
		System.out.println(a);
		a.clear();
		System.out.println(a);
		a.add("E");
		System.out.println(a.contains("E"));//判断是否包含参数对象
		System.out.println(a.isEmpty());//判断是否空
		a.addAll(Arrays.asList(bArr));
		a.remove("C");//若参数对象存在，则删除
		System.out.println(a);
		System.out.println(a.size());//元素数目
		System.out.println(a.toString());
		System.out.println(a.toArray());
	}
	//Collection遍历：数组遍历法
	@Test
	public void test2(){
		String[] aStr={"A","B","C","D"};
		Collection<String> b=new ArrayList<String>();
		b.addAll(Arrays.asList(aStr));
		Object[] bStr=b.toArray();
		for (Object s : bStr) {
			System.out.println(s);
		}
	}
	//Collection遍历：Iterator遍历法
	@Test
	public void test3(){
		String[] aStr={"A","B","C","D"};
		Collection<String> b=new ArrayList<String>();
		b.addAll(Arrays.asList(aStr));
		Iterator<String> iterator = b.iterator();
		while (iterator.hasNext()) {
			String temp=iterator.next();
			System.out.println(temp);
		}
	}
}

二、Set

package com.wllfengshu.test;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

/**
 * 测试 集合Set
 * @author Administrator
 * HashSet和TreeSet
 */
public class Test2Set {
	//Set不接受重复元素
	//测试HashSet
	@Test
	public void test1(){
		A a=new A("abc");
		A b=new A("abc");
		A c=a;
		Set<A> set=new HashSet<A>();
		set.add(a);
		set.add(b);
		set.add(c);//由于a和c都指向同一个引用，故是相同元素
		System.out.println(set.toString());
		//总结：Set通过对象的哈希值是否相同来判断
	}
	//测试TreeSet 用来排序
	@Test
	public void test2(){
		//测试自然排序(必须使用实现了Comparable接口)
		Set<String> aa=new TreeSet<String>();
		aa.add("A");
		aa.add("B");
		System.out.println(aa);
		
//		A aClass1=new A("123");
//		A aClass2=new A("456");
//		Set<A> a=new TreeSet<A>();
//		a.add(aClass1);
//		a.add(aClass2);//错误：必须使用实现了Comparable接口
		
		B bClass1=new B("123");
		B bClass2=new B("456");
		Set<B> b=new TreeSet<B>();
		b.add(bClass1);
		b.add(bClass2);
		System.out.println(b);
		
		//指定排序(必须使用实现了Comparator接口)
		A aClass1=new A("123");
		A aClass2=new A("456");
		Set<A> c=new TreeSet<A>(new C());//这里的C类实现了Comparator接口，来指定排序规则
		c.add(aClass1);
		c.add(aClass2);
		System.out.println(c);
	}
}
class A{
	private String name;
	public A(String name){
		this.name=name;
	}
}
class B implements Comparable{
	private String name;
	public B(String name){
		this.name=name;
	}
	@Override
	public int compareTo(Object o) {
		return 0;
	}
}
class C implements Comparator<A>{
	@Override
	public int compare(A o1, A o2) {
		//这里指定排序规则
		return 0;
	}
}

三、List

package com.wllfengshu.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import org.junit.Test;

/**
 * 测试List
 * @author Administrator
 * 列表
 */
public class Test3List {
	//允许放相同的元素,相当于数据结构中的线性表
	//测试ArrayList   相当于单向链表
	@Test
	public void test1(){
		List<String> list=new ArrayList<String>();
		list.add("A");//添加元素
		list.add("B");
		System.out.println(list.toString());
		boolean contains = list.contains("D");//是否包含元素D
		System.out.println(contains);
		int indexOf = list.indexOf("D");
		System.out.println(indexOf);//返回元素第一次的索引
		list.remove(1);//按照索引删除元素
		System.out.println(list);
		list.add(new String("E"));
		list.add("C");
		Collections.sort(list);//排序
		System.out.println(list);
		list.add(1, "P");//指定位置插入
		System.out.println(list);
		//总结：ArrayList可进行快速访问，但是插入和删除数据较慢，线程不安全
	}
	//测试LinkedList  相当于双向链表  
	@Test
	public void test2(){
		LinkedList<String> linkedList=new LinkedList<String>();
		linkedList.add("A");
		linkedList.add("B");
		linkedList.add("C");
		System.out.println(linkedList.getFirst());//取第一个元素
		linkedList.addFirst("P");//在栈头添加
		System.out.println(linkedList);
		linkedList.poll();//在栈头做出栈
		System.out.println(linkedList);
		String peek = linkedList.peek();//读栈顶元素
		System.out.println(peek);
		linkedList.push("G");//在栈头做入栈
		System.out.println(linkedList);
		//总结：LinkedList可作为栈   先进后出   只能在栈头进行操作
	}
}

四、Queue

package com.wllfengshu.test;

import java.util.LinkedList;
import java.util.Queue;

import org.junit.Test;

/**
 * 测试Queue
 * @author Administrator
 * 队列
 */
public class Test4Queue {
	//测试单向队列 先进先出，从一端进，另一端出
	 @Test
	 public void test1(){
		 Queue<String> queue=new LinkedList<String>();
		 queue.add("A");
		 queue.add("B");
		 queue.add("C");
		 System.out.println(queue.peek());//读队首   不删除首元素
		 System.out.println(queue);
		 System.out.println(queue.poll());//读队首  删除首元素
		 System.out.println(queue);
		 System.out.println(queue.offer("D"));//在队尾插一个元素
		 System.out.println(queue);
	 }
	 //测试双向队列
	 @Test
	 public void test2(){
		 LinkedList<String> queue=new LinkedList<String>();
		 queue.add("A");
		 queue.add("B");
		 queue.add("C");
		 queue.addFirst("O");//在队头插入
		 queue.addLast("D");//在队尾插入
		 queue.getFirst();//取队头
		 queue.getLast();//取队尾
		 queue.removeFirst();//删去队头，并返回队头
		 queue.removeLast();//删去队尾，并返回队尾
	 }
}

五、Map

package com.wllfengshu.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

import org.junit.Test;

/**
 * 测试Map
 * @author Administrator
 * 映射
 */
public class Test5Map {
	//Map是 键-值形式的映射
	//测试HashMap
	@Test
	public void test1(){
		Map<String,Integer> map=new HashMap<String,Integer>();
		map.put("A", 1);
		map.put("B", 2);
		boolean containsKey = map.containsKey("C");//是否包含指定的key
		System.out.println(containsKey);
		boolean containsValue = map.containsValue(2);
		System.out.println(containsValue);//是否包含指定的value
		for(String key:map.keySet()){
			System.out.println(key+" "+map.get(key));
		}
	}
	//测试TreeMap
	@Test
	public void test2(){
		TreeMap<String,Integer> map=new TreeMap<String,Integer>();
		map.put("A", 1);
		map.put("B", 2);
		map.put("C", 2);
		map.put("D", 2);
		String firstKey = map.firstKey();
		System.out.println(firstKey);//返回第一个键
		SortedMap<String, Integer> subMap = map.subMap("A", "C");
		System.out.println(subMap);//返回有map键范围内生成的子集
	}
}