本文详细介绍了Java集合框架的构成，包括Collection、List、Set、Map等接口及其具体实现类，如ArrayList、LinkedList、HashMap等，并提供了多种遍历集合的方法及示例代码。
集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。
java的集合框架如下图所示：
从上面的图可以看出java集合类主要有以下几种：
- List线性表–结构的集合类：ArrayList类， LinkedList类， Vector类， Stack类
- Map图–结构的集合类：HashMap类， Hashtable类
- Set规则集–结构的集合类：HashSet类， TreeSet类
- Queue结构的集合类：Queue接口
Collection接口是集合层次中的根接口，JDK没有提供这个接口的实现类。由Collection接口派生的两个接口是List和Set， 其中
- Set:不能包含重复的元素，子接口SortedSet是一个按照升序排列的元素的Set。
- List:可以包含重复的元素，是一个有序的集合，提供了按索引访问的方式，有次序，位置不改变。
Collection接口
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后 一个构造函数允许用户复制一个Collection。
如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
Iterator it = collection.iterator(); // 获得一个迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}Collection接口常用的方法：
| boolean | add(E o) 确保此 collection 包含指定的元素（可选操作）。 |
|---|
| boolean | contains(Object o) 如果此 collection 包含指定的元素，则返回 true。 |
|---|
| boolean | remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 |
|---|
| int | size() 返回此 collection 中的元素数。 |
|---|
| Object[] | toArray() 返回包含此 collection 中所有元素的数组。 |
|---|
| Iterator | iterator() 返回在此 collection 的元素上进行迭代的迭代器。 |
|---|
List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。和下面要提到的Set不同，List允许有相同的元素。
除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。
java中对集合对象list的几种循环访问的总结如下
1 经典的for循环
public static void main(String[] args) {
List<String> list = new ArrayList();
list.add("123");
list.add("java");
list.add("j2ee");
System.out.println("==========经典的for循环=========");
for(int i=0; i<list.size();i++){
System.out.println(list.get(i));
}
}2 增强的for循环
public static void main(String[] args) {
List<String> list = new ArrayList();
list.add("123");
list.add("java");
list.add("j2ee");
System.out.println("=========Java1.6的for循环=======");
for(String s:list){
System.out.println(s);
}
}3 Iterate的使用
public static void main(String[] args) {
List<String> list = new ArrayList();
list.add("123");
list.add("java");
list.add("j2ee");
System.out.println("=========Iterate循环=======");
Iterator<String> iter = list.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
}实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。其中ArrayList：数组实现，查询快，增删慢，线程不安全，轻量级；LinkedList：链表实现，增删快，查询慢；Vector：数组实现，线程安全，重量级。
LinkedList类
LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
List list = Collections.synchronizedList(new LinkedList(...)); 下面分析一下应用LinkedList场景的代码：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
publicclass LinkedListTest {
publicstaticvoid main(String[] args) {
List<String> a=new ArrayList<String>();
a.add("a");
a.add("b");
a.add("c");
System.out.println(a);
List<String> b=new ArrayList<String>();
b.add("d");
b.add("e");
b.add("f");
b.add("g");
System.out.println(b);
//ListIterator在Iterator基础上添加了add(),previous()和hasPrevious()方法
ListIterator<String> aIter=a.listIterator();
//普通的Iterator只有三个方法，hasNext()，next()和remove()
Iterator<String> bIter=b.iterator();
//b归并入a当中，间隔交叉得插入b中的元素while(bIter.hasNext())
{
if(aIter.hasNext())
aIter.next();
aIter.add(bIter.next());
}
System.out.println(a);
//在b中每隔两个元素删除一个
bIter=b.iterator();
while(bIter.hasNext())
{
bIter.next();
if(bIter.hasNext())
{
bIter.next();//remove跟next是成对出现的，remove总是删除前序
bIter.remove();
}
}
System.out.println(b);
//删除a中所有的b中的元素
a.removeAll(b);
System.out.println(a);
}
}ArrayList类
ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并 没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
代码实例：ArrayListDemo
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
publicclass ArrayListDemo {
publicstaticvoid main(String[] args) {
List<String> arrList=new ArrayList<String>();
arrList.add("a");
arrList.add("b");
arrList.add("c");
arrList.add("c");
arrList.add("d");
//使用Iterator输出集合
Iterator<String> iter=arrList.iterator();
while(iter.hasNext())
{
System.out.print(iter.next()+" ");
}
System.out.println();
//使用For Each输出结合for(String e:arrList)
{
System.out.print(e+" ");
}
System.out.println();
//使用toString输出集合
System.out.println(arrList);
}
}运行结果如下：
a b c c d
a b c c d
[a, b, c, c, d]Vector类
Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。
向量类提供了三种构造方法：
public vector() public vector(int initialcapacity,int capacityIncrement) public vector(int initialcapacity) 例子：VectorApp.java
import java.util.Vector;
import java.lang.*;
import java.util.Enumeration;
public class VectorApp
{
public static void main(String args[])
{
Vector v1 = new Vector();
Integer integer1= new Integer(1);
//加入为字符串对象
v1.addElement("one");
//加入的为integer的对象
v1.addElement(integer1);
v1.addElement(integer1);
v1.addElement("two");
v1.addElement(new Integer(2));
v1.addElement(integer1);
v1.addElement(integer1);
//转为字符串并打印
System.out.println("The Vector v1 is:\n\t"+v1);
//向指定位置插入新对象
v1.insertElement("three",2);
v1.insertElement(new Float(3.9),3);
System.out.println("The Vector v1(used method
insertElementAt()is:\n\t)"+v1);
//将指定位置的对象设置为新的对象
//指定位置后的对象依次往后顺延
v1.setElementAt("four",2);
System.out.println("The vector v1 cused method setElmentAt()is:\n\t"+v1);
v1.removeElement(integer1);
//从向量对象v1中删除对象integer1
//由于存在多个integer1,所以从头开始。
//找删除找到的第一个integer1.
Enumeration enum = v1.elements();
System.out.println("The vector v1 (used method removeElememt()is");
while(enum.hasMoreElements())
System.out.println(enum.nextElement()+"");
System.out.println();
//使用枚举类(Enumeration)的方法取得向量对象的每个元素。
System.out.println("The position of Object1(top-to-botton):"+v1.indexOf(integer1));
System.out.println("The position of Object1(tottom-to-top):"+v1.lastIndexOf(integer1));
//按不同的方向查找对象integer1所处的位置
v1.setSize(4);
System.out.println("The new Vector(resized the vector)is:"+v1);
//重新设置v1的大小，多余的元素被抛弃
}
} 运行结果：
E:\java01>java VectorApp
The vector v1 is:[one,1,1,two,2,1,1]
The vector v1(used method insetElementAt()) is:
[one,1,three,3.9,1,two,2,1,1]
The vector v1(used method setElementAt()) is:
[one,1,four,3.9,1,two,2,1,1]
The vector v1(useed method removeElement()) is:
one four 3.9 1 two 2 1 1
The position of object1(top-to-botton):3
The position of object1(botton-to-top):7
The new Vector(resized the vector) is: Stack 类
Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方 法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
栈的特点是后进先出。API中Stack自身的方法不多，基本跟栈的特点有关。
示例程序如下：
import java.util.Stack;
public class StackTest {
public static void main(String[] args) {
Stack<String> stack = new Stack<String>();
System.out.println("now the stack is " + isEmpty(stack));
stack.push("1");
stack.push("2");
stack.push("3");
stack.push("4");
stack.push("5");
System.out.println("now the stack is " + isEmpty(stack));
System.out.println(stack.peek());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.search("2"));
}
public static String isEmpty(Stack<String> stack) {
return stack.empty() ? "empty" : "not empty";
}
} 输出为：
now the stack is not empty
5
5
4
2 
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
