www.久久久久久久久,久久国产精品免费一区二区三区,欧美一区久久久

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

摘要: TreeSet �c�d��C�� NavigableSet 接口�Q�是一�U�有序的Set集合�Q? 必须提供元素的排序方法：自然排序�Q�或者在构造方法中提供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 接口�l�承�?SortedSet 接口�Q�在排序Set的基��上支持更多的查找功能�?br /> NavigableSet 接口的新�Ҏ��：

higher()、lower()�Ҏ��可以�q�回大于、小于指定元素的最�q�元�?/li>
descendingSet()、descendingIterator()�Ҏ��可以按照排序�l�果的逆向遍历元素
subSet()、headSet()、tailSet()�q�些�Ҏ��中可以传入参敎ͼ�指定是否包括��_��）元素

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

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

java.util.AbstractSet抽象�cȝ��承自 AbstractCollection 抽象�c�，所有Set的实现类都直接或者间接��承AbstractSet父类�?br /> AbstractSet�c�d��括equals(),hashCode(),removeAll(c)�Ҏ��Q�这些方法都被实��C��Q�子�c�L��需再重写�?br /> AbstractSet�c�L��供了实现Set集合的基本框�Ӟ��方便HashSet、TreeSet�q�些子类的实现�?br />

  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�c�？
37         if (!(o instanceof Set))
38             return false;
39
40         Collection c = (Collection) o;
41         // 先比较大��?/span>
42         if (c.size() != size())
43             return false;
44         try {
45         // 再比较所有的元素
46             return containsAll(c);
47         // 处理containsAll(c)抛出的异�?/span>
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         // 使用�q�代器遍历所有的元素
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         // 对元素少的集合��用�P代器
127         if (size() > c.size()) {
128             for (Iterator i = c.iterator(); i.hasNext();)
129                 // Set集合删除元素�Q�记录操作是否成�?/span>
130                 modified |= remove(i.next());
131         } else {
132             for (Iterator i = iterator(); i.hasNext();) {
133                 if (c.contains(i.next())) {
134                 // �q�代器删除元素，记录成功
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接口�l�承Set接口�Q�分化出一�c�L��序的Set集合�?br /> SortedSet接口引入的新�Ҏ��：

兌��Comparator接口�Q�支持对元素的排�?/li>
扩展了对构造方法的�U�定。因为接口不能定义构造方法，所以只能在文档中对接口实现�c�M��出约�?/li>
提供有序Set衍生出的�Ҏ��Q�subSet(from,end),first(),last()

必须注意的是�Q�在SortedSet中��用的排序�Ҏ��Q�Comparable或者是Comparator�Q�必��d��equals�Ҏ��的含义一��_��否则会出�?#8220;异常�?#8221;Set。因为SortedSet在插入元素的时候��用compare�Ҏ��定元素是否相同�Q�如果出��C��compare�Ҏ��q�回不相�{�（元素被插入）�Q�但是equals�Ҏ��q�回相等的情况，所实现的Set�c�d��象就会不�W�合Set的原始定义�?br />

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

Set 接口分析

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

java.util.Set接口�l�承了Collection接口�Q�定义了没有重复元素的一�c�集合，也就是数学上的集合概��c�?br /> Set接口引入的新�Ҏ��：

不允许添加重复元素，所以null元素最多有一�?/li>
不允许Set自包�?/li>
add(),equals(),hashCode()�Ҏ��U�定被修改，以支持元素唯一�?br />

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

List 接口分析

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

java.util.List接口�l�承了Collection接口的，表达一�U�有序的集合�?br /> List接口加入的新�Ҏ��包括：

通过索引讉K��和修改元素，索引��g��0开�?/li>
允许重复元素�Q�包括null
提供ListIterator接口�Q�支持双向遍历，元素的添加和修改

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

Collection 接口分析

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

Collection 接口是List和Set集合�cȝ��根，定义了List和Set诸多实现�cȝ��通用�Ҏ��?br /> Collection 接口的��承关�p�d��如下�Q?br />
java.util.Collection

java.util.List
java.util.Queue

java.util.Deque

java.util.Set

java.util.SortedSet

java.util.NavigableSet

Collection 接口的方法定义参见JDK文��?br />

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

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接口定义了遍历集合类对象的通用�Ҏ��Q�不同的集合�c�L��不同的Iterator实现�c�，实现接口中的抽象�Ҏ��。有了Iterator接口�Q�可以用�l�一的方式对各种集合元素�q�行遍历和�P代，方便�E�序的修攏V�?br /> 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接口�Q�定义了更多的访问方法。不仅可以向前遍历，�q�可以向后遍历，��d��、修改元素。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 发表评论

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 发表评论