java笔记之java中的集合框架

Java集合框架的知识总结（1）

说明：先从整体介绍了Java集合框架包含的接口和类，然后总结了集合框架中的一些基本知识和关键点，并结合实例进行简单分析。

1、综述

        所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。

       当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型（参见具体泛型的内容）。

    Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类。

Set和List接口是Collection接口派生的两个子接口，Queue是Java提供的队列实现，类似于List。

 

Map实现类用于保存具有映射关系的数据（key-value）。

Set、List和Map可以看做集合的三大类。

     List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。

     Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。

     Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。

对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayList和HashMap三个实现类。（并发控制的集合类，以后有空研究下）。

2、Collection接口

     Collection接口是List、Set和Queue接口的父接口，同时可以操作这三个接口。

Collection接口定义操作集合元素的具体方法大家可以参考API文档，这里通过一个例子来说明Collection的添加元素、删除元素、返回集合中元素的个数以及清空集合元素的方法。

public class TestCollection
{
    public static void main(String[] args) 
    {
        Collection c = new ArrayList();
        //添加元素
        c.add("孙悟空");
        //虽然集合里不能放基本类型的值，但Java支持自动装箱
        c.add(6);

        System.out.println("c集合的元素个数为:" + c.size());
       
　　　　 //删除指定元素
        c.remove(6);
       
　　　　 System.out.println("c集合的元素个数为:" + c.size());
        //判断是否包含指定字符串
        System.out.println("c集合的是否包含孙悟空字符串:" + c.contains("孙悟空"));

        c.add("轻量级J2EE企业应用实战");

        System.out.println("c集合的元素：" + c);        

　　　　　Collection books = new HashSet();

        books.add("轻量级J2EE企业应用实战");
        books.add("Struts2权威指南");

        System.out.println("c集合是否完全包含books集合？" + c.containsAll(books));

        //用c集合减去books集合里的元素
        c.removeAll(books);

        System.out.println("c集合的元素：" + c);

        //删除c集合里所有元素
        c.clear();

        System.out.println("c集合的元素：" + c);

        //books集合里只剩下c集合里也同时包含的元素
        books.retainAll(c);

        System.out.println("books集合的元素:" + books);
    }
}

Java集合框架总结（2）——Set接口的使用

1、Set接口的使用

    Set集合里多个对象之间没有明显的顺序。具体详细方法请参考API文档（可见身边随时带上API文档有多重要），基本与Collection方法相同。只是行为不同（Set不允许包含重复元素）。

      Set集合不允许重复元素，是因为Set判断两个对象相同不是使用==运算符，而是根据equals方法。即两个对象用equals方法比较返回true，Set就不能接受两个对象。

public class TestSet
{
	public static void main(String[] args) 
	{
		Set<String> books = new HashSet<String>();
		
		//添加一个字符串对象
		books.add(new String("Struts2权威指南"));
		
		//再次添加一个字符串对象，
		//因为两个字符串对象通过equals方法比较相等，所以添加失败，返回false
		boolean result = books.add(new String("Struts2权威指南"));
		
		System.out.println(result);
		
		//下面输出看到集合只有一个元素
		System.out.println(books);	
	}
}

 

      程序运行结果：

false 
[Struts2权威指南]

 

 

        说明：程序中，book集合两次添加的字符串对象明显不是一个对象（程序通过new关键字来创建字符串对象），当使用==运算符判断返回false，使用equals方法比较返回true，所以不能添加到Set集合中，最后只能输出一个元素。

        Set接口中的知识，同时也适用于HashSet、TreeSet和EnumSet三个实现类。

2、HashSet类

          HashSet按Hash算法来存储集合的元素，因此具有很好的存取和查找性能。

          HashSet的特点：

（1）HashSet不是同步的，多个线程访问是需要通过代码保证同步 

（2）集合元素值可以使null。

       HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode（）方法返回值也相等。

 

//类A的equals方法总是返回true,但没有重写其hashCode()方法
class A
{
    public boolean equals(Object obj)
    {
        return true;
    }
}
//类B的hashCode()方法总是返回1,但没有重写其equals()方法
class B
{
    public int hashCode()
    {
        return 1;
    }
}
//类C的hashCode()方法总是返回2,并重写其equals()方法
class C
{
    public int hashCode()
    {
        return 2;
    }
    public boolean equals(Object obj)
    {
        return true;
    }
}
public class TestHashSet
{
    public static void main(String[] args) 
    {
        HashSet<Object> books = new HashSet<Object>();
        //分别向books集合中添加2个A对象，2个B对象，2个C对象
        books.add(new A());
        books.add(new A());
        books.add(new B());
        books.add(new B());
        books.add(new C());
        books.add(new C());
        System.out.println(books);
    }
}

 

程序运行结果：

[B@1,  B@1 ,  C@2 ,  A@b5dac4 ,  A@9945ce]

           

说明：

（1）Object类提供的toString方法总是返回该对象实现类的类名+@+hashCode(16进制数）值，所以可以看到上面程序输出的结果。可以通过重写toString方法来输出自己希望的形式。

（2）即使2个A对象通过equals比较返回true，但HashSet依然把它们当成2个对象；即使2个B对象的hashCode（）返回相同值，但HashSet依然把它们当成2个对象。即如果把一个对象放入HashSet中时，如果重写该对象equals（）方法，也应该重写其hashCode（）方法。其规则是：如果2个对象通过equals方法比较返回true时，这两个对象的hashCode也应该相同。

hash算法的功能：

它能保证通过一个对象快速查找到另一个对象。hash算法的价值在于速度，它可以保证查询得到快速执行。

当需要查询集合中某个元素时，hash算法可以直接根据该元素的值得到该元素保存位置，从而可以让程序快速找到该元素。

当从HashSet中访问元素时，HashSet先计算该元素的hashCode值（也就是调用该对象的hashCode（））方法的返回值），然后直接到该hashCode对应的位置去取出该元素。

即也是快速的原因。HashSet中每个能存储元素的“曹位（slot）”通常称为“桶（bucket）”，如果多个元素的hashCode相同，但它们通过equals（）方法比较返回false，就需要一个“桶”里放多个元素，从而导致性能下降。

继续深入研究HashSet：

          当向HashSet中添加一个可变对象后，并且后面程序修改了该可变对象的属性，可能导致它与集合中其他元素相同，这就可能导致HashSet中包含两个相同的对象。

看下面程序：

class R
{
	int count;
	public R(int count)
	{
		this.count = count;
	}
	public String toString()
	{
		return "R(count属性:" + count + ")";
	}
	public boolean equals(Object obj)
	{
		if (obj instanceof R)
		{
			R r = (R)obj;
			if (r.count == this.count)
			{
				return true;
			}
		}
		return false;
	}
	public int hashCode()
	{
		return this.count;
	}
}
public class TestHashSet2
{
	public static void main(String[] args) 
	{
		HashSet<R> hs = new HashSet<R>();
		hs.add(new R(5));
		hs.add(new R(-3));
		hs.add(new R(9));
		hs.add(new R(-2));
		//打印HashSet集合，集合元素是有序排列的
		System.out.println(hs);
		//取出第一个元素
		Iterator<R> it = hs.iterator();
		R first = (R)it.next();     //first指向集合的第一个元素
		//为第一个元素的count属性赋值
		first.count = -3;           //first指向的元素值发生改变，地址并没有改变，大家可以试着用Java内存分配机制（栈和堆)思考下。
		//再次输出count将看到HashSet里的元素处于无序状态
		System.out.println(hs);
		hs.remove(new R(-3));
		System.out.println(hs);
		//输出false
		System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3)));
		//输出false
		System.out.println("hs是否包含count为5的R对象？" + hs.contains(new R(5)));

	}
}

 

程序运行结果：

[R(count属性:5), R(count属性:9), R(count属性:-3), R(count属性:-2)] 
[R(count属性:-3), R(count属性:9), R(count属性:-3), R(count属性:-2)] 
[R(count属性:-3), R(count属性:9), R(count属性:-2)] 
hs是否包含count为-3的R对象？false 
hs是否包含count为5的R对象？false

 

       说明：程序重写了R类的equals（）和hashCode（）方法，这两个方法都是根据R对象的count属性来判断。从运行结果可以看出，HashSet集合中有完全相同元素，这表明两个元素已经重复，但因为HashSet在添加它们时已经把它们添加到了不同地方，所以HashSet完全可以容纳两个相同元素。至于第一个count为-3的R对象，它保存在count为5的R对象对应的位置（地址）。当向HashSet中添加可变对象时，必须十分小心。如果修改HashSet集合中的对象，有可能导致该对象与集合中其他对象相等，从而导致HashSet无法准确访问该对象。

 

       HashSet还有一个子类LinkedHashSet，LinkedHashSet集合也根据元素hashCode值来决定元素存储位置，但它同时使用链表维护元素的次序，即当遍历LinkedHashSet集合元素时，HashSet将会按元素的添加顺序来访问集合里的元素。

 

3、TreeSet类

       TreeSet是SortedSet接口的唯一实现，TreeSet可以确保集合元素处于排序状态（元素是有序的）。

       TreeSet提供的几个额外方法：

Comparator comparator()： 返回当前Set使用的Comparator，或者返回null，表示以自然方式排序。

Object first()：返回集合中的第一个元素。

Object last()：返回集合中的最后一个元素。

Objiect lower(Object e)：返回集合中位于指定元素之前的元素（即小于指定元素的最大元素，参考元素可以不是TreeSet的元素）。

Object higher(Object e)：返回集合中位于指定元素之后的元素（即大于指定元素的最小元素，参考元素可以不需要TreeSet的元素）。

SortedSet subSet(fromElement， toElement)：返回此Set的子集，范围从fromElement(包含大于等于）到toElement(不包含小于）。

SortedSet headSet(toElement)：返回此Set的子集，由小于toElement的元素组成。

SortedSet tailSet(fromElement)：返回此Set的子集，由大于或等于fromElement的元素组成。

 

public class TestTreeSetCommon
{
	public static void main(String[] args) 
	{
		TreeSet<Integer> nums = new TreeSet<Integer>();
		//向TreeSet中添加四个Integer对象
		nums.add(5);
		nums.add(2);
		nums.add(10);
		nums.add(-9);
		//输出集合元素，看到集合元素已经处于排序状态
		System.out.println(nums);
		//输出集合里的第一个元素
		System.out.println(nums.first());
		//输出集合里的最后一个元素
		System.out.println(nums.last());
		//返回小于4的子集，不包含4
		System.out.println(nums.headSet(4));
		//返回大于5的子集，如果Set中包含5，子集中还包含5
		System.out.println(nums.tailSet(5));
		//返回大于等于-3，小于4的子集。
		System.out.println(nums.subSet(-3 , 4));
	}
}

程序运行结果：

[-9, 2, 5, 10] 
-9 
10 
[-9, 2] 
[5, 10] 
[2]

说明：由运行结果可以看出，TreeSet并不是根据元素的插入顺序进行排序，而是根据元素实际值来进行排序。TreeSet采用红黑树的数据结构对元素进行排序

Java集合框架总结（3）——TreeSet类的排序问题

 

TreeSet支持两种排序方法：自然排序和定制排序。TreeSet默认采用自然排序。

1、自然排序

    TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系，然后将集合元素按升序排列，这种方式就是自然排序。（比较的前提：两个对象的类型相同）。

 

    java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类的对象就可以比较大小。当一个对象调用该方法与另一个对象进行比较，例如obj1.comparTo(obj2),如果该方法返回0，则表明这两个对象相等；如果返回一个正整数，则表明obj1大于obj2；如果该方法返回一个负整数，则表明obj1小于obj2.

 

java常用类实现Comparable接口，并提供了比较大小的标准。实现Comparable接口的常用类：

• BigDecimal、BigIneger以及所有数值型对应包装类：按它们对应的数值的大小进行比较。
• Character：按字符的UNICODE值进行比较。
• Boolean：true对应的包装类实例大于false对应的包装类实例。
• String：按字符串中字符的UNICODE值进行比较。
• Date、Time：后面的时间、日期比前面的时间、日期大。

如果试图把一个对象添加进TreeSet时，则该对象的类必须实现Comparable接口。

如下程序则会报错：

class Err 
{ 
} 
public class TestTreeSetError 
{ 
    public static void main(String[] args) 
    { 
        TreeSet ts = new TreeSet(); 
        //向TreeSet集合中添加两个Err对象 
        ts.add(new Err()); 
        ts.add(new Err()); 
    } 
}

 

说明：

    上面程序试图向TreeSet集合中添加2个Err对象，添加第一个对象时，TreeSet里没有任何元素，所以没有问题；当添加第二个Err对象时，TreeSet就会调用该对象的compareTo(Object obj)方法与集合中其他元素进行比较——如果对应的类没有实现Comparable接口，则会引发ClassCastException异常。而且当试图从TreeSet中取出元素第一个元素时，依然会引发ClassCastException异常。

 

    当采用compareTo(Object obj)方法比较对象时，都需要将被比较对象obj强制类型转换成相同类型，因为只有相同类的两个实例才能比较大小。即向TreeSet中添加的应该是同一个类的对象，否则会引发ClassCastException异常。例如，当向TreeSet中添加一个字符串对象，这个操作完全正常。当添加第二个Date对象时，TreeSet就好调用该对象的compareTo(Object obj)方法与集合中其他元素进行比较，则此时程序会引发异常。

    在实际编程中，程序员可以定义自己的类向TreeSet中添加多种类型的对象，前提是用户自定义类实现了Comparable接口，实现该接口时在实现compareTo(Object obj)方法时没有进行强制类型转换。但当操作TreeSet里的集合数据时，不同类型的元素依然会发生ClassCastExceptio异常。（认真阅读下就会明白)

    当把一个对象加入TreeSet集合中时，TreeSet调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，然后根据红黑树算法决定它的存储位置。如果两个对象通过compareTo(Object obj)比较相等，TreeSet即认为它们存储同一位置。

    对于TreeSet集合而言，它判断两个对象不相等的标准是：两个对象通过equals方法比较返回false，或通过compareTo（Object obj）比较没有返回0——即使两个对象时同一个对象，TreeSet也会把它们当成两个对象进行处理。

如下程序所示：

//Z类，重写了equals方法，总是返回false， 
//重写了compareTo(Object obj)方法，总是返回正整数 
class Z implements Comparable 
{ 
    int age; 
    public Z(int age) 
    { 
        this.age = age; 
    } 
    public boolean equals(Object obj) 
    { 
        return false; 
    } 
    public int compareTo(Object obj) 
    { 
        return 1; 
    } 
} 
public class TestTreeSet 
{ 
    public static void main(String[] args) 
    { 
        TreeSet set = new TreeSet(); 
        Z z1 = new Z(6); 
        set.add(z1); 
        System.out.println(set.add(z1)); 
        //下面输出set集合，将看到有2个元素 
        System.out.println(set); 
        //修改set集合的第一个元素的age属性 
        ((Z)(set.first())).age = 9; 
        //输出set集合的最后一个元素的age属性，将看到也变成了9 
        System.out.println(((Z)(set.last())).age); 
    } 
}

程序运行结果：

true 
[TreeSet.Z@1fb8ee3, TreeSet.Z@1fb8ee3] 
9

说明：

    程序中把同一个对象添加了两次，因为z1对象的equals()方法总是返回false，而且compareTo(Object obj)方法总是返回1。这样TreeSet会认为z1对象和它自己也不相同，因此TreeSet中添加两个z1对象。而TreeSet对象保存的两个元素实际上是同一个元素。所以当修改TreeSet集合里第一个元素的age属性后，该TreeSet集合里最后一个元素的age属性也随之改变了。

    总结：当需要把一个对象放入TreeSet中时，重写该对象对应类的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致结果，其规则是：如果两个对象通过equals方法比较返回true时，这两个对象通过compareTo（Object obj）方法比较应返回0.

    如果两个对象通过equals方法比较返回true，但这两个对象通过compareTo(Object obj)方法比较不返回0时，这将导致TreeSet将会把这两个对象保存在不同位置，从而两个对象都可以添加成功，这与Set集合的规则有点出入。

如果两个对象通过compareTo(Object obj)方法比较返回0时，但它们通过equals方法比较返回false时将更麻烦：因为两个对象通过compareTo（Object obj）方法比较相等，TreeSet将试图把它们保存在同一个位置，但实际上又不行（否则将只剩下一个对象），所以处理起来比较麻烦。

    如果向TreeSet中添加一个可变对象后，并且后面程序修改了该可变对象的属性，导致它与其他对象的大小顺序发生改变，但TreeSet不会再次调整它们的顺序，甚至可能导致TreeSet中保存这两个对象，它们通过equals方法比较返回true，compareTo（Object obj）方法比较返回0.

如下程序所示：

class R 
{ 
    int count; 
    public R(int count) 
    { 
        this.count = count; 
    } 
    public String toString() 
    { 
        return "R(count属性:" + count + ")"; 
    } 
    public boolean equals(Object obj) 
    { 
        if (obj instanceof R) 
        { 
            R r = (R)obj; 
            if (r.count == this.count) 
            { 
                return true; 
            } 
        } 
        return false; 
    } 
    public int hashCode() 
    { 
        return this.count; 
    } 
} 
public class TestHashSet2 
{ 
    public static void main(String[] args) 
    { 
        HashSet hs = new HashSet(); 
        hs.add(new R(5)); 
        hs.add(new R(-3)); 
        hs.add(new R(9)); 
        hs.add(new R(-2)); 
        //打印TreeSet集合，集合元素是有序排列的 
        System.out.println(hs); 
        //取出第一个元素 
        Iterator it = hs.iterator(); 
        R first = (R)it.next(); 
        //为第一个元素的count属性赋值 
        first.count = -3; 
        //再次输出count将看到TreeSet里的元素处于无序状态 
        System.out.println(hs); 
        hs.remove(new R(-3)); 
        System.out.println(hs); 
        //输出false 
        System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3))); 
        //输出false 
        System.out.println("hs是否包含count为5的R对象？" + hs.contains(new R(5)));

    } 
}

 

程序运行结果：

[R(count属性:-3), R(count属性:-2), R(count属性:5), R(count属性:9)] 
[R(count属性:20), R(count属性:-2), R(count属性:5), R(count属性:-2)] 
[R(count属性:20), R(count属性:-2), R(count属性:5), R(count属性:-2)] 
[R(count属性:20), R(count属性:-2), R(count属性:-2)]

说明：

    上面程序中的R对象是一个正常重写了equals方法和comparable方法类，这两个方法都以R对象的count属性作为判断的依据。可以看到程序第一次输出的结果是有序排列的。当改变R对象的count属性，程序的输出结果也发生了改变，而且包含了重复元素。一旦改变了TreeSet集合里可变元素的属性，当再视图删除该对象时，TreeSet也会删除失败（甚至集合中原有的、属性没被修改，但与修改后元素相等的元素也无法删除），所以删除count

为-2的R对象时，没有任何元素被删除；程序可以删除count为5的R对象，这表明TreeSet可以删除没有被修改属性、且不与其他被修改属性的对象重复的对象。

    总结：与HashSet在处理这些对象时将非常复杂，而且容易出错。为了让程序更具健壮，推荐HashSet和TreeSet集合中只放入不可变对象。

2、定制排序

    TreeSet的自然排序是根据集合元素的大小，TreeSet将他们以升序排列。如果需要实现定制排序，例如降序，则可以使用Comparator接口。该接口里包含一个int compare（T o1， T o2）方法，该方法用于比较o1和o2的大小。

   如果需要实现定制排序，则需要在创建TreeSet集合对象时，并提供一个Comparator对象与该TreeSet集合关联，由该Comparator对象负责集合元素的排序逻辑。

如下程序所示：

class M { 
    int age;

    public M(int age) { 
        this.age = age; 
    }

    public String toString() { 
        return "M对象（age：" + age + ")"; 
    } 
}

public class TestTreeSet3 { 
    public static void main(String[] args) { 
        TreeSet ts = new TreeSet(new Comparator() { 
            public int compare(Object o1, Object o2) {

                M m1 = (M) o1; 
                M m2 = (M) o2;

                if (m1.age > m2.age) { 
                    return -1; 
                } else if (m1.age == m2.age) { 
                    return 0; 
                } else { 
                    return 1; 
                } 
            } 
        }); 
        ts.add(new M(5)); 
        ts.add(new M(-3)); 
        ts.add(new M(9)); 
        System.out.println(ts); 
    } 
}

程序运行结果：

[M对象（age：9), M对象（age：5), M对象（age：-3)]

说明：

    上面程序中创建了一个Comparator接口的匿名内部类对象，该对象负责ts集合的排序。所以当我们把M对象添加到ts集合中时，无须M类实现Comparable接口，因为此时TreeSet无须通过M对象来比较大小，而是由与TreeSet关联的Comparator对象来负责集合元素的排序。使用定制排序时，TreeSet对集合元素排序时不管集合元素本身的大小，而是由Comparator对象负责集合元素的排序规则。

Java集合框架总结（4）——List接口的使用

    List集合代表一个有序集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。

1、List接口和ListIterator接口

    List作为Collection接口的子接口，可以使用Collection接口里的全部方法。List是有序集合，所以List集合里增加了一些根据索引来操作集合元素的方法：

• void add(int index, Object element):将元素element插入在List集合的index处。
• boolean addAll(int index, Collection c):将集合c所包含的所有元素都插入在List集合的index处。
• Object get(int index):返回集合index索引处的元素。
• int lastIndexOf(Object o):返回对象o在List集合中最后一次出现的位置索引。
• Object remove(int index):删除并返回index索引处的元素。
• Object set(int index, Object element):将index索引处的元素替换成element对象，返回新元素。
• List subList(int fromIndex, int toIndex):返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成的子集合。

    List集合可以根据索引来插入、替换和删除集合元素。

示例程序：

public class TestList
{
    public static void main(String[] args)
    {
        List books = new ArrayList();
        //向books集合中添加三个元素
        books.add(new String("轻量级J2EE企业应用实战"));
        books.add(new String("Struts2权威指南"));
        books.add(new String("基于J2EE的Ajax宝典"));
        System.out.println(books);
        //将新字符串对象插入在第二个位置
        books.add(1 , new String("ROR敏捷开发最佳实践")); //已添加的对象，和下面语句做对比
        for (int i = 0 ; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }
        //删除第三个元素
        books.remove(2);
        System.out.println(books);
        //判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf(new String("ROR敏捷开发最佳实践"))); //新创建的对象
        //将第二个元素替换成新的字符串对象
        books.set(1, new String("Struts2权威指南"));
        System.out.println(books);
        //将books集合的第二个元素（包括）到第三个元素（不包括）截取称子集合
        System.out.println(books.subList(1 , 2));

    }
}

程序运行结果：

[轻量级J2EE企业应用实战, Struts2权威指南, 基于J2EE的Ajax宝典] 
轻量级J2EE企业应用实战 
ROR敏捷开发最佳实践 
Struts2权威指南 
基于J2EE的Ajax宝典 
[轻量级J2EE企业应用实战, ROR敏捷开发最佳实践, 基于J2EE的Ajax宝典] 
1 
[轻量级J2EE企业应用实战, Struts2权威指南, 基于J2EE的Ajax宝典] 
[Struts2权威指南]

程序说明：List集合可以使用普通for循环来遍历集合元素。List判断两个对象相等只要通过equals方法比较返回true即可。如在判断“ROR敏捷开发最佳实践”字符串的位置是，新创建了一个新字符串对象，但是程序仍返回第一次创建字符串对象的位置。当调用List的set（int index， Object element）方法来改变List集合指定索引处元素时，指定的索引必须是List集合的有效索引。

     与set只提供了一个iterator()方法不同，List还额外提供了一个listIteratro()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操作List的方法。

ListIterator接口在Iterator接口基础上增加了如下方法：

• boolean hasPrevious()：返回该迭代器关联集合是否还有上一个元素。
• Object previous()：返回该迭代器上一个元素。
• void add()：在指定位置插入一个元素。

程序示例：

public static void main(String[] args)
    {
        String[] books = {
            "Struts2权威指南",
            "轻量级J2EE企业应用实战"
        };
        List bookList = new ArrayList();
        for (int i = 0; i < books.length ; i++ )
        {
            bookList.add(books[i]);
        }
        ListIterator lit = bookList.listIterator();
        while (lit.hasNext())
        {
            System.out.println(lit.next());
            lit.add("-------分隔符-------");
        }
        System.out.println("==========下面开始反向迭代===========");
        while(lit.hasPrevious())
        {
            System.out.println(lit.previous());
        }
    }
}

程序运行结果：

Struts2权威指南 
轻量级J2EE企业应用实战 
==========下面开始反向迭代=========== 
-------分隔符------- 
轻量级J2EE企业应用实战 
-------分隔符------- 
Struts2权威指南

程序说明：List通过ListTterator迭代集合时，即可采用next()方法进行正向迭代，迭代过程中可以使用add()方法向上一次迭代元素的后面添加一个新元素。同时程序演示了向前迭代。

 2、ArrayList和Vector实现类

    ArrayList和Vector作为List类的两个典型实现，完全支持前面介绍的List接口全部功能。

    ArrayList和Vector类都是基于数组实现的List类，他们封装了一个动态再分配的Object[]数组。每个ArrayList或Vector对象有一个capacity属性，表示它们所封装的Object[]数组的长度。capacity会添加元素的个数而自动增加。当向集合中添加大量元素时，可以使用ensureCapacity方法一次性地增加capacity。这可以减少增加重分配次数，从而提供性能。capacity大小也可以在创建时就指定，该属性默认为10.

ArrayList和Vector提供如下两个方法来操作capacity属性：

• void ensureCapacity(int minCapacity):将ArrayList或Vector集合的capacity增加minCapacity。
• void trimToSize()：调整ArrayList或Vector集合的capacity为列表当前大小。程序可调用该方法来减少ArrayList或Vector集合对象存储空间。

    ArrayList和Vector用法几乎相同，Vector是一个古老的集合（从JDK1.0），起初Java还没有提供系统的集合框架，所以Vector里提供了一些方法名很长的方法：例如addElement(Object obj), 等同于add()方法。从JDK1.2以后，Java提供了系统的集合框架，就将Vector改为实习List接口，作为List的实习之一，从而导致Vector里有一些功能重复的方法。Vector具有很多缺点，通常尽量少用Vector实现类。

 

   ArrayList和Vector的区别：ArrayList是线程不安全的，多个线程访问同一个ArrayList集合时，如果有超过一条线程修改了ArrayList集合，则程序必须手动保证该集合的同步性。Vector集合则是线程安全的，无线程序保证该集合的同步性。因为Vector是线程安全的，所以Vector的性能比ArrayList的性能要低。实际上，即使保证List集合线程安全，同样不推荐使用Vector实现类。Collections工具类，可以将一个ArrayList变成线程安全的。

 

   Vector还提供了一个Stack子类，它用于模拟了”栈“这种数据结构，”栈“通常是指”后进先出“（LIFO）的容器。最后”push“进栈的元素，将最先被”pop“出栈。与Java中其他集合一样，进栈出栈的都是Object，因此从栈中取出元素后必须做类型转换，除非你只是使用Object具有的操作。所以stack类提供了如下几个方法：

• Object peek():返回”栈“的第一个元素，但并不将该元素”pop“出栈。
• Object pop():返回”栈“的第一个元素，并将该元素”pop“出栈。
• void push(Object item):将一个元素”push“进栈，最后一个进”栈“的元素总是位于”栈“顶。

程序示例：

public class TestVector
{
    public static void main(String[] args)
    {
        Stack v = new Stack();
        //依次将三个元素push入"栈"
        v.push("Struts2权威指南");
        v.push("轻量级J2EE企业应用实战");
        v.push("ROR敏捷开发最佳实践");
        //输出：[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践]
        System.out.println(v);
        //访问第一个元素，但并不将其pop出"栈"，输出：ROR敏捷开发最佳实践
        System.out.println(v.peek());
        //依然输出：[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践]
        System.out.println(v);
        //pop出第一个元素，输出：ROR敏捷开发最佳实践
        System.out.println(v.pop());
        //依然输出：[Struts2权威指南, 轻量级J2EE企业应用实战]
        System.out.println(v);
    }
}

程序运行结果：

[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践] 
ROR敏捷开发最佳实践 
[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践] 
ROR敏捷开发最佳实践 
[Struts2权威指南, 轻量级J2EE企业应用实战]

   3、LinkedList实现类

    List还有一个LinkedList的实现，它是一个基于链表实现的List类，对于顺序访问集合中的元素进行了优化，特别是当插入、删除元素时速度非常快。因为LinkedList即实现了List接口，也实现了Deque接口（双向队列），Deque接口是Queue接口的子接口，它代表一个双向列表，Deque接口里定义了一些可以双向操作队列的方法：

• void addFirst(Object e)：将制定元素插入该双向队列的开头。
• void addLast(Object e)：将制定元素插入该双向队列的末尾。
• Iterator descendingIterator()：返回以该双向队列对应的迭代器，该迭代器将以逆向顺序来迭代队列中的元素。
• Object getFirst()：获取、但不删除双向队列的第一个元素。
• Object getLast(): 获取、但不删除双向队列的最后一个元素。
• boolean offerFirst(Object e): 将指定的元素插入该双向队列的开头。
• boolean offerLast(Object e): 将指定的元素插入该双向队列的末尾。
• Object peekFirst(): 获取、但不删除该双向队列的第一个元素：如果此双端队列为空，则返回null。
• Object peekLast()：获取、但不删除该双向队列的最后一个元素：如果此双端队列为空，则返回null。
• Object pollFirst()：获取、并删除该双向队列的第一个元素：如果此双端队列为空，则返回null。
• Object pollLast()：获取、并删除该双向队列的最后一个元素：如果此双端队列为空，则返回null。
• Object pop()：pop出该双向队列所表示的栈中第一个元素。
• void push(Object e):将一个元素push进该双向队列所表示的栈中（即该双向队列的头部）。
• Object removerFirst()：获取、并删除该双向队列的最后一个元素。
• Object removeFirstOccurrence(Object o)：删除该双向队列的第一次的出现元素o。
• Object removeLast():获取、并删除该双向队列的最后一个元素。
• Object removeLastOccurrence(Object o)：删除该双向队列的最后一次出现的元素o。

从上面方法中可以看出，LinkedList不仅可以当成双向队列使用，也可以当成“栈”使用。同时，LinkedList实现了List接口，所以还被当成List使用。

程序示例：

public class TestLinkedList
{
    public static void main(String[] args)
    {
        LinkedList books = new LinkedList();
        //将字符串元素加入队列的尾部
        books.offer("Struts2权威指南");
        //将一个字符串元素入栈
        books.push("轻量级J2EE企业应用实战");
        //将字符串元素添加到队列的头部
        books.offerFirst("ROR敏捷开发最佳实践");
        for (int i = 0; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }
        //访问、并不删除队列的第一个元素
        System.out.println(books.peekFirst());
        //访问、并不删除队列的最后一个元素
        System.out.println(books.peekLast());
        //采用出栈的方式将第一个元素pop出队列
        System.out.println(books.pop());
        //下面输出将看到队列中第一个元素被删除
        System.out.println(books);
        //访问、并删除队列的最后一个元素
        System.out.println(books.pollLast());
        //下面输出将看到队列中只剩下中间一个元素：轻量级J2EE企业应用实战
        System.out.println(books);

    }
}

程序运行结果：

ROR敏捷开发最佳实践 
轻量级J2EE企业应用实战 
Struts2权威指南 
ROR敏捷开发最佳实践 
Struts2权威指南 
ROR敏捷开发最佳实践 
[轻量级J2EE企业应用实战, Struts2权威指南] 
Struts2权威指南 
[轻量级J2EE企业应用实战]

说明：程序中示范了LinkedList作为双向队列、栈和List集合的用法。LinkedList与ArrayList、Vector的实现机制完全不同，ArrayList、Vector内部以数组的形式来保存集合中的元素，因此随机访问集合元素上有较好的性能；而LinkedList内部以链表的形式来保存集合中的元素，因此随机访问集合时性能较差，但在插入、删除元素时性能非常出色（只需改变指针所指的地址即可）。Vector因实现了线程同步功能，所以各方面性能有所下降。

 

关于使用List集合的几点建议：

• 如果需要遍历List集合元素，对应ArrayList、Vector集合，则应该使用随机访问方法（get）来遍历集合元素，这样性能更好。对应LinkedList集合，则应采用迭代器（Iterator）来遍历集合元素。
• 如果需要经常执行插入、删除操作来改变Lst集合大小，则应该使用LinkedList集合，而不是ArrayList。
• 如果多条线程需要同时访问List集合中的元素，可以考虑使用Vector这个同步实现。

Java集合框架总结（5）——Map接口的使用

Map用于保存具有映射关系的数据（key-vlaue）。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false

Map中包含了一个keySet()方法，用于返回Map所以key组成的Set集合。

    Map集合与Set集合元素的存储形式很像，如Set接口下有HashSet、LinkedHashSet、SortedSet（接口）、TreeSet、EnumSet等实现类和子接口，而Map接口下则有HashMap、LinkedHashMap、SortedMap（接口）、TreeMap、EnumMap等实现类和子接口。

 

    Map的value非常类似List：元素与元素之间可以重复，每个元素可以根据索引（key）来查找。

    Map有时也称为字典，或关联数组。

Map接口中定义如下方法：

• void clear();删除Map对象中所有key-value对。
• boolean containsKey(Object key):查询Map中是否包含指定key，如果包含则返回true。
• boolean containsValue(Object value):查询Map中是否包含一个或多个value，如果包含则返回true。
• Set entrySet():返回Map中所有包含的key-value对组成的Set集合，每个集合元素都是Map.Entry(Entry是Map的内部类）对象。
• Object get(Obejct key):返回指定key所对应的value；如果此Map中不包含key，则返回null。
• boolean isEmpty():查询该Map是否为空（即不包含任何key-value对），如果为空则返回true。
• Set keySet():返回该Map中所有key所组成的set集合。
• Object put(Object key, Object value):添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对。
• Object remove(Object key):删除指定key对应的key-value对，返回被删除key所关联的value，如果该key不存在，返回null。
• int size():返回该Map里的key-value对的个数。
• Collection values():返回该Map里所有value组成的Collection。

    Map接口提供了大量的实现类，如HashMap和Hashtable等，以及HashMap的子类LinkedHashMap,还有SortedMap子接口及该接口的实现类TreeMap。下面将进行详细介绍。

    Map中包括一个内部类：Entry。该类封装了一个key-value对，Entry包含三个方法：

• Object getkey():返回该Entry里包含的key值。
• Object getValue():返回该Entry里包含的value值。
• Object setValue():设置该Entry里包含的value值，并返回新设置的value值。

    可以把Map理解成一个特殊的Set，只是该Set里包含的集合元素是Entry对象，而不是普通对象。

 

1、HashMap和Hashtable实现类

　　HashMap和Hashtable都是Map接口的实现类，Hashtable是一个古老的Map实现类，它从JDK1.0起就有，它包含两个烦琐的方法：elements()(类似于Map接口定义的values()方法）和keys()（类似于Map接口定义的keySet()方法)，现在很少使用这两种方法。

两点区别：

• Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高些；但如果多线程访问同一个Map对象，使用Hashtable实现类更好。
• Hashtable不允许使用null作为key和value，如果为null，则引发NullPointerException异常；但HashMap可以使用null作为key或value。

　　由于HashMap里的可以不能重复，所以HashMap里最多只有一对key-value值为null，但可以有无数多项key-value对的value为null。

　　HashMap重写了toString()方法方法总是返回如下格式的字符串：{key1 = value1，key2 = value2..}

　　HashMap、Hashtable判断两个key相等的标准是：两个key通过equasl方法比较返回ture,两个key的hashCode值相等。

LinkedHashMap类

　　HashMap有一个子类：LinkedHashMap,它也是双向链表来维护key-value对的次序，该链表定义了迭代顺序，该迭代顺序与key-value对的插入顺序保持一致。

LinkedHashMap可以避免对HashMap、Hashtable里的key-value对进行排序（只要插入key-value对时保持顺序即可）。同时又可避免使用TreeMap所增加的成本。

LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能，但在迭代访问Map里的全部元素时将有很好的性能，因为它以链表来维护内部顺序。

Properties类

　　Properties类是Hashtable类的子类，用于处理属性文件（例如Windows操作平台上的ini文件）。Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件，也可以把属性文件中的属性名=属性值加载到Map对象中。由于属性文件里的属性名、属性值只能是字符串类型，所以Properties里的key、value都是字符串类型，该类提供了如下三个方法来修改Properties里的key、value值。

1. String getProperty(String key):获取Properties中指定属性名对应的属性值，类似于Map的get(Object key)方法。
2. String getProperty(String key, String defaultValue):该方法与前一个方法基本类似。该方法多一个功能，如果Properties中不存在指定key时，该方法返回默认值。
3. Object geProperty(String key、String value):设置属性值，类似Hashtable的put方法。

提供两个读、写属性文件的方法：

1. void load(InputStream inStream):从属性文件（以输入流表示）中加载属性名=属性值，把加载到的属性名=属性值对追加到Properties里（由于Properties是Hashtable)的子类，它不保证key-value对之间的次序）。
2. void Store(OutputStream out, String comment):将Properties中的key-valu对写入指定属性文件（以输出流表示）。

示例程序：

public class TestProperties
{
    public static void main(String[] args) throws Exception
    {
        Properties props = new Properties();
        //向Properties中增加属性
        props.setProperty("username" , "yeeku");
        props.setProperty("password" , "123456");
        //将Properties中的属性保存到a.ini文件中
        props.store(new FileOutputStream("a.ini") , "comment line");
        //新建一个Properties对象
        Properties props2 = new Properties();
        //向Properties中增加属性
        props2.setProperty("gender" , "male");
        //将a.ini文件中的属性名-属性值追加到props2中
        props2.load(new FileInputStream("a.ini") );
        System.out.println(props2);
    }
}

 

 

运行结果：

{password=123456, gender=male, username=yeeku}

 

2、SortedMap接口和TreeMap实现类

　　Map接口派生了一个SortedMap子接口，TreeMap为其实现类。类似TreeSet排序，TreeMap也是基于红黑树对TreeMap中所有key进行排序，从而保证TreeMap中所有key-value对处于有序状态。TreeMap两种排序方法：

1. 自然排序：TreeMap的所有key必须实现Comparable接口，而且所有key应该是同一个类的对象，否则将会抛出ClassCastExcepiton异常。
2. 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeＭap中所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口。

　　TreeMap中判断两个key相等的标准也是两个key通过equals比较返回true，而通过compareTo方法返回0，TreeMap即认为这两个key是相等的。

　　如果使用自定义的类作为TreeMap的key，应重新该类的equals方法和compareTo方法时应有一致的返回结果：即两个key通过equals方法比较返回true时，它们通过compareTo方法比较应该返回0。如果equals方法与compareTo方法的返回结果不一致，要么该TreeMap与Map接口的规则有出入（当equals比较返回true,但CompareTo比较不返回0时），要么TreeMap处理起来性能有所下降（当compareTo比较返回0，当equals比较不返回true时）。

TreeMap中提供了系列根据key顺序来访问Map中key-value对方法：

1. Map.Entry firstEntry():返回该Map中最小key所对应的key-value对，如果该Map为空，则返回null。
2. Object firstKey():返回该Map中的最小key值，如果该Map为空，则返回null。
3. Map.Entry lastEntry():返回该Map中最大key所对应的key-value对，如果该Map为空，或不存在这样的key-value都返回null。
4. Object lastKey():返回该Map中的最大key值，如果该Map为空，或不存在这样的key都返回null。
5. Map.Entry higherEntry(Object key):返回该Map中位于key后一位的key-value对（即大于指定key的最小key所对应的key-value对）。如果该Map为空，则返回null。
6. Object higherKey():返回该Map中位于key后一位的key值（即大于指定key的最小key值）。如果该Map为空，或不存在这样的key都返回null。
7. Map.Entry lowerEntry(Object key):返回该Map中位于key前一位的key-value对（即小于指定key的最大key所对应的key-value对）。如果该Map为空，或不存在这样的key-value则返回null。
8. Object lowerKey():返回该Map中位于key前一位的key值（即小于指定key的最大key值）。如果该Map为空，或不存在这样的key都返回null。
9. NavigableMap subMap(Object fromKey, boolean fromInclusive, Object tokey, boolean tolnclusive):返回该Map的子Map，其key的范围从fromKey(是否包括取决于第二个参数）到tokey（是否包括取决于第四个参数）。
10. SorterMap subMap（Object fromKey， Object toKey)：返回该Map的子Map，其key的范围从fromKey（包括）到toKey（不包括）。
11. SortedMap tailMap（Object fromKey，boolean inclusive）:返回该Map的子Map，其key的范围是大于fromkey（是否包括取决于第二个参数）的所有key。
12. NavigableMap headMap(Object toKey, boolean lnclusive):返回该Map的子Map，其key的范围是小于fromKey（是否包括取决于第二个参数）的所有key。

程序示例：

//R类，重写了equals方法，如果count属性相等返回true
//重写了compareTo(Object obj)方法，如果count属性相等返回0;
class R implements Comparable
{
    int count;
    public R(int count)
    {
        this.count = count;
    }
    public String toString()
    {
        return "R(count属性:" + count + ")";
    }
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj != null
            && obj.getClass() == R.class)
        {
            R r = (R)obj;
            if (r.count == this.count)
            {
                return true;
            }
        }
        return false;
    }
    public int compareTo(Object obj)
    {
        R r = (R)obj;
        if (this.count > r.count)
        {
            return 1;
        }
        else if (this.count == r.count)
        {
            return 0;
        }
        else
        {
            return -1;
        }
    }
}
public class TestTreeMap
{
    public static void main(String[] args)
    {
        TreeMap tm = new TreeMap();
        tm.put(new R(3) , "轻量级J2EE企业应用实战");
        tm.put(new R(-5) , "Struts2权威指南");
        tm.put(new R(9) , "ROR敏捷开发最佳实践");
        System.out.println(tm);
        //返回该TreeMap的第一个Entry对象
        System.out.println(tm.firstEntry());
        //返回该TreeMap的最后一个key值
        System.out.println(tm.lastKey());
        //返回该TreeMap的比new R(2)大的最小key值。
        System.out.println(tm.higherKey(new R(2)));
        //返回该TreeMap的比new R(2)小的最大的key－value对。
        System.out.println(tm.lowerEntry(new R(2)));
        //返回该TreeMap的子TreeMap
        System.out.println(tm.subMap(new R(-1) , new R(4)));

    }
}

 

运行结果：

{R(count属性:-5)=Struts2权威指南, R(count属性:3)=轻量级J2EE企业应用实战, R(count属性:9)=ROR敏捷开发最佳实践} 
R(count属性:-5)=Struts2权威指南 
R(count属性:9) 
R(count属性:3) 
R(count属性:-5)=Struts2权威指南 
{R(count属性:3)=轻量级J2EE企业应用实战}

本文转自 星星传奇的博客 ：http://www.cnblogs.com/zhxxcq/archive/2012/03/11/2389611.html，感谢作者的分享