java-AbstractCollection类-源码解析

  1 package java.util;
  2  
  3 public abstract class AbstractCollection<E> implements Collection<E> {
  4  
  5     protected AbstractCollection() {
  6     }
  7  
  8     public abstract Iterator<E> iterator();
  9  
 10     public abstract int size();
 11  
 12     //判断集合中是否有数据
 13     public boolean isEmpty() {
 14         return size() == 0;
 15     }
 16  
 17     /**
 18      * 判断是否包含指定的元素
 19      * （1）如果参数为null，查找值为null的元素，如果存在，返回true，否则返回false。
 20      * （2）如果参数不为null，则根据equals方法查找与参数相等的元素，如果存在，则返回true，否则返回false。
 21      * 注意：这里必须对null单独处理，否则null.equals会报空指针异常
 22      */
 23     public boolean contains(Object o) {
 24         Iterator<E> it = iterator();
 25         if (o==null) {
 26             while (it.hasNext())
 27                 if (it.next()==null)
 28                     return true;
 29         } else {
 30             while (it.hasNext())
 31                 if (o.equals(it.next()))
 32                     return true;
 33         }
 34         return false;
 35     }
 36  
 37     /**
 38      * 功能：将集合元素转换为数组
 39      * 实现：
 40      * （1）创建一个数组，大小为集合中元素的数量
 41      * （2）通过迭代器遍历集合，将当前集合中的元素复制到数组中（复制引用）
 42      * （3）如果集合中元素比预期的少，则调用Arrays.copyOf()方法将数组的元素复制到新数组中，并返回新数组，Arrays.copyOf的源码在后续文章中会分析.
 43      * （4）如果集合中元素比预期的多，则调用finishToArray方法生成新数组，并返回新数组，否则返回（1）中创建的数组
 44      */
 45     public Object[] toArray() {
 46         Object[] r = new Object[size()];
 47         Iterator<E> it = iterator();
 48         for (int i = 0; i < r.length; i++) {
 49             if (! it.hasNext()) // fewer elements than expected
 50                 return Arrays.copyOf(r, i);
 51             r[i] = it.next();
 52         }
 53         return it.hasNext() ? finishToArray(r, it) : r;
 54     }
 55  
 56     /**
 57      * 功能：通过泛型约束返回指定类型的数组
 58      * 实现：
 59      * （1）如果传入数组的长度的长度大于等于集合的长度，则将当前集合的元素复制到传入的数组中
 60      * （2）如果传入数组的长度小于集合的大小，则将创建一个新的数组来进行集合元素的存储
 61      */
 62     public <T> T[] toArray(T[] a) {
 63         // Estimate size of array; be prepared to see more or fewer elements
 64         int size = size();
 65         T[] r = a.length >= size ? a :
 66                   (T[])java.lang.reflect.Array
 67                   .newInstance(a.getClass().getComponentType(), size);
 68         Iterator<E> it = iterator();
 69  
 70         for (int i = 0; i < r.length; i++) {
 71             //集合元素大小小于数组的长度
 72             if (! it.hasNext()) { // fewer elements than expected
 73                 if (a == r) {//如果数组是参数中的数组，则将剩余部分的值都设置为null
 74                     r[i] = null; // null-terminate
 75                 } else if (a.length < i) {//如果传入的数组长度小于集合长度，则通过Arrays.copyOf将之前数组中的元素复制到新数组中
 76                     return Arrays.copyOf(r, i);
 77                 } else {//如果传入数组的长度比集合大，则将多的元素设置为空
 78                     System.arraycopy(r, 0, a, 0, i);
 79                     if (a.length > i) {
 80                         a[i] = null;
 81                     }
 82                 }
 83                 return a;
 84             }
 85             r[i] = (T)it.next();
 86         }
 87         // more elements than expected
 88         //集合元素大小大于数组的长度
 89         return it.hasNext() ? finishToArray(r, it) : r;
 90     }
 91  
 92     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 93  
 94     /**
 95      *  功能：数组扩容
 96      *  （1）当数组索引指向最后一个元素+1时，对数组进行扩容：即创建一个更长的数组，然后将原数组的内容复制到新数组中
 97      *  （2）扩容大小：cap + cap/2 +1
 98      *  （3）扩容前需要先判断是否数组长度是否溢出
 99      *  注意：这里的迭代器是从上层的方法（toArray）传过来的，并且这个迭代器已执行了一部分，而不是从头开始迭代的
100      */
101     private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
102         int i = r.length;
103         while (it.hasNext()) {
104             int cap = r.length;
105             if (i == cap) {
106                 int newCap = cap + (cap >> 1) + 1;
107                 // overflow-conscious code
108                 if (newCap - MAX_ARRAY_SIZE > 0)
109                     newCap = hugeCapacity(cap + 1);
110                 r = Arrays.copyOf(r, newCap);
111             }
112             r[i++] = (T)it.next();
113         }
114         // trim if overallocated
115         return (i == r.length) ? r : Arrays.copyOf(r, i);
116     }
117  
118     /**
119      * 判断数组容量是否溢出，最大为整型数据的最大值
120      */
121     private static int hugeCapacity(int minCapacity) {
122         if (minCapacity < 0) // overflow
123             throw new OutOfMemoryError
124                 ("Required array size too large");
125         return (minCapacity > MAX_ARRAY_SIZE) ?
126             Integer.MAX_VALUE :
127             MAX_ARRAY_SIZE;
128     }
129  
130     /**
131      * 未实现
132      */
133     public boolean add(E e) {
134         throw new UnsupportedOperationException();
135     }
136  
137     /**
138      * 功能：移除指定元素
139      * （1）如果参数为null，则找到第一个值为null的元素，并将其删除，返回true，如果不存在null的元素，返回false。
140      * （2）如果参数不为null，则根据equals方法找到第一个与参数相等的元素，并将其删除，返回true，如果找不到，返回false。
141      */
142     public boolean remove(Object o) {
143         Iterator<E> it = iterator();
144         if (o==null) {
145             while (it.hasNext()) {
146                 if (it.next()==null) {
147                     it.remove();
148                     return true;
149                 }
150             }
151         } else {
152             while (it.hasNext()) {
153                 if (o.equals(it.next())) {
154                     it.remove();
155                     return true;
156                 }
157             }
158         }
159         return false;
160     }
161  
162     /**
163      * 遍历参数集合，依次判断参数集合中的元素是否在当前集合中，
164      * 只要有一个不存在，则返回false
165      * 如果参数集合中所有的元素都在当前集合中，则返回true
166      */
167     public boolean containsAll(Collection<?> c) {
168         for (Object e : c)
169             if (!contains(e))
170                 return false;
171         return true;
172     }
173  
174     /**
175      * 遍历参数集合，依次将参数集合中的元素添加当前集合中
176      */
177     public boolean addAll(Collection<? extends E> c) {
178         boolean modified = false;
179         for (E e : c)
180             if (add(e))
181                 modified = true;
182         return modified;
183     }
184  
185     /**
186      * 功能：移除参数集合的元素
187      * （1）获取当前集合的迭代器进行遍历
188      * （2）如果当前集合中的元素包含在参数集合中，则删除当前集合中的元素
189      *  注：只要参数集合中有任何一个元素在当前元素中，则返回true，表示当前集合有发送变化，否则返回false。
190      */
191     public boolean removeAll(Collection<?> c) {
192         boolean modified = false;
193         Iterator<?> it = iterator();
194         while (it.hasNext()) {
195             if (c.contains(it.next())) {
196                 it.remove();
197                 modified = true;
198             }
199         }
200         return modified;
201     }
202  
203     /***
204      * 功能：求参数集合与当前集合的交集
205      * （1）获取当前集合的迭代器进行遍历
206      * （2）如果当前集合中的元素不在参数集合中，则将其移除。
207      *  注意：如果当前集合是参数集合中的子集，则返回false，表示当前集合未发送变化，否则返回true。
208      */
209     public boolean retainAll(Collection<?> c) {
210         boolean modified = false;
211         Iterator<E> it = iterator();
212         while (it.hasNext()) {
213             if (!c.contains(it.next())) {
214                 it.remove();
215                 modified = true;
216             }
217         }
218         return modified;
219     }
220  
221     //删除所有元素
222     public void clear() {
223         Iterator<E> it = iterator();
224         while (it.hasNext()) {
225             it.next();
226             it.remove();
227         }
228     }
229  
230  
231     public String toString() {
232         Iterator<E> it = iterator();
233         if (! it.hasNext())
234             return "[]";
235  
236         StringBuilder sb = new StringBuilder();
237         sb.append(‘[‘);
238         for (;;) {
239             E e = it.next();
240             sb.append(e == this ? "(this Collection)" : e);
241             if (! it.hasNext())
242                 return sb.append(‘]‘).toString();
243             sb.append(‘,‘).append(‘ ‘);
244         }
245     }
246  
247 }