java.util包中提供了一些集合类，这些集合类又被称为容器。集合类与数组的不同之处是，数组的长度是固定的，集合的长度是可变的；数组用来存放基本类型的数据，集合用来存放对象的引用。常用的集合有List集合和Map集合，其中List与Set继承了Collection接口，各接口还提供了不同的实现类。上述集合类的继承关系如图所示:
List、Set、Map区别
List(有序，可重复):List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据移动，所以插入删除数据慢。
Set(无序，不能重复):Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。
Map(键值对，键唯一，值不唯一):Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对Map集合，遍历的先得到键的Set集合，对Set集合进行遍历得到相应的值。
Collection接口
collection接口是层次结构中的根接口。构成Collection的单位称为元素。Collection接口通常不直接使用，但该接口提供了添加元素、删除元素、管理数据的方法。由于List接口与Set接口都继承了Collection接口，因此这些方法对于List集合和Set集合都是通用的，如下表所示:
| 方法 | 功能描述 |
|---|---|
| add(E e) | 将指定的对象添加到集合中 |
| remove(Object o) | 将指定的对象从该集合中移除 |
| isEmpty() | 返回boolean值，用于判断当前集合是否为空 |
| iterator() | 返回在此Collection的元素上进行迭代的迭代器。用于遍历集合中的对象 |
| size() | 返回int型值，获取该集合中元素的个数 |
集合是通过迭代器进行遍历，如下所示:
package set;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest {
/**
* @param args
*/
public static void main(String[] args) {
Collection<String> list=new ArrayList<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。
List集合
List集合包括List接口以及List接口的所有实现类。List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。类似Java数组，用户可通过使用索引（元素在集合中的位置）来访问集合中的元素。
List接口
List接口继承了Collection接口，因此包含Collection中的所有方法。此外，List接口还定义了以下两个重要的方法:
get(int index):获得指定索引位置的元素。
set(int index,Object obj):将集合中指定索引位置的对象修改为指定的对象。
List接口的常用的两个实现类有ArrayList与LinkedList。
区别
ArrayList类实现了可变的数组。允许保存所有的元素，包括null，并可以根据索引位置对集合进行快速的随机访问；缺点是向指定的索引位置插入对象或删除对象的速度较慢。
LinkedList类采用链表结构保存对象。这种结构的优点便是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List集合的效率较高；但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低。
下面用代码实现:
package set;
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 i = (int) (Math.random() * list.size()); // 获得0~2之间的随机数
System.out.println("随机获得数组中的元素:" + list.get(i));
list.remove(2); // 移除数组中第三个元素
for (int j = 0; j < list.size(); j++) { // 循环遍历集合
System.out.println(list.get(i));
}
}
}
运行结果如下所示:
Set集合
Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但Set集合中不能包含重复对象。Set集合由Set接口的实现类组成。Set接口继承了Collection接口，所以包含了Collection的所有方法。（Set允许包含空值，但最多只能有一个空值）
Set接口常用的实现类有HashSet类与TreeSet类。
HashSet类实现Set接口，由哈希表支持。它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用null元素。
Treeset类不仅实现了Set接口，还实现了java.util.SortedSet接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较器递增排序，即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。TreeSet类新增的方法如下表所示:
| 方法 | 功能描述 |
| first() | 返回此Set中当前第一个元素(最低元素) |
| last() | 返回此Set中当前最后一个（最高）元素 |
| comparator() | 返回对此Set中的元素进行排序的比较器，如果此Set是自然顺序，则返回null |
| headSet(E toElement) | 返回一个新的Set集合，新集合是toElement(不包含)之前的所有对象 |
| subSet(E fromElement,E fromElement) | 返回一个新的Set集合，是fromElement（包含）对象与fromElement(不包含）对象之前的所有对象 |
| tailSet(E fromElement) | 返回一个新的Set集合，新集合包含对象fromElement(包含)之后的所有对象 |
下面代码实现:
package set;
import java.util.Iterator;
import java.util.TreeSet;
public class UpdateStu implements Comparable<Object> { // 创建类实现Comparable接口
String name;
long id;
public UpdateStu(String name, long id) { // 构造方法
this.id = id;
this.name = name;
}
@Override
public int compareTo(Object o) {
UpdateStu upstu = (UpdateStu) o;
int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);// 三目运算符就是用自己的id和传入对象的id最比较如果自己的id大于upstu的id，那么值为1，否则再判断是否相等，如果相等则为0，不相等则为1
return result;
}
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;
}
public static void main(String[] args) {
UpdateStu stu1 = new UpdateStu("张三", 001);
UpdateStu stu2 = new UpdateStu("李四", 002);
UpdateStu stu3 = new UpdateStu("王五", 003);
UpdateStu stu4 = new UpdateStu("马六", 004);
TreeSet<UpdateStu> tree = new TreeSet<UpdateStu>(); // 创建集合把UpdateStu放在集合中
tree.add(stu1);
tree.add(stu2);
tree.add(stu3);
tree.add(stu4);
Iterator<UpdateStu> it = tree.iterator(); // Set集合中的所有对象的代码
System.out.println("Set集合中的所有元素:"); // 创建迭代器遍历集合
while (it.hasNext()) {
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + "" + stu.getName());
}
it = tree.headSet(stu2).iterator(); // 截取排在stu2对象之前的对象
System.out.println("截取前面部分的集合:");
while (it.hasNext()) {
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + "" + stu.getName());
}
it = tree.subSet(stu2, stu3).iterator();// 截取排在stu2和stu3之间的对象
System.out.println("截取中间部分的集合");
while (it.hasNext()) { // 遍历集合
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + "" + stu.getName());
}
}
}
运行结果如下所示:
存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的CompareTo(Object o)方法比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、0、正整数。
Map集合
Map集合没有继承Collection接口，其提供的是Key到Value的映射。Map中不能包含相同的Key，每个key只能映射一个value。key还决定了存储对象在映射中的存储位置，但便是由key对象本身决定的，而是采用直接寻址技术。
Map接口
Map接口提供了将Key映射到值的对象。一个映射不能包含重复的Key，每个Key最多只能映射一个值。Map接口中同样提供了集合的常用方法，除此之外还包括如下表所示的方法:
| 方法 | 功能描述 |
| put(K key,V value) | 向集合中添加指定的key与value的映射关系 |
| containsKey(Object key) | 如果此映射包含指定key的映射关系，则返回true |
| containsValue(Object value) | 如果此映射将一个或多个Key映射到指定值，则返回true |
| get(Object key) | 如果存在指定的key对象，则返回该对象对应的值，否则返回null。 |
| keySet() | 返回该集合中的所有key对象形成的Set集合 |
| values() | 返回该集合中所有值形成的Collection集合 |
代码如下所示:
package set;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class UpdateStuTest {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>(); // 创建Map对象
map.put("01", "李同学");
map.put("02", "张同学");
Set<String> set = map.keySet(); // 构建Map集合中所有key对象的集合
Iterator<String> it = set.iterator(); // 创建集合迭代器
System.out.println("key集合中的元素:");
while (it.hasNext()) {
System.out.println(it.next());
}
Collection<String> collection=map.values(); //构建Map集合中所有values值的集合
it=collection.iterator();
System.out.println("values集合中的元素:");
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果如下所示:
Map集合中允许值对象是null，而且没有个数限制。例如，可通过"map.put("05",null);"语句向集合中添加对象。
Map集合的实现类
Map接口常用的实现类有HashMap和TreeMap。建议使用HashMap类实现Map集合，因为由HashMap类实现的Map集合添加和删除映射关系效率更高。HashMap是基于哈希表的Map接口的实现，HashMap通过哈希码对其内部的映射关系进行快速查找；而TreeMap中的映射关系存在一定的顺序，如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合。
HashMap类是基于哈希表的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性。HashMap通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
TreeMap类不仅实现了Map接口，还实现了java.util.SortedMap接口，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时，TreeMap类比HashMap类性能稍差。由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null。
代码如下所示:
package set;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class Emp {
private String e_id;
private String e_name;
public Emp(String e_id, String e_name) {
this.e_id = e_id;
this.e_name = e_name;
}
public String getE_id() {
return e_id;
}
public void setE_id(String eId) {
e_id = eId;
}
public String getE_name() {
return e_name;
}
public void setE_name(String eName) {
e_name = eName;
}
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>(); // 由HashMap实现的Map对象
Emp emp = new Emp("351", "张三"); // 创建Emp对象
Emp emp2 = new Emp("512", "李四");
Emp emp3 = new Emp("853", "王一");
Emp emp4 = new Emp("125", "赵六");
Emp emp5 = new Emp("341", "黄七");
map.put(emp4.getE_id(), emp4.getE_name()); // 将emp对象放在map集合中
map.put(emp5.getE_id(), emp5.getE_name());
map.put(emp.getE_id(), emp.getE_name());
map.put(emp2.getE_id(), emp2.getE_name());
map.put(emp3.getE_id(), emp3.getE_name());
Set<String> set = map.keySet(); // 获取Map集合中的Key对象集合放入set集合中
Iterator<String> it = set.iterator();
System.out.println("HashMap类实现的Map集合，无序:");
while (it.hasNext()) {
String str = (String) it.next(); // 遍历Map集合
String name = (String) map.get(str);
System.out.println(str + "" + name);
}
TreeMap<String, String> treemap = new TreeMap<String, String>(); // 创建TreeMap集合对象
treemap.putAll(map); // 向集合中添加对象
Iterator<String> iter = treemap.keySet().iterator();
System.out.println("TreeMap类实现的Map集合，键对象升序:");
while (iter.hasNext()) { // 遍历TreeMap集合对象
String str = (String) iter.next(); // 获取集合中的所有key对象
String name = (String) treemap.get(str); // 获取集合中的所有values值
System.out.println(str + " " + name);
}
}
}
运行结果如下所示:
