具体的关于ArrayList等实现类的介绍有时间再专门写篇文章，这里只是作简单介绍
集合类概述
集合类又被称为容器，和数组类似都能够存储一定的数据，但是又不一样。
常用的集合有List、Set、Map。其中接口List和Set继承了Collection接口，各接口还提供了不同的实现类。
在说常见集合之前，先提一下Collection类。Collection类是层次结构中的根接口。构成Collection的单位称为元素。所有实现Collection接口的类都必须供给两个标准的机关函数：无参数的机关函数用于创建一个空的Collection，有一个Collection参数的机关函数用于创建一个新的Collection，这个新的Collection与传入的Collection有雷同的元素。后一个机关函数容许用户复制一个Collection。下面介绍一下该类提供的方法：
内容摘自Java API手册
其中常用的是add()、remove()、isEmpty()、iterator()、size()。
在对集合中的数据进行遍历时，经常要用到迭代器（Iterator）来获取集合的迭代器，所以这里也对迭代器进行一下简单的介绍：
迭代器（Iterator）
Iterator是一个用于遍历集合中元素的接口，所有的集合类，都实现了Iterator接口。
下面是Java API手册中迭代器类的方法：
举个例子：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo {
public static void main(String[] args) {
Collection<String> list=new ArrayList<String>(); //初始化元素类型为String的容器
list.add("a"); //向集合中添加元素
list.add("b");
list.add("c");
Iterator<String> it=list.iterator(); //返回迭代器的值
while(it.hasNext()){ //判断存在 下一个数值
String str=(String)it.next(); //返回迭代器的下一个元素
System.out.println(str);
}
}
}输出结果为：
a
b
c这里需要提醒一下，Iterator的next()方法返回的是Object，所以要对其进行强制转换为String类。
List集合
List集合继承了Collection类，集合中的元素允许重复，各元素的顺序就是对象的插入顺序，除了迭代器之外，List和数组类似，能够通过索引（元素在集合中的位置编号，从0开始）来访问集合中的元素。
List接口 继承了Collection的同时还定义了新的方法：
下面是API手册中的List接口的方法：
其中常用的主要是以下两个：
get(int index); 获得指定索引位置的元素，实现了按索引查找的功能。
set(int index,Object obj); 将索引指定位置的元素修改为指定对象。
List接口的实现类：
1. ArrayList类（动态数组）：允许保存所有元素（包括null），非线程安全，插入数据有序，查找元素速度快，但由于插入数据涉及到元素移动等内存操作，所以对增删操作速度较慢。ArrayList类采用数组体式格式存储数据，数组元素数大于实际存储的数据以便增长和插入元素。
2. LinkedList类：采用链表结构保存对象，便于增删对象，查找对象慢。
代码示例：
import java.util.ArrayList;
import java.util.List;
public class Gather {
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
int m=(int)(Math.random()*list.size());
System.out.println("随机数对应的元素值为："+list.get(m));
list.remove(2); //索引值是从0开始的，即2对应的索引值为“c”
list.remove("b");
System.out.println("删除索引是‘2’的元素后和值为“c”的元素之后，数组遍历结果为：");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}输出结果为：
随机数对应的元素值为：c
删除索引是‘2’的元素后和值为“c”的元素之后，数组遍历结果为：
aSet集合
相对于List集合，Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但Set集合中不能包含重复对象，同样，Set继承于Collection类。
Set常见实现类：
- HashSet类
由哈希表（HashMap实例）支持。不保证Set的迭代顺序，特别是它不能保证该顺序恒久不变，允许使用null元素。 - TreeSet类
不仅实现了Set接口，还实现了java.util.SortedSet接口，因此TreeSet类实现Set集合在遍历集合时按照自然顺序递增排序，也可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。
（还有一个AbstractMap类用的少，如果以后接触了再补上来）
对于TreeSet中的在遍历集合时按照自然顺序递增排序，但也不允许元素重复，参考
Comparable接口：
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。 compareTo()方法用于比较此对象与指定对象的顺序。
下面是TreeSet的代码示例：
import java.util.Iterator;
import java.util.TreeSet;
public class UpdateStu implements Comparable<Object> {
String name;
long id;
public UpdateStu(String name,long id){
this.id=id;
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
UpdateStu upstu=(UpdateStu)o;
int result=id>upstu.id?1:(id==upstu.id?0:-1); //比较当前类和传入的类的id大小，如果根据比值的情况，分别返回1，0，-1
return result;
}
public static void main(String[] args) {
UpdateStu stu1=new UpdateStu("李同学",00101);
UpdateStu stu2=new UpdateStu("张同学",00102);
UpdateStu stu3=new UpdateStu("刘同学",00103);
UpdateStu stu4=new UpdateStu("王同学",00104);
TreeSet<UpdateStu> tset=new TreeSet<UpdateStu>();
tset.add(stu3);
tset.add(stu2);
tset.add(stu1);
tset.add(stu4);
Iterator<UpdateStu> iter=tset.iterator();
System.out.println("遍历tset集合中的元素");
while(iter.hasNext()){
UpdateStu stu=(UpdateStu)iter.next(); //next()方法返回的是Object，所以要对其进行类型转换
System.out.println(stu.getI d()+" "+stu.getName());
}
iter=tset.headSet(stu3).iterator();
System.out.println("截取stu3前面的部分集合");
while(iter.hasNext()){
UpdateStu stu=(UpdateStu)iter.next();
System.out.println(stu.getId()+" "+stu.getName());
}
iter=tset.subSet(stu1, stu3).iterator();
System.out.println("截取stu1和stu3中间部分的集合");
while(iter.hasNext()){
UpdateStu stu=(UpdateStu)iter.next();
System.out.println(stu.getId()+" "+stu.getName());
}
iter=tset.tailSet(stu2).iterator();
System.out.println("截取stu2之后的集合");
while(iter.hasNext()){
UpdateStu stu=(UpdateStu)iter.next(); //定义一个局部的UpdateStu变量，便于下行的数据输出
System.out.println(stu.getId()+" "+stu.getName());
}
}
}代码说明：存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo(Object o)方法比较此对象与指定对象的顺序。
Map集合
Map集合并非继承Collection接口，其提供的是key到value的映射一个value可以被多个key映射，但是key只能指向一个value，且key值不能相同。
下面是Map的常用方法：
| 方法名 | 作用 |
|---|---|
| put(K key,V value) | 向集合中添加指定的key和value的映射关系 |
| containsKey(Object key) | 如果此映射中包含指定key的映射关系，则返回true |
| containsValue(Object value) | 如果此映射将一个或多个key映射到指定的value，返回true |
| get(Object key) | 如果存在指定的key，则返回该对象对应的值，否则返回null |
| keySet() | 返回该集合中的所有key对象形成的Set集合 |
| values() | 返回该对象中所有值对象形成的Collection集合 |
代码示例：
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class UpStu {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put("01","李同学");
map.put("02", "张同学");
map.put("03", "王同学");
System.out.println("查找是否有编号为02的同学："+map.containsKey("02"));
System.out.println("查找是否有王同学："+map.containsValue("王同学"));
Set<String> set=map.keySet(); //获取key的集合
Collection<String> coll=map.values(); //获取values的集合
Iterator<String> siter=set.iterator();
Iterator<String> citer=coll.iterator();
System.out.println("key集合中的元素：");
while(siter.hasNext()){
String str=(String) siter.next();
System.out.println(str);
}
System.out.println("values集合中的元素：");
while(citer.hasNext()){
String str=(String)citer.next();
System.out.println(str);
}
}
}result:
查找是否有编号为02的同学：true
查找是否有王同学：true
key集合中的元素：
01
02
03
values集合中的元素：
李同学
张同学
王同学Map集合中是允许对象是null的，而且没有个数限制。
Map接口的实现类
HaspMap：建议使用HashMap集合实现Map集合，因为该类实现的Map集合添加和删除映射关系效率更高。该类是基于哈希表的Map接口的实现，通过哈希码对其内部的映射关系进行快速查找，允许使用null值和null键，但是必须保证唯一性。
TreeMap：TreeMap类实现的Map集合存在一定的顺序，当需要有序的Map集合时，可以考虑TreeMap，不允许键值为null。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
class Emp{
private String name;
private String id;
public Emp(String id,String name){
this.id=id;
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
public class MapText {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
Emp emp1=new Emp("001","张三");
Emp emp2=new Emp("002","李四");
Emp emp3=new Emp("003","王一");
Emp emp4=new Emp("004","赵六");
Emp emp5=new Emp("005","黄七");
Emp emp6=new Emp("006","牛二");
map.put(emp2.getId(), emp2.getName());
map.put(emp4.getId(), emp4.getName());
map.put(emp1.getId(), emp1.getName());
map.put(emp3.getId(), emp3.getName());
map.put(emp6.getId(), emp6.getName());
map.put(emp5.getId(), emp5.getName());
Set<String> set=map.keySet();
Iterator<String> siter=set.iterator();
System.out.println("HashMap类实现的Map集合，无序");
while(siter.hasNext()){
String key=(String)siter.next(); //获取下个迭代器的值，即key
String name=(String)map.get(key); //调用map.get()方法，根据映射，返回key对象对应的值
System.out.println(key+" "+name);
}
System.out.println("Treemap类实现的Map集合，有序");
TreeMap<String,String> treemap=new TreeMap<String,String>();
treemap.putAll(map); //将map对象中的所有值赋给treemap
Iterator<String> titer=treemap.keySet().iterator();
while(titer.hasNext()){
String key=(String)titer.next(); //获取下个迭代器的值，即key
String name=(String)map.get(key); //调用map.get()方法，根据映射，返回key对象对应的值
System.out.println(key+" "+name);
}
}
}
result:
查找是否有编号为02的同学：true
查找是否有王同学：true
key集合中的元素：
01
02
03
values集合中的元素：
李同学
张同学
王同学