BlogJava-Java Coder-文章分类-java.util 包分析

Map 接口分析

fred.li — Sun, 27 Jul 2008 13:11:00 GMT

java.util.Map 接口定义了key-value对形式的集合类型，它提供了三种访问视图：

key set：所有key的集合。由于key是不可重复的，所以返回一个set
value collection：所有value的集合，value可以重复
entry set：所有key-value对的集合，也不可能重复

对这三个视图的修改都会影响到原来的Map集合。
必须注意的是，Map中的key要选择不可变对象，比如String，否则Map的行为不可预测。

Map接口中还定义了一个内部接口Map.Entry，它包含了一个key-value对象，提供了getKey()和getValue()等方法。和entrySet()方法一起使用，可以方便的遍历整个Map集合。

fred.li 2008-07-27 21:11 发表评论

TreeSet 类分析

fred.li — Sat, 26 Jul 2008 09:11:00 GMT

摘要: TreeSet 类实现了 NavigableSet 接口，是一种有序的Set集合：必须提供元素的排序方法：自然排序，或者在构造方法中提供Comparator对象 TreeSet 依赖 TreeMap 的实现，所有的方法都依托TreeMap 排序方法必须和equals(obj)方法相一致，以符合Set的定义 Code highlighting pro... 阅读全文

fred.li 2008-07-26 17:11 发表评论

NavigableSet 接口分析

fred.li — Mon, 21 Jul 2008 14:34:00 GMT

java.util.Navigable 接口继承自 SortedSet 接口，在排序Set的基础上支持更多的查找功能。
NavigableSet 接口的新特性：

higher()、lower()方法可以返回大于、小于指定元素的最近元素
descendingSet()、descendingIterator()方法可以按照排序结果的逆向遍历元素
subSet()、headSet()、tailSet()这些方法中可以传入参数，指定是否包括头（尾）元素

fred.li 2008-07-21 22:34 发表评论

AbstractSet 抽象类分析

fred.li — Mon, 21 Jul 2008 14:20:00 GMT

java.util.AbstractSet抽象类继承自 AbstractCollection 抽象类，所有Set的实现类都直接或者间接继承AbstractSet父类。
AbstractSet类包括equals(),hashCode(),removeAll(c)方法，这些方法都被实现了，子类无需再重写。
AbstractSet类提供了实现Set集合的基本框架，方便HashSet、TreeSet这些子类的实现。

  1 package java.util;
  2
  3 public abstract class AbstractSet<E> extends AbstractCollection<E> implements
  4         Set<E> {
  5     /**
  6      * Sole constructor. (For invocation by subclass constructors, typically
  7      * implicit.)
  8      */
  9     protected AbstractSet() {
10     }
11
12     // Comparison and hashing
13
14     /**
15      * Compares the specified object with this set for equality. Returns
16      * true if the given object is also a set, the two sets have the
17      * same size, and every member of the given set is contained in this set.
18      * This ensures that the equals method works properly across
19      * different implementations of the Set interface.
20      *

21      *
22      * This implementation first checks if the specified object is this set; if
23      * so it returns true. Then, it checks if the specified object is a
24      * set whose size is identical to the size of this set; if not, it returns
25      * false. If so, it returns containsAll((Collection) o).
26      *
27      * @param o
28      *            object to be compared for equality with this set
29      * @return true if the specified object is equal to this set
30      */
31     public boolean equals(Object o) {
32         // 是否指向同一个对象？
33         if (o == this)
34             return true;
35
36         // 是否都是Set类？
37         if (!(o instanceof Set))
38             return false;
39
40         Collection c = (Collection) o;
41         // 先比较大小
42         if (c.size() != size())
43             return false;
44         try {
45         // 再比较所有的元素
46             return containsAll(c);
47         // 处理containsAll(c)抛出的异常
48         } catch (ClassCastException unused) {
49             return false;
50         } catch (NullPointerException unused) {
51             return false;
52         }
53     }
54
55     /**
56      * Returns the hash code value for this set. The hash code of a set is
57      * defined to be the sum of the hash codes of the elements in the set, where
58      * the hash code of a null element is defined to be zero. This
59      * ensures that s1.equals(s2) implies that
60      * s1.hashCode()==s2.hashCode() for any two sets s1 and
61      * s2, as required by the general contract of
62      * {@link Object#hashCode}.
63      *
64      *

65      * This implementation iterates over the set, calling the hashCode
66      * method on each element in the set, and adding up the results.
67      *
68      * @return the hash code value for this set
69      * @see Object#equals(Object)
70      * @see Set#equals(Object)
71      */
72     public int hashCode() {
73         int h = 0;
74         // 使用迭代器遍历所有的元素
75         Iterator<E> i = iterator();
76         while (i.hasNext()) {
77             E obj = i.next();
78             if (obj != null)
79                 // 加上每个元素的hashCode
80                 h += obj.hashCode();
81         }
82         return h;
83     }
84
85     /**
86      * Removes from this set all of its elements that are contained in the
87      * specified collection (optional operation). If the specified collection is
88      * also a set, this operation effectively modifies this set so that its
89      * value is the asymmetric set difference of the two sets.
90      *
91      *

92      * This implementation determines which is the smaller of this set and the
93      * specified collection, by invoking the size method on each. If
94      * this set has fewer elements, then the implementation iterates over this
95      * set, checking each element returned by the iterator in turn to see if it
96      * is contained in the specified collection. If it is so contained, it is
97      * removed from this set with the iterator's remove method. If the
98      * specified collection has fewer elements, then the implementation iterates
99      * over the specified collection, removing from this set each element
100      * returned by the iterator, using this set's remove method.
101      *
102      *

103      * Note that this implementation will throw an
104      * UnsupportedOperationException if the iterator returned by the
105      * iterator method does not implement the remove method.
106      *
107      * @param c
108      *            collection containing elements to be removed from this set
109      * @return true if this set changed as a result of the call
110      * @throws UnsupportedOperationException
111      *             if the removeAll operation is not supported by this
112      *             set
113      * @throws ClassCastException
114      *             if the class of an element of this set is incompatible with
115      *             the specified collection (optional)
116      * @throws NullPointerException
117      *             if this set contains a null element and the specified
118      *             collection does not permit null elements (optional), or if
119      *             the specified collection is null
120      * @see #remove(Object)
121      * @see #contains(Object)
122      */
123     public boolean removeAll(Collection c) {
124         boolean modified = false;
125
126         // 对元素少的集合使用迭代器
127         if (size() > c.size()) {
128             for (Iterator i = c.iterator(); i.hasNext();)
129                 // Set集合删除元素，记录操作是否成功
130                 modified |= remove(i.next());
131         } else {
132             for (Iterator i = iterator(); i.hasNext();) {
133                 if (c.contains(i.next())) {
134                 // 迭代器删除元素，记录成功
135                     i.remove();
136                     modified = true;
137                 }
138             }
139         }
140         return modified;
141     }
142
143 }
144

fred.li 2008-07-21 22:20 发表评论

SortedSet 接口分析

fred.li — Sun, 20 Jul 2008 13:24:00 GMT

java.util.SortedSet接口继承Set接口，分化出一类有序的Set集合。
SortedSet接口引入的新特性：

关联Comparator接口，支持对元素的排序
扩展了对构造方法的约定。因为接口不能定义构造方法，所以只能在文档中对接口实现类作出约定
提供有序Set衍生出的方法：subSet(from,end),first(),last()

必须注意的是，在SortedSet中使用的排序方法，Comparable或者是Comparator，必须和equals方法的含义一致，否则会出现“异常的”Set。因为SortedSet在插入元素的时候使用compare方法确定元素是否相同，如果出现了compare方法返回不相等（元素被插入），但是equals方法返回相等的情况，所实现的Set类对象就会不符合Set的原始定义。

fred.li 2008-07-20 21:24 发表评论

Set 接口分析

fred.li — Sun, 20 Jul 2008 09:16:00 GMT

java.util.Set接口继承了Collection接口，定义了没有重复元素的一类集合，也就是数学上的集合概念。
Set接口引入的新特性：

不允许添加重复元素，所以null元素最多有一个
不允许Set自包含
add(),equals(),hashCode()方法约定被修改，以支持元素唯一性

fred.li 2008-07-20 17:16 发表评论

List 接口分析

fred.li — Sun, 20 Jul 2008 08:59:00 GMT

java.util.List接口继承了Collection接口的，表达一种有序的集合。
List接口加入的新特性包括：

通过索引访问和修改元素，索引值从0开始
允许重复元素，包括null
提供ListIterator接口，支持双向遍历，元素的添加和修改

fred.li 2008-07-20 16:59 发表评论

Collection 接口分析

fred.li — Sun, 20 Jul 2008 07:21:00 GMT

Collection 接口是List和Set集合类的根，定义了List和Set诸多实现类的通用方法。
Collection 接口的继承关系图如下：

java.util.Collection

java.util.List
java.util.Queue

java.util.Deque

java.util.Set

java.util.SortedSet

java.util.NavigableSet

Collection 接口的方法定义参见JDK文档。

fred.li 2008-07-20 15:21 发表评论

HashSet 类分析

fred.li — Sat, 19 Jul 2008 13:35:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --> 1 package java.util; 2 3 public ... 阅读全文

fred.li 2008-07-19 21:35 发表评论

Iterator和ListIterator接口分析

fred.li — Sat, 19 Jul 2008 03:53:00 GMT

Iterator接口定义了遍历集合类对象的通用方法，不同的集合类有不同的Iterator实现类，实现接口中的抽象方法。有了Iterator接口，可以用统一的方式对各种集合元素进行遍历和迭代，方便程序的修改。
Iterator接口中包括的方法有：

1 public interface Iterator<E> {
2     /**
3      * Returns true if the iteration has more elements. (In other
4      * words, returns true if next would return an element
5      * rather than throwing an exception.)
6      *
7      * @return true if the iterator has more elements.
8      */
9     boolean hasNext();
10
11     /**
12      * Returns the next element in the iteration.
13      *
14      * @return the next element in the iteration.
15      * @exception NoSuchElementException iteration has no more elements.
16      */
17     E next();
18
19     /**
20      *
21      * Removes from the underlying collection the last element returned by the
22      * iterator (optional operation).  This method can be called only once per
23      * call to next.  The behavior of an iterator is unspecified if
24      * the underlying collection is modified while the iteration is in
25      * progress in any way other than by calling this method.
26      *
27      * @exception UnsupportedOperationException if the remove
28      *          operation is not supported by this Iterator.
29
30      * @exception IllegalStateException if the next method has not
31      *          yet been called, or the remove method has already
32      *          been called after the last call to the next
33      *          method.
34      */
35     void remove();
36 }

ListIterator接口扩展了Iterator接口，定义了更多的访问方法。不仅可以向前遍历，还可以向后遍历，添加、修改元素。ListIterator接口中包括的方法有：

  1 public interface ListIterator<E> extends Iterator<E> {
  2     // Query Operations
  3
  4     /**
  5      * Returns true if this list iterator has more elements when
  6      * traversing the list in the forward direction. (In other words, returns
  7      * true if next would return an element rather than
  8      * throwing an exception.)
  9      *
10      * @return true if the list iterator has more elements when
11      *        traversing the list in the forward direction.
12      */
13     boolean hasNext();
14
15     /**
16      * Returns the next element in the list.  This method may be called
17      * repeatedly to iterate through the list, or intermixed with calls to
18      * previous to go back and forth.  (Note that alternating calls
19      * to next and previous will return the same element
20      * repeatedly.)
21      *
22      * @return the next element in the list.
23      * @exception NoSuchElementException if the iteration has no next element.
24      */
25     E next();
26
27     /**
28      * Returns true if this list iterator has more elements when
29      * traversing the list in the reverse direction.  (In other words, returns
30      * true if previous would return an element rather than
31      * throwing an exception.)
32      *
33      * @return true if the list iterator has more elements when
34      *           traversing the list in the reverse direction.
35      */
36     boolean hasPrevious();
37
38     /**
39      * Returns the previous element in the list.  This method may be called
40      * repeatedly to iterate through the list backwards, or intermixed with
41      * calls to next to go back and forth.  (Note that alternating
42      * calls to next and previous will return the same
43      * element repeatedly.)
44      *
45      * @return the previous element in the list.
46      *
47      * @exception NoSuchElementException if the iteration has no previous
48      *            element.
49      */
50     E previous();
51
52     /**
53      * Returns the index of the element that would be returned by a subsequent
54      * call to next. (Returns list size if the list iterator is at the
55      * end of the list.)
56      *
57      * @return the index of the element that would be returned by a subsequent
58      *            call to next, or list size if list iterator is at end
59      *           of list.
60      */
61     int nextIndex();
62
63     /**
64      * Returns the index of the element that would be returned by a subsequent
65      * call to previous. (Returns -1 if the list iterator is at the
66      * beginning of the list.)
67      *
68      * @return the index of the element that would be returned by a subsequent
69      *            call to previous, or -1 if list iterator is at
70      *           beginning of list.
71      */
72     int previousIndex();
73
74
75     // Modification Operations
76
77     /**
78      * Removes from the list the last element that was returned by
79      * next or previous (optional operation).  This call can
80      * only be made once per call to next or previous.  It
81      * can be made only if ListIterator.add has not been called after
82      * the last call to next or previous.
83      *
84      * @exception UnsupportedOperationException if the remove
85      *            operation is not supported by this list iterator.
86      * @exception IllegalStateException neither next nor
87      *            previous have been called, or remove or
88      *            add have been called after the last call to
89      *            next or previous.
90      */
91     void remove();
92
93     /**
94      * Replaces the last element returned by next or
95      * previous with the specified element (optional operation).
96      * This call can be made only if neither ListIterator.remove nor
97      * ListIterator.add have been called after the last call to
98      * next or previous.
99      *
100      * @param e the element with which to replace the last element returned by
101      *          next or previous.
102      * @exception UnsupportedOperationException if the set operation
103      *           is not supported by this list iterator.
104      * @exception ClassCastException if the class of the specified element
105      *           prevents it from being added to this list.
106      * @exception IllegalArgumentException if some aspect of the specified
107      *          element prevents it from being added to this list.
108      * @exception IllegalStateException if neither next nor
109      *              previous have been called, or remove or
110      *          add have been called after the last call to
111      *           next or previous.
112      */
113     void set(E e);
114
115     /**
116      * Inserts the specified element into the list (optional operation).  The
117      * element is inserted immediately before the next element that would be
118      * returned by next, if any, and after the next element that
119      * would be returned by previous, if any.  (If the list contains
120      * no elements, the new element becomes the sole element on the list.)
121      * The new element is inserted before the implicit cursor: a subsequent
122      * call to next would be unaffected, and a subsequent call to
123      * previous would return the new element.  (This call increases
124      * by one the value that would be returned by a call to nextIndex
125      * or previousIndex.)
126      *
127      * @param e the element to insert.
128      * @exception UnsupportedOperationException if the add method is
129      *           not supported by this list iterator.
130      *
131      * @exception ClassCastException if the class of the specified element
132      *           prevents it from being added to this list.
133      *
134      * @exception IllegalArgumentException if some aspect of this element
135      *            prevents it from being added to this list.
136      */
137     void add(E e);
138 }

fred.li 2008-07-19 11:53 发表评论

LinkedList 类分析

fred.li — Fri, 18 Jul 2008 08:48:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --> 1 package java.util; 2 3... 阅读全文

fred.li 2008-07-18 16:48 发表评论