Showing the changes to java/pkg/java/util/Collection.java (1 of 18352 files). Show all
Unified · Split
| @@ -0,0 +1,456 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. | ||
| 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | ||
| 4 | * | ||
| 5 | * This code is free software; you can redistribute it and/or modify it | ||
| 6 | * under the terms of the GNU General Public License version 2 only, as | ||
| 7 | * published by the Free Software Foundation. Oracle designates this | ||
| 8 | * particular file as subject to the "Classpath" exception as provided | ||
| 9 | * by Oracle in the LICENSE file that accompanied this code. | ||
| 10 | * | ||
| 11 | * This code is distributed in the hope that it will be useful, but WITHOUT | ||
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
| 14 | * version 2 for more details (a copy is included in the LICENSE file that | ||
| 15 | * accompanied this code). | ||
| 16 | * | ||
| 17 | * You should have received a copy of the GNU General Public License version | ||
| 18 | * 2 along with this work; if not, write to the Free Software Foundation, | ||
| 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| 20 | * | ||
| 21 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | ||
| 22 | * or visit www.oracle.com if you need additional information or have any | ||
| 23 | * questions. | ||
| 24 | */ | ||
| 25 | |||
| 26 | package java.util; | ||
| 27 | |||
| 28 | /** | ||
| 29 | * The root interface in the <i>collection hierarchy</i>. A collection | ||
| 30 | * represents a group of objects, known as its <i>elements</i>. Some | ||
| 31 | * collections allow duplicate elements and others do not. Some are ordered | ||
| 32 | * and others unordered. The JDK does not provide any <i>direct</i> | ||
| 33 | * implementations of this interface: it provides implementations of more | ||
| 34 | * specific subinterfaces like <tt>Set</tt> and <tt>List</tt>. This interface | ||
| 35 | * is typically used to pass collections around and manipulate them where | ||
| 36 | * maximum generality is desired. | ||
| 37 | * | ||
| 38 | * <p><i>Bags</i> or <i>multisets</i> (unordered collections that may contain | ||
| 39 | * duplicate elements) should implement this interface directly. | ||
| 40 | * | ||
| 41 | * <p>All general-purpose <tt>Collection</tt> implementation classes (which | ||
| 42 | * typically implement <tt>Collection</tt> indirectly through one of its | ||
| 43 | * subinterfaces) should provide two "standard" constructors: a void (no | ||
| 44 | * arguments) constructor, which creates an empty collection, and a | ||
| 45 | * constructor with a single argument of type <tt>Collection</tt>, which | ||
| 46 | * creates a new collection with the same elements as its argument. In | ||
| 47 | * effect, the latter constructor allows the user to copy any collection, | ||
| 48 | * producing an equivalent collection of the desired implementation type. | ||
| 49 | * There is no way to enforce this convention (as interfaces cannot contain | ||
| 50 | * constructors) but all of the general-purpose <tt>Collection</tt> | ||
| 51 | * implementations in the Java platform libraries comply. | ||
| 52 | * | ||
| 53 | * <p>The "destructive" methods contained in this interface, that is, the | ||
| 54 | * methods that modify the collection on which they operate, are specified to | ||
| 55 | * throw <tt>UnsupportedOperationException</tt> if this collection does not | ||
| 56 | * support the operation. If this is the case, these methods may, but are not | ||
| 57 | * required to, throw an <tt>UnsupportedOperationException</tt> if the | ||
| 58 | * invocation would have no effect on the collection. For example, invoking | ||
| 59 | * the {@link #addAll(Collection)} method on an unmodifiable collection may, | ||
| 60 | * but is not required to, throw the exception if the collection to be added | ||
| 61 | * is empty. | ||
| 62 | * | ||
| 63 | * <p><a name="optional-restrictions"/> | ||
| 64 | * Some collection implementations have restrictions on the elements that | ||
| 65 | * they may contain. For example, some implementations prohibit null elements, | ||
| 66 | * and some have restrictions on the types of their elements. Attempting to | ||
| 67 | * add an ineligible element throws an unchecked exception, typically | ||
| 68 | * <tt>NullPointerException</tt> or <tt>ClassCastException</tt>. Attempting | ||
| 69 | * to query the presence of an ineligible element may throw an exception, | ||
| 70 | * or it may simply return false; some implementations will exhibit the former | ||
| 71 | * behavior and some will exhibit the latter. More generally, attempting an | ||
| 72 | * operation on an ineligible element whose completion would not result in | ||
| 73 | * the insertion of an ineligible element into the collection may throw an | ||
| 74 | * exception or it may succeed, at the option of the implementation. | ||
| 75 | * Such exceptions are marked as "optional" in the specification for this | ||
| 76 | * interface. | ||
| 77 | * | ||
| 78 | * <p>It is up to each collection to determine its own synchronization | ||
| 79 | * policy. In the absence of a stronger guarantee by the | ||
| 80 | * implementation, undefined behavior may result from the invocation | ||
| 81 | * of any method on a collection that is being mutated by another | ||
| 82 | * thread; this includes direct invocations, passing the collection to | ||
| 83 | * a method that might perform invocations, and using an existing | ||
| 84 | * iterator to examine the collection. | ||
| 85 | * | ||
| 86 | * <p>Many methods in Collections Framework interfaces are defined in | ||
| 87 | * terms of the {@link Object#equals(Object) equals} method. For example, | ||
| 88 | * the specification for the {@link #contains(Object) contains(Object o)} | ||
| 89 | * method says: "returns <tt>true</tt> if and only if this collection | ||
| 90 | * contains at least one element <tt>e</tt> such that | ||
| 91 | * <tt>(o==null ? e==null : o.equals(e))</tt>." This specification should | ||
| 92 | * <i>not</i> be construed to imply that invoking <tt>Collection.contains</tt> | ||
| 93 | * with a non-null argument <tt>o</tt> will cause <tt>o.equals(e)</tt> to be | ||
| 94 | * invoked for any element <tt>e</tt>. Implementations are free to implement | ||
| 95 | * optimizations whereby the <tt>equals</tt> invocation is avoided, for | ||
| 96 | * example, by first comparing the hash codes of the two elements. (The | ||
| 97 | * {@link Object#hashCode()} specification guarantees that two objects with | ||
| 98 | * unequal hash codes cannot be equal.) More generally, implementations of | ||
| 99 | * the various Collections Framework interfaces are free to take advantage of | ||
| 100 | * the specified behavior of underlying {@link Object} methods wherever the | ||
| 101 | * implementor deems it appropriate. | ||
| 102 | * | ||
| 103 | * <p>This interface is a member of the | ||
| 104 | * <a href="{@docRoot}/../technotes/guides/collections/index.html"> | ||
| 105 | * Java Collections Framework</a>. | ||
| 106 | * | ||
| 107 | * @param <E> the type of elements in this collection | ||
| 108 | * | ||
| 109 | * @author Josh Bloch | ||
| 110 | * @author Neal Gafter | ||
| 111 | * @see Set | ||
| 112 | * @see List | ||
| 113 | * @see Map | ||
| 114 | * @see SortedSet | ||
| 115 | * @see SortedMap | ||
| 116 | * @see HashSet | ||
| 117 | * @see TreeSet | ||
| 118 | * @see ArrayList | ||
| 119 | * @see LinkedList | ||
| 120 | * @see Vector | ||
| 121 | * @see Collections | ||
| 122 | * @see Arrays | ||
| 123 | * @see AbstractCollection | ||
| 124 | * @since 1.2 | ||
| 125 | */ | ||
| 126 | |||
| 127 | public interface Collection<E> extends Iterable<E> { | ||
| 128 | // Query Operations | ||
| 129 | |||
| 130 | /** | ||
| 131 | * Returns the number of elements in this collection. If this collection | ||
| 132 | * contains more than <tt>Integer.MAX_VALUE</tt> elements, returns | ||
| 133 | * <tt>Integer.MAX_VALUE</tt>. | ||
| 134 | * | ||
| 135 | * @return the number of elements in this collection | ||
| 136 | */ | ||
| 137 | int size(); | ||
| 138 | |||
| 139 | /** | ||
| 140 | * Returns <tt>true</tt> if this collection contains no elements. | ||
| 141 | * | ||
| 142 | * @return <tt>true</tt> if this collection contains no elements | ||
| 143 | */ | ||
| 144 | boolean isEmpty(); | ||
| 145 | |||
| 146 | /** | ||
| 147 | * Returns <tt>true</tt> if this collection contains the specified element. | ||
| 148 | * More formally, returns <tt>true</tt> if and only if this collection | ||
| 149 | * contains at least one element <tt>e</tt> such that | ||
| 150 | * <tt>(o==null ? e==null : o.equals(e))</tt>. | ||
| 151 | * | ||
| 152 | * @param o element whose presence in this collection is to be tested | ||
| 153 | * @return <tt>true</tt> if this collection contains the specified | ||
| 154 | * element | ||
| 155 | * @throws ClassCastException if the type of the specified element | ||
| 156 | * is incompatible with this collection | ||
| 157 | * (<a href="#optional-restrictions">optional</a>) | ||
| 158 | * @throws NullPointerException if the specified element is null and this | ||
| 159 | * collection does not permit null elements | ||
| 160 | * (<a href="#optional-restrictions">optional</a>) | ||
| 161 | */ | ||
| 162 | boolean contains(Object o); | ||
| 163 | |||
| 164 | /** | ||
| 165 | * Returns an iterator over the elements in this collection. There are no | ||
| 166 | * guarantees concerning the order in which the elements are returned | ||
| 167 | * (unless this collection is an instance of some class that provides a | ||
| 168 | * guarantee). | ||
| 169 | * | ||
| 170 | * @return an <tt>Iterator</tt> over the elements in this collection | ||
| 171 | */ | ||
| 172 | Iterator<E> iterator(); | ||
| 173 | |||
| 174 | /** | ||
| 175 | * Returns an array containing all of the elements in this collection. | ||
| 176 | * If this collection makes any guarantees as to what order its elements | ||
| 177 | * are returned by its iterator, this method must return the elements in | ||
| 178 | * the same order. | ||
| 179 | * | ||
| 180 | * <p>The returned array will be "safe" in that no references to it are | ||
| 181 | * maintained by this collection. (In other words, this method must | ||
| 182 | * allocate a new array even if this collection is backed by an array). | ||
| 183 | * The caller is thus free to modify the returned array. | ||
| 184 | * | ||
| 185 | * <p>This method acts as bridge between array-based and collection-based | ||
| 186 | * APIs. | ||
| 187 | * | ||
| 188 | * @return an array containing all of the elements in this collection | ||
| 189 | */ | ||
| 190 | Object[] toArray(); | ||
| 191 | |||
| 192 | /** | ||
| 193 | * Returns an array containing all of the elements in this collection; | ||
| 194 | * the runtime type of the returned array is that of the specified array. | ||
| 195 | * If the collection fits in the specified array, it is returned therein. | ||
| 196 | * Otherwise, a new array is allocated with the runtime type of the | ||
| 197 | * specified array and the size of this collection. | ||
| 198 | * | ||
| 199 | * <p>If this collection fits in the specified array with room to spare | ||
| 200 | * (i.e., the array has more elements than this collection), the element | ||
| 201 | * in the array immediately following the end of the collection is set to | ||
| 202 | * <tt>null</tt>. (This is useful in determining the length of this | ||
| 203 | * collection <i>only</i> if the caller knows that this collection does | ||
| 204 | * not contain any <tt>null</tt> elements.) | ||
| 205 | * | ||
| 206 | * <p>If this collection makes any guarantees as to what order its elements | ||
| 207 | * are returned by its iterator, this method must return the elements in | ||
| 208 | * the same order. | ||
| 209 | * | ||
| 210 | * <p>Like the {@link #toArray()} method, this method acts as bridge between | ||
| 211 | * array-based and collection-based APIs. Further, this method allows | ||
| 212 | * precise control over the runtime type of the output array, and may, | ||
| 213 | * under certain circumstances, be used to save allocation costs. | ||
| 214 | * | ||
| 215 | * <p>Suppose <tt>x</tt> is a collection known to contain only strings. | ||
| 216 | * The following code can be used to dump the collection into a newly | ||
| 217 | * allocated array of <tt>String</tt>: | ||
| 218 | * | ||
| 219 | * <pre> | ||
| 220 | * String[] y = x.toArray(new String[0]);</pre> | ||
| 221 | * | ||
| 222 | * Note that <tt>toArray(new Object[0])</tt> is identical in function to | ||
| 223 | * <tt>toArray()</tt>. | ||
| 224 | * | ||
| 225 | * @param a the array into which the elements of this collection are to be | ||
| 226 | * stored, if it is big enough; otherwise, a new array of the same | ||
| 227 | * runtime type is allocated for this purpose. | ||
| 228 | * @return an array containing all of the elements in this collection | ||
| 229 | * @throws ArrayStoreException if the runtime type of the specified array | ||
| 230 | * is not a supertype of the runtime type of every element in | ||
| 231 | * this collection | ||
| 232 | * @throws NullPointerException if the specified array is null | ||
| 233 | */ | ||
| 234 | <T> T[] toArray(T[] a); | ||
| 235 | |||
| 236 | // Modification Operations | ||
| 237 | |||
| 238 | /** | ||
| 239 | * Ensures that this collection contains the specified element (optional | ||
| 240 | * operation). Returns <tt>true</tt> if this collection changed as a | ||
| 241 | * result of the call. (Returns <tt>false</tt> if this collection does | ||
| 242 | * not permit duplicates and already contains the specified element.)<p> | ||
| 243 | * | ||
| 244 | * Collections that support this operation may place limitations on what | ||
| 245 | * elements may be added to this collection. In particular, some | ||
| 246 | * collections will refuse to add <tt>null</tt> elements, and others will | ||
| 247 | * impose restrictions on the type of elements that may be added. | ||
| 248 | * Collection classes should clearly specify in their documentation any | ||
| 249 | * restrictions on what elements may be added.<p> | ||
| 250 | * | ||
| 251 | * If a collection refuses to add a particular element for any reason | ||
| 252 | * other than that it already contains the element, it <i>must</i> throw | ||
| 253 | * an exception (rather than returning <tt>false</tt>). This preserves | ||
| 254 | * the invariant that a collection always contains the specified element | ||
| 255 | * after this call returns. | ||
| 256 | * | ||
| 257 | * @param e element whose presence in this collection is to be ensured | ||
| 258 | * @return <tt>true</tt> if this collection changed as a result of the | ||
| 259 | * call | ||
| 260 | * @throws UnsupportedOperationException if the <tt>add</tt> operation | ||
| 261 | * is not supported by this collection | ||
| 262 | * @throws ClassCastException if the class of the specified element | ||
| 263 | * prevents it from being added to this collection | ||
| 264 | * @throws NullPointerException if the specified element is null and this | ||
| 265 | * collection does not permit null elements | ||
| 266 | * @throws IllegalArgumentException if some property of the element | ||
| 267 | * prevents it from being added to this collection | ||
| 268 | * @throws IllegalStateException if the element cannot be added at this | ||
| 269 | * time due to insertion restrictions | ||
| 270 | */ | ||
| 271 | boolean add(E e); | ||
| 272 | |||
| 273 | /** | ||
| 274 | * Removes a single instance of the specified element from this | ||
| 275 | * collection, if it is present (optional operation). More formally, | ||
| 276 | * removes an element <tt>e</tt> such that | ||
| 277 | * <tt>(o==null ? e==null : o.equals(e))</tt>, if | ||
| 278 | * this collection contains one or more such elements. Returns | ||
| 279 | * <tt>true</tt> if this collection contained the specified element (or | ||
| 280 | * equivalently, if this collection changed as a result of the call). | ||
| 281 | * | ||
| 282 | * @param o element to be removed from this collection, if present | ||
| 283 | * @return <tt>true</tt> if an element was removed as a result of this call | ||
| 284 | * @throws ClassCastException if the type of the specified element | ||
| 285 | * is incompatible with this collection | ||
| 286 | * (<a href="#optional-restrictions">optional</a>) | ||
| 287 | * @throws NullPointerException if the specified element is null and this | ||
| 288 | * collection does not permit null elements | ||
| 289 | * (<a href="#optional-restrictions">optional</a>) | ||
| 290 | * @throws UnsupportedOperationException if the <tt>remove</tt> operation | ||
| 291 | * is not supported by this collection | ||
| 292 | */ | ||
| 293 | boolean remove(Object o); | ||
| 294 | |||
| 295 | |||
| 296 | // Bulk Operations | ||
| 297 | |||
| 298 | /** | ||
| 299 | * Returns <tt>true</tt> if this collection contains all of the elements | ||
| 300 | * in the specified collection. | ||
| 301 | * | ||
| 302 | * @param c collection to be checked for containment in this collection | ||
| 303 | * @return <tt>true</tt> if this collection contains all of the elements | ||
| 304 | * in the specified collection | ||
| 305 | * @throws ClassCastException if the types of one or more elements | ||
| 306 | * in the specified collection are incompatible with this | ||
| 307 | * collection | ||
| 308 | * (<a href="#optional-restrictions">optional</a>) | ||
| 309 | * @throws NullPointerException if the specified collection contains one | ||
| 310 | * or more null elements and this collection does not permit null | ||
| 311 | * elements | ||
| 312 | * (<a href="#optional-restrictions">optional</a>), | ||
| 313 | * or if the specified collection is null. | ||
| 314 | * @see #contains(Object) | ||
| 315 | */ | ||
| 316 | boolean containsAll(Collection<?> c); | ||
| 317 | |||
| 318 | /** | ||
| 319 | * Adds all of the elements in the specified collection to this collection | ||
| 320 | * (optional operation). The behavior of this operation is undefined if | ||
| 321 | * the specified collection is modified while the operation is in progress. | ||
| 322 | * (This implies that the behavior of this call is undefined if the | ||
| 323 | * specified collection is this collection, and this collection is | ||
| 324 | * nonempty.) | ||
| 325 | * | ||
| 326 | * @param c collection containing elements to be added to this collection | ||
| 327 | * @return <tt>true</tt> if this collection changed as a result of the call | ||
| 328 | * @throws UnsupportedOperationException if the <tt>addAll</tt> operation | ||
| 329 | * is not supported by this collection | ||
| 330 | * @throws ClassCastException if the class of an element of the specified | ||
| 331 | * collection prevents it from being added to this collection | ||
| 332 | * @throws NullPointerException if the specified collection contains a | ||
| 333 | * null element and this collection does not permit null elements, | ||
| 334 | * or if the specified collection is null | ||
| 335 | * @throws IllegalArgumentException if some property of an element of the | ||
| 336 | * specified collection prevents it from being added to this | ||
| 337 | * collection | ||
| 338 | * @throws IllegalStateException if not all the elements can be added at | ||
| 339 | * this time due to insertion restrictions | ||
| 340 | * @see #add(Object) | ||
| 341 | */ | ||
| 342 | boolean addAll(Collection<? extends E> c); | ||
| 343 | |||
| 344 | /** | ||
| 345 | * Removes all of this collection's elements that are also contained in the | ||
| 346 | * specified collection (optional operation). After this call returns, | ||
| 347 | * this collection will contain no elements in common with the specified | ||
| 348 | * collection. | ||
| 349 | * | ||
| 350 | * @param c collection containing elements to be removed from this collection | ||
| 351 | * @return <tt>true</tt> if this collection changed as a result of the | ||
| 352 | * call | ||
| 353 | * @throws UnsupportedOperationException if the <tt>removeAll</tt> method | ||
| 354 | * is not supported by this collection | ||
| 355 | * @throws ClassCastException if the types of one or more elements | ||
| 356 | * in this collection are incompatible with the specified | ||
| 357 | * collection | ||
| 358 | * (<a href="#optional-restrictions">optional</a>) | ||
| 359 | * @throws NullPointerException if this collection contains one or more | ||
| 360 | * null elements and the specified collection does not support | ||
| 361 | * null elements | ||
| 362 | * (<a href="#optional-restrictions">optional</a>), | ||
| 363 | * or if the specified collection is null | ||
| 364 | * @see #remove(Object) | ||
| 365 | * @see #contains(Object) | ||
| 366 | */ | ||
| 367 | boolean removeAll(Collection<?> c); | ||
| 368 | |||
| 369 | /** | ||
| 370 | * Retains only the elements in this collection that are contained in the | ||
| 371 | * specified collection (optional operation). In other words, removes from | ||
| 372 | * this collection all of its elements that are not contained in the | ||
| 373 | * specified collection. | ||
| 374 | * | ||
| 375 | * @param c collection containing elements to be retained in this collection | ||
| 376 | * @return <tt>true</tt> if this collection changed as a result of the call | ||
| 377 | * @throws UnsupportedOperationException if the <tt>retainAll</tt> operation | ||
| 378 | * is not supported by this collection | ||
| 379 | * @throws ClassCastException if the types of one or more elements | ||
| 380 | * in this collection are incompatible with the specified | ||
| 381 | * collection | ||
| 382 | * (<a href="#optional-restrictions">optional</a>) | ||
| 383 | * @throws NullPointerException if this collection contains one or more | ||
| 384 | * null elements and the specified collection does not permit null | ||
| 385 | * elements | ||
| 386 | * (<a href="#optional-restrictions">optional</a>), | ||
| 387 | * or if the specified collection is null | ||
| 388 | * @see #remove(Object) | ||
| 389 | * @see #contains(Object) | ||
| 390 | */ | ||
| 391 | boolean retainAll(Collection<?> c); | ||
| 392 | |||
| 393 | /** | ||
| 394 | * Removes all of the elements from this collection (optional operation). | ||
| 395 | * The collection will be empty after this method returns. | ||
| 396 | * | ||
| 397 | * @throws UnsupportedOperationException if the <tt>clear</tt> operation | ||
| 398 | * is not supported by this collection | ||
| 399 | */ | ||
| 400 | void clear(); | ||
| 401 | |||
| 402 | |||
| 403 | // Comparison and hashing | ||
| 404 | |||
| 405 | /** | ||
| 406 | * Compares the specified object with this collection for equality. <p> | ||
| 407 | * | ||
| 408 | * While the <tt>Collection</tt> interface adds no stipulations to the | ||
| 409 | * general contract for the <tt>Object.equals</tt>, programmers who | ||
| 410 | * implement the <tt>Collection</tt> interface "directly" (in other words, | ||
| 411 | * create a class that is a <tt>Collection</tt> but is not a <tt>Set</tt> | ||
| 412 | * or a <tt>List</tt>) must exercise care if they choose to override the | ||
| 413 | * <tt>Object.equals</tt>. It is not necessary to do so, and the simplest | ||
| 414 | * course of action is to rely on <tt>Object</tt>'s implementation, but | ||
| 415 | * the implementor may wish to implement a "value comparison" in place of | ||
| 416 | * the default "reference comparison." (The <tt>List</tt> and | ||
| 417 | * <tt>Set</tt> interfaces mandate such value comparisons.)<p> | ||
| 418 | * | ||
| 419 | * The general contract for the <tt>Object.equals</tt> method states that | ||
| 420 | * equals must be symmetric (in other words, <tt>a.equals(b)</tt> if and | ||
| 421 | * only if <tt>b.equals(a)</tt>). The contracts for <tt>List.equals</tt> | ||
| 422 | * and <tt>Set.equals</tt> state that lists are only equal to other lists, | ||
| 423 | * and sets to other sets. Thus, a custom <tt>equals</tt> method for a | ||
| 424 | * collection class that implements neither the <tt>List</tt> nor | ||
| 425 | * <tt>Set</tt> interface must return <tt>false</tt> when this collection | ||
| 426 | * is compared to any list or set. (By the same logic, it is not possible | ||
| 427 | * to write a class that correctly implements both the <tt>Set</tt> and | ||
| 428 | * <tt>List</tt> interfaces.) | ||
| 429 | * | ||
| 430 | * @param o object to be compared for equality with this collection | ||
| 431 | * @return <tt>true</tt> if the specified object is equal to this | ||
| 432 | * collection | ||
| 433 | * | ||
| 434 | * @see Object#equals(Object) | ||
| 435 | * @see Set#equals(Object) | ||
| 436 | * @see List#equals(Object) | ||
| 437 | */ | ||
| 438 | boolean equals(Object o); | ||
| 439 | |||
| 440 | /** | ||
| 441 | * Returns the hash code value for this collection. While the | ||
| 442 | * <tt>Collection</tt> interface adds no stipulations to the general | ||
| 443 | * contract for the <tt>Object.hashCode</tt> method, programmers should | ||
| 444 | * take note that any class that overrides the <tt>Object.equals</tt> | ||
| 445 | * method must also override the <tt>Object.hashCode</tt> method in order | ||
| 446 | * to satisfy the general contract for the <tt>Object.hashCode</tt> method. | ||
| 447 | * In particular, <tt>c1.equals(c2)</tt> implies that | ||
| 448 | * <tt>c1.hashCode()==c2.hashCode()</tt>. | ||
| 449 | * | ||
| 450 | * @return the hash code value for this collection | ||
| 451 | * | ||
| 452 | * @see Object#hashCode() | ||
| 453 | * @see Object#equals(Object) | ||
| 454 | */ | ||
| 455 | int hashCode(); | ||
| 456 | } | ||