|
Message
From: cvs at opencores.org<cvs@o...>
Date: Thu Oct 26 02:52:18 CEST 2006
Subject: [cvs-checkins] MODIFIED: jop ...
Date: 00/06/10 26:02:52 Added: jop/java/target/src/jdk14/java/util AbstractCollection.java
AbstractList.java AbstractMap.java AbstractSet.java
ArrayList.java Arrays.java Collection.java
Collections.java Comparator.java
ConcurrentModificationException.java Date.java
Dictionary.java Enumeration.java EventListener.java
First_Enumeration.java First_Vector.java
HashMap.java HashSet.java Hashtable.java
Iterator.java List.java ListIterator.java Map.java
NoSuchElementException.java Random.java
RandomAccess.java Set.java SortedMap.java
SortedSet.java Vector.java
Log:
merge with Nelsons JDK and split into three source directories
Revision Changes Path
1.1 jop/java/target/src/jdk14/java/util/AbstractCollection.java
http://www.opencores.org/cvsweb.shtml/jop/java/target/src/jdk14/java/util/AbstractCollection.java?rev=1.1&content-type=text/x-cvsweb-markup
Index: AbstractCollection.java
===================================================================
/* AbstractCollection.java -- Abstract implementation of most of Collection
Copyright (C) 1998, 2000, 2001, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
//import java.lang.reflect.Array;
/**
* A basic implementation of most of the methods in the Collection interface to
* make it easier to create a collection. To create an unmodifiable Collection,
* just subclass AbstractCollection and provide implementations of the
* iterator() and size() methods. The Iterator returned by iterator() need only
* provide implementations of hasNext() and next() (that is, it may throw an
* UnsupportedOperationException if remove() is called). To create a modifiable
* Collection, you must in addition provide an implementation of the
* add(Object) method and the Iterator returned by iterator() must provide an
* implementation of remove(). Other methods should be overridden if the
* backing data structure allows for a more efficient implementation. The
* precise implementation used by AbstractCollection is documented, so that
* subclasses can tell which methods could be implemented more efficiently.
* <p>
*
* The programmer should provide a no-argument constructor, and one that
* accepts another Collection, as recommended by the Collection interface.
* Unfortunately, there is no way to enforce this in Java.
*
* @author Original author unknown
* @author Bryce McKinlay
* @author Eric Blake (ebb9@e...)
* @see Collection
* @see AbstractSet
* @see AbstractList
* @since 1.2
* @status updated to 1.4
*/
public abstract class AbstractCollection implements Collection
{
/**
* The main constructor, for use by subclasses.
*/
protected AbstractCollection()
{
}
/**
* Return an Iterator over this collection. The iterator must provide the
* hasNext and next methods and should in addition provide remove if the
* collection is modifiable.
*
* @return an iterator
*/
public abstract Iterator iterator();
/**
* Return the number of elements in this collection. If there are more than
* Integer.MAX_VALUE elements, return Integer.MAX_VALUE.
*
* @return the size
*/
public abstract int size();
/**
* Add an object to the collection (optional operation). This implementation
* always throws an UnsupportedOperationException - it should be
* overridden if the collection is to be modifiable. If the collection
* does not accept duplicates, simply return false. Collections may specify
* limitations on what may be added.
*
* @param o the object to add
* @return true if the add operation caused the Collection to change
* @throws UnsupportedOperationException if the add operation is not
* supported on this collection
* @throws NullPointerException if the collection does not support null
* @throws ClassCastException if the object is of the wrong type
* @throws IllegalArgumentException if some aspect of the object prevents
* it from being added
*/
public boolean add(Object o)
{
throw new UnsupportedOperationException();
}
/**
* Add all the elements of a given collection to this collection (optional
* operation). This implementation obtains an Iterator over the given
* collection and iterates over it, adding each element with the
* add(Object) method (thus this method will fail with an
* UnsupportedOperationException if the add method does). The behavior is
* unspecified if the specified collection is modified during the iteration,
* including the special case of trying addAll(this) on a non-empty
* collection.
*
* @param c the collection to add the elements of to this collection
* @return true if the add operation caused the Collection to change
* @throws UnsupportedOperationException if the add operation is not
* supported on this collection
* @throws NullPointerException if the specified collection is null
* @throws ClassCastException if the type of any element in c is
* not a valid type for addition.
* @throws IllegalArgumentException if some aspect of any element
* in c prevents it being added.
* @throws NullPointerException if any element in c is null and this
* collection doesn't allow null values.
* @see #add(Object)
*/
public boolean addAll(Collection c)
{
Iterator itr = c.iterator();
boolean modified = false;
int pos = c.size();
while (--pos >= 0)
modified |= add(itr.next());
return modified;
}
/**
* Remove all elements from the collection (optional operation). This
* implementation obtains an iterator over the collection and calls next
* and remove on it repeatedly (thus this method will fail with an
* UnsupportedOperationException if the Iterator's remove method does)
* until there are no more elements to remove.
* Many implementations will have a faster way of doing this.
*
* @throws UnsupportedOperationException if the Iterator returned by
* iterator does not provide an implementation of remove
* @see Iterator#remove()
*/
public void clear()
{
Iterator itr = iterator();
int pos = size();
while (--pos >= 0)
{
itr.next();
itr.remove();
}
}
/**
* Test whether this collection contains a given object. That is, if the
* collection has an element e such that (o == null ? e == null :
* o.equals(e)). This implementation obtains an iterator over the collection
* and iterates over it, testing each element for equality with the given
* object. If it is equal, true is returned. Otherwise false is returned when
* the end of the collection is reached.
*
* @param o the object to remove from this collection
* @return true if this collection contains an object equal to o
*/
public boolean contains(Object o)
{
Iterator itr = iterator();
int pos = size();
while (--pos >= 0)
if (equals(o, itr.next()))
return true;
return false;
}
/**
* Tests whether this collection contains all the elements in a given
* collection. This implementation iterates over the given collection,
* testing whether each element is contained in this collection. If any one
* is not, false is returned. Otherwise true is returned.
*
* @param c the collection to test against
* @return true if this collection contains all the elements in the given
* collection
* @throws NullPointerException if the given collection is null
* @see #contains(Object)
*/
public boolean containsAll(Collection c)
{
Iterator itr = c.iterator();
int pos = c.size();
while (--pos >= 0)
if (!contains(itr.next()))
return false;
return true;
}
/**
* Test whether this collection is empty. This implementation returns
* size() == 0.
*
* @return true if this collection is empty.
* @see #size()
*/
public boolean isEmpty()
{
return size() == 0;
}
/**
* Remove a single instance of an object from this collection (optional
* operation). That is, remove one element e such that
* <code>(o == null ? e == null : o.equals(e))</code>, if such an element
* exists. This implementation obtains an iterator over the collection
* and iterates over it, testing each element for equality with the given
* object. If it is equal, it is removed by the iterator's remove method
* (thus this method will fail with an UnsupportedOperationException if
* the Iterator's remove method does). After the first element has been
* removed, true is returned; if the end of the collection is reached, false
* is returned.
*
* @param o the object to remove from this collection
* @return true if the remove operation caused the Collection to change, or
* equivalently if the collection did contain o.
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @see Iterator#remove()
*/
public boolean remove(Object o)
{
Iterator itr = iterator();
int pos = size();
while (--pos >= 0)
if (equals(o, itr.next()))
{
itr.remove();
return true;
}
return false;
}
/**
* Remove from this collection all its elements that are contained in a given
* collection (optional operation). This implementation iterates over this
* collection, and for each element tests if it is contained in the given
* collection. If so, it is removed by the Iterator's remove method (thus
* this method will fail with an UnsupportedOperationException if the
* Iterator's remove method does).
*
* @param c the collection to remove the elements of
* @return true if the remove operation caused the Collection to change
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @throws NullPointerException if the collection, c, is null.
* @see Iterator#remove()
*/
public boolean removeAll(Collection c)
{
return removeAllInternal(c);
}
/**
* Remove from this collection all its elements that are contained in a given
* collection (optional operation). This implementation iterates over this
* collection, and for each element tests if it is contained in the given
* collection. If so, it is removed by the Iterator's remove method (thus
* this method will fail with an UnsupportedOperationException if the
* Iterator's remove method does). This method is necessary for ArrayList,
* which cannot publicly override removeAll but can optimize this call.
*
* @param c the collection to remove the elements of
* @return true if the remove operation caused the Collection to change
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @throws NullPointerException if the collection, c, is null.
* @see Iterator#remove()
*/
// Package visible for use throughout java.util.
boolean removeAllInternal(Collection c)
{
Iterator itr = iterator();
boolean modified = false;
int pos = size();
while (--pos >= 0)
if (c.contains(itr.next()))
{
itr.remove();
modified = true;
}
return modified;
}
/**
* Remove from this collection all its elements that are not contained in a
* given collection (optional operation). This implementation iterates over
* this collection, and for each element tests if it is contained in the
* given collection. If not, it is removed by the Iterator's remove method
* (thus this method will fail with an UnsupportedOperationException if
* the Iterator's remove method does).
*
* @param c the collection to retain the elements of
* @return true if the remove operation caused the Collection to change
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @throws NullPointerException if the collection, c, is null.
* @see Iterator#remove()
*/
public boolean retainAll(Collection c)
{
return retainAllInternal(c);
}
/**
* Remove from this collection all its elements that are not contained in a
* given collection (optional operation). This implementation iterates over
* this collection, and for each element tests if it is contained in the
* given collection. If not, it is removed by the Iterator's remove method
* (thus this method will fail with an UnsupportedOperationException if
* the Iterator's remove method does). This method is necessary for
* ArrayList, which cannot publicly override retainAll but can optimize
* this call.
*
* @param c the collection to retain the elements of
* @return true if the remove operation caused the Collection to change
* @throws UnsupportedOperationException if this collection's Iterator
* does not support the remove method
* @throws NullPointerException if the collection, c, is null.
* @see Iterator#remove()
*/
// Package visible for use throughout java.util.
boolean retainAllInternal(Collection c)
{
Iterator itr = iterator();
boolean modified = false;
int pos = size();
while (--pos >= 0)
if (!c.contains(itr.next()))
{
itr.remove();
modified = true;
}
return modified;
}
/**
* Return an array containing the elements of this collection. This
* implementation creates an Object array of size size() and then iterates
* over the collection, setting each element of the array from the value
* returned by the iterator. The returned array is safe, and is not backed
* by the collection.
*
* @return an array containing the elements of this collection
*/
public Object[] toArray()
{
Iterator itr = iterator();
int size = size();
Object[] a = new Object[size];
for (int pos = 0; pos < size; pos++)
a[pos] = itr.next();
return a;
}
/**
* Copy the collection into a given array if it will fit, or into a
* dynamically created array of the same run-time type as the given array if
* not. If there is space remaining in the array, the first element after the
* end of the collection is set to null (this is only useful if the
* collection is known to contain no null elements, however). This
* implementation first tests whether the given array is large enough to hold
* all the elements of the collection. If not, the reflection API is used to
* allocate a new array of the same run-time type. Next an iterator is
* obtained over the collection and the elements are placed in the array as
* they are returned by the iterator. Finally the first spare element, if
* any, of the array is set to null, and the created array is returned.
* The returned array is safe; it is not backed by the collection. Note that
* null may not mark the last element, if the collection allows null
* elements.
*
* @param a the array to copy into, or of the correct run-time type
* @return the array that was produced
* @throws NullPointerException if the given array is null
* @throws ArrayStoreException if the type of the array precludes holding
* one of the elements of the Collection
*/
public Object[] toArray(Object[] a)
{
int size = size();
if (a.length < size) {
// a = (Object[]) Array.newInstance(a.getClass().getComponentType(),
// size);
System.out.println("NYI");
throw new RuntimeException();
}
else if (a.length > size)
a[size] = null;
Iterator itr = iterator();
for (int pos = 0; pos < size; pos++)
a[pos] = itr.next();
return a;
}
/**
* Creates a String representation of the Collection. The string returned is
* of the form "[a, b, ...]" where a and b etc are the results of calling
* toString on the elements of the collection. This implementation obtains an
* Iterator over the Collection and adds each element to a StringBuffer as it
* is returned by the iterator. "<this>" is inserted when the collection
* contains itself (only works for direct containment, not for collections
* inside collections).
*
* @return a String representation of the Collection
*/
public String toString()
{
Iterator itr = iterator();
StringBuffer r = new StringBuffer("[");
boolean hasNext = itr.hasNext();
while (hasNext)
{
Object o = itr.next();
if (o == this)
r.append("<this>");
else
r.append(o);
hasNext = itr.hasNext();
if (hasNext)
r.append(", ");
}
r.append("]");
return r.toString();
}
/**
* Compare two objects according to Collection semantics.
*
* @param o1 the first object
* @param o2 the second object
* @return o1 == null ? o2 == null : o1.equals(o2)
*/
// Package visible for use throughout java.util.
// It may be inlined since it is final.
static final boolean equals(Object o1, Object o2)
{
return o1 == null ? o2 == null : o1.equals(o2);
}
/**
* Hash an object according to Collection semantics.
*
* @param o the object to hash
* @return o1 == null ? 0 : o1.hashCode()
*/
// Package visible for use throughout java.util.
// It may be inlined since it is final.
static final int hashCode(Object o)
{
return o == null ? 0 : o.hashCode();
}
}
1.1 jop/java/target/src/jdk14/java/util/AbstractList.java
http://www.opencores.org/cvsweb.shtml/jop/java/target/src/jdk14/java/util/AbstractList.java?rev=1.1&content-type=text/x-cvsweb-markup
Index: AbstractList.java
===================================================================
/* AbstractList.java -- Abstract implementation of most of List
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/**
* A basic implementation of most of the methods in the List interface to make
* it easier to create a List based on a random-access data structure. If
* the list is sequential (such as a linked list), use AbstractSequentialList.
* To create an unmodifiable list, it is only necessary to override the
* size() and get(int) methods (this contrasts with all other abstract
* collection classes which require an iterator to be provided). To make the
* list modifiable, the set(int, Object) method should also be overridden, and
* to make the list resizable, the add(int, Object) and remove(int) methods
* should be overridden too. Other methods should be overridden if the
* backing data structure allows for a more efficient implementation.
* The precise implementation used by AbstractList is documented, so that
* subclasses can tell which methods could be implemented more efficiently.
* <p>
*
* As recommended by Collection and List, the subclass should provide at
* least a no-argument and a Collection constructor. This class is not
* synchronized.
*
* @author Original author unknown
* @author Bryce McKinlay
* @author Eric Blake (ebb9@e...)
* @see Collection
* @see List
* @see AbstractSequentialList
* @see AbstractCollection
* @see ListIterator
* @since 1.2
* @status updated to 1.4
*/
public abstract class AbstractList extends AbstractCollection implements List
{
/**
* A count of the number of structural modifications that have been made to
* the list (that is, insertions and removals). Structural modifications
* are ones which change the list size or affect how iterations would
* behave. This field is available for use by Iterator and ListIterator,
* in order to throw a {@link ConcurrentModificationException} in response
* to the next operation on the iterator. This <i>fail-fast</i> behavior
* saves the user from many subtle bugs otherwise possible from concurrent
* modification during iteration.
* <p>
*
* To make lists fail-fast, increment this field by just 1 in the
* <code>add(int, Object)</code> and <code>remove(int)</code> methods.
* Otherwise, this field may be ignored.
*/
protected transient int modCount;
/**
* The main constructor, for use by subclasses.
*/
protected AbstractList()
{
}
/**
* Returns the elements at the specified position in the list.
*
* @param index the element to return
* @return the element at that position
* @throws IndexOutOfBoundsException if index < 0 || index >= size()
*/
public abstract Object get(int index);
/**
* Insert an element into the list at a given position (optional operation).
* This shifts all existing elements from that position to the end one
* index to the right. This version of add has no return, since it is
* assumed to always succeed if there is no exception. This implementation
* always throws UnsupportedOperationException, and must be overridden to
* make a modifiable List. If you want fail-fast iterators, be sure to
* increment modCount when overriding this.
*
* @param index the location to insert the item
* @param o the object to insert
* @throws UnsupportedOperationException if this list does not support the
* add operation
* @throws IndexOutOfBoundsException if index < 0 || index > size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
* @see #modCount
*/
public void add(int index, Object o)
{
throw new UnsupportedOperationException();
}
/**
* Add an element to the end of the list (optional operation). If the list
* imposes restraints on what can be inserted, such as no null elements,
* this should be documented. This implementation calls
* <code>add(size(), o);</code>, and will fail if that version does.
*
* @param o the object to add
* @return true, as defined by Collection for a modified list
* @throws UnsupportedOperationException if this list does not support the
* add operation
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
* @see #add(int, Object)
*/
public boolean add(Object o)
{
add(size(), o);
return true;
}
/**
* Insert the contents of a collection into the list at a given position
* (optional operation). Shift all elements at that position to the right
* by the number of elements inserted. This operation is undefined if
* this list is modified during the operation (for example, if you try
* to insert a list into itself). This implementation uses the iterator of
* the collection, repeatedly calling add(int, Object); this will fail
* if add does. This can often be made more efficient.
*
* @param index the location to insert the collection
* @param c the collection to insert
* @return true if the list was modified by this action, that is, if c is
* non-empty
* @throws UnsupportedOperationException if this list does not support the
* addAll operation
* @throws IndexOutOfBoundsException if index < 0 || index > size()
* @throws ClassCastException if some element of c cannot be added to this
* list due to its type
* @throws IllegalArgumentException if some element of c cannot be added
* to this list for some other reason
* @throws NullPointerException if the specified collection is null
* @see #add(int, Object)
*/
public boolean addAll(int index, Collection c)
{
Iterator itr = c.iterator();
int size = c.size();
for (int pos = size; pos > 0; pos--)
add(index++, itr.next());
return size > 0;
}
/**
* Clear the list, such that a subsequent call to isEmpty() would return
* true (optional operation). This implementation calls
* <code>removeRange(0, size())</code>, so it will fail unless remove
* or removeRange is overridden.
*
* @throws UnsupportedOperationException if this list does not support the
* clear operation
* @see #remove(int)
* @see #removeRange(int, int)
*/
public void clear()
{
removeRange(0, size());
}
/**
* Test whether this list is equal to another object. A List is defined to be
* equal to an object if and only if that object is also a List, and the two
* lists have the same sequence. Two lists l1 and l2 are equal if and only
* if <code>l1.size() == l2.size()</code>, and for every integer n between 0
* and <code>l1.size() - 1</code> inclusive, <code>l1.get(n) == null ?
* l2.get(n) == null : l1.get(n).equals(l2.get(n))</code>.
* <p>
*
* This implementation returns true if the object is this, or false if the
* object is not a List. Otherwise, it iterates over both lists (with
* iterator()), returning false if two elements compare false or one list
* is shorter, and true if the iteration completes successfully.
*
* @param o the object to test for equality with this list
* @return true if o is equal to this list
* @see Object#equals(Object)
* @see #hashCode()
*/
public boolean equals(Object o)
{
if (o == this)
return true;
if (! (o instanceof List))
return false;
int size = size();
if (size != ((List) o).size())
return false;
Iterator itr1 = iterator();
Iterator itr2 = ((List) o).iterator();
while (--size >= 0)
if (! equals(itr1.next(), itr2.next()))
return false;
return true;
}
/**
* Obtains a hash code for this list. In order to obey the general
* contract of the hashCode method of class Object, this value is
* calculated as follows:
*
<pre>hashCode = 1;
Iterator i = list.iterator();
while (i.hasNext())
{
Object obj = i.next();
hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode());
}</pre>
*
* This ensures that the general contract of Object.hashCode() is adhered to.
*
* @return the hash code of this list
*
* @see Object#hashCode()
* @see #equals(Object)
*/
public int hashCode()
{
int hashCode = 1;
Iterator itr = iterator();
int pos = size();
while (--pos >= 0)
hashCode = 31 * hashCode + hashCode(itr.next());
return hashCode;
}
/**
* Obtain the first index at which a given object is to be found in this
* list. This implementation follows a listIterator() until a match is found,
* or returns -1 if the list end is reached.
*
* @param o the object to search for
* @return the least integer n such that <code>o == null ? get(n) == null :
* o.equals(get(n))</code>, or -1 if there is no such index
*/
public int indexOf(Object o)
{
ListIterator itr = listIterator();
int size = size();
for (int pos = 0; pos < size; pos++)
if (equals(o, itr.next()))
return pos;
return -1;
}
/**
* Obtain an Iterator over this list, whose sequence is the list order.
* This implementation uses size(), get(int), and remove(int) of the
* backing list, and does not support remove unless the list does. This
* implementation is fail-fast if you correctly maintain modCount.
* Also, this implementation is specified by Sun to be distinct from
* listIterator, although you could easily implement it as
* <code>return listIterator(0)</code>.
*
* @return an Iterator over the elements of this list, in order
* @see #modCount
*/
public Iterator iterator()
{
// Bah, Sun's implementation forbids using listIterator(0).
return new Iterator()
{
private int pos = 0;
private int size = size();
private int last = -1;
private int knownMod = modCount;
// This will get inlined, since it is private.
/**
* Checks for modifications made to the list from
* elsewhere while iteration is in progress.
*
* @throws ConcurrentModificationException if the
* list has been modified elsewhere.
*/
private void checkMod()
{
if (knownMod != modCount)
throw new ConcurrentModificationException();
}
/**
* Tests to see if there are any more objects to
* return.
*
* @return True if the end of the list has not yet been
* reached.
*/
public boolean hasNext()
{
return pos < size;
}
/**
* Retrieves the next object from the list.
*
* @return The next object.
* @throws NoSuchElementException if there are
* no more objects to retrieve.
* @throws ConcurrentModificationException if the
* list has been modified elsewhere.
*/
public Object next()
{
checkMod();
if (pos == size)
throw new NoSuchElementException();
last = pos;
return get(pos++);
}
/**
* Removes the last object retrieved by <code>next()</code>
* from the list, if the list supports object removal.
*
* @throws ConcurrentModificationException if the list
* has been modified elsewhere.
* @throws IllegalStateException if the iterator is positioned
* before the start of the list or the last object has already
* been removed.
* @throws UnsupportedOperationException if the list does
* not support removing elements.
*/
public void remove()
{
checkMod();
if (last < 0)
throw new IllegalStateException();
AbstractList.this.remove(last);
pos--;
size--;
last = -1;
knownMod = modCount;
}
};
}
/**
* Obtain the last index at which a given object is to be found in this
* list. This implementation grabs listIterator(size()), then searches
* backwards for a match or returns -1.
*
* @return the greatest integer n such that <code>o == null ? get(n) == null
* : o.equals(get(n))</code>, or -1 if there is no such index
*/
public int lastIndexOf(Object o)
{
int pos = size();
ListIterator itr = listIterator(pos);
while (--pos >= 0)
if (equals(o, itr.previous()))
return pos;
return -1;
}
/**
* Obtain a ListIterator over this list, starting at the beginning. This
* implementation returns listIterator(0).
*
* @return a ListIterator over the elements of this list, in order, starting
* at the beginning
*/
public ListIterator listIterator()
{
return listIterator(0);
}
/**
* Obtain a ListIterator over this list, starting at a given position.
* A first call to next() would return the same as get(index), and a
* first call to previous() would return the same as get(index - 1).
* <p>
*
* This implementation uses size(), get(int), set(int, Object),
* add(int, Object), and remove(int) of the backing list, and does not
* support remove, set, or add unless the list does. This implementation
* is fail-fast if you correctly maintain modCount.
*
* @param index the position, between 0 and size() inclusive, to begin the
* iteration from
* @return a ListIterator over the elements of this list, in order, starting
* at index
* @throws IndexOutOfBoundsException if index < 0 || index > size()
* @see #modCount
*/
public ListIterator listIterator(final int index)
{
if (index < 0 || index > size())
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size());
return new ListIterator()
{
private int knownMod = modCount;
private int position = index;
private int lastReturned = -1;
private int size = size();
// This will get inlined, since it is private.
/**
* Checks for modifications made to the list from
* elsewhere while iteration is in progress.
*
* @throws ConcurrentModificationException if the
* list has been modified elsewhere.
*/
private void checkMod()
{
if (knownMod != modCount)
throw new ConcurrentModificationException();
}
/**
* Tests to see if there are any more objects to
* return.
*
* @return True if the end of the list has not yet been
* reached.
*/
public boolean hasNext()
{
return position < size;
}
/**
* Tests to see if there are objects prior to the
* current position in the list.
*
* @return True if objects exist prior to the current
* position of the iterator.
*/
public boolean hasPrevious()
{
return position > 0;
}
/**
* Retrieves the next object from the list.
*
* @return The next object.
* @throws NoSuchElementException if there are no
* more objects to retrieve.
* @throws ConcurrentModificationException if the
* list has been modified elsewhere.
*/
public Object next()
{
checkMod();
if (position == size)
throw new NoSuchElementException();
lastReturned = position;
return get(position++);
}
/**
* Retrieves the previous object from the list.
*
* @return The next object.
* @throws NoSuchElementException if there are no
* previous objects to retrieve.
* @throws ConcurrentModificationException if the
* list has been modified elsewhere.
*/
public Object previous()
{
checkMod();
if (position == 0)
throw new NoSuchElementException();
lastReturned = --position;
return get(lastReturned);
}
/**
* Returns the index of the next element in the
* list, which will be retrieved by <code>next()</code>
*
* @return The index of the next element.
*/
public int nextIndex()
{
return position;
}
/**
* Returns the index of the previous element in the
* list, which will be retrieved by <code>previous()</code>
*
* @return The index of the previous element.
*/
public int previousIndex()
{
return position - 1;
}
/**
* Removes the last object retrieved by <code>next()</code>
* or <code>previous()</code> from the list, if the list
* supports object removal.
*
* @throws IllegalStateException if the iterator is positioned
* before the start of the list or the last object has already
* been removed.
* @throws UnsupportedOperationException if the list does
* not support removing elements.
* @throws ConcurrentModificationException if the list
* has been modified elsewhere.
*/
public void remove()
{
checkMod();
if (lastReturned < 0)
throw new IllegalStateException();
AbstractList.this.remove(lastReturned);
size--;
position = lastReturned;
lastReturned = -1;
knownMod = modCount;
}
/**
* Replaces the last object retrieved by <code>next()</code>
* or <code>previous</code> with o, if the list supports object
* replacement and an add or remove operation has not already
* been performed.
*
* @throws IllegalStateException if the iterator is positioned
* before the start of the list or the last object has already
* been removed.
* @throws UnsupportedOperationException if the list doesn't support
* the addition or removal of elements.
* @throws ClassCastException if the type of o is not a valid type
* for this list.
* @throws IllegalArgumentException if something else related to o
* prevents its addition.
* @throws ConcurrentModificationException if the list
* has been modified elsewhere.
*/
public void set(Object o)
{
checkMod();
if (lastReturned < 0)
throw new IllegalStateException();
AbstractList.this.set(lastReturned, o);
}
/**
* Adds the supplied object before the element that would be returned
* by a call to <code>next()</code>, if the list supports addition.
*
* @param o The object to add to the list.
* @throws UnsupportedOperationException if the list doesn't support
* the addition of new elements.
* @throws ClassCastException if the type of o is not a valid type
* for this list.
* @throws IllegalArgumentException if something else related to o
* prevents its addition.
* @throws ConcurrentModificationException if the list
* has been modified elsewhere.
*/
public void add(Object o)
{
checkMod();
AbstractList.this.add(position++, o);
size++;
lastReturned = -1;
knownMod = modCount;
}
};
}
/**
* Remove the element at a given position in this list (optional operation).
* Shifts all remaining elements to the left to fill the gap. This
* implementation always throws an UnsupportedOperationException.
* If you want fail-fast iterators, be sure to increment modCount when
* overriding this.
*
* @param index the position within the list of the object to remove
* @return the object that was removed
* @throws UnsupportedOperationException if this list does not support the
* remove operation
* @throws IndexOutOfBoundsException if index < 0 || index >= size()
* @see #modCount
*/
public Object remove(int index)
{
throw new UnsupportedOperationException();
}
/**
* Remove a subsection of the list. This is called by the clear and
* removeRange methods of the class which implements subList, which are
* difficult for subclasses to override directly. Therefore, this method
* should be overridden instead by the more efficient implementation, if one
* exists. Overriding this can reduce quadratic efforts to constant time
* in some cases!
* <p>
*
* This implementation first checks for illegal or out of range arguments. It
* then obtains a ListIterator over the list using listIterator(fromIndex).
* It then calls next() and remove() on this iterator repeatedly, toIndex -
* fromIndex times.
*
* @param fromIndex the index, inclusive, to remove from.
* @param toIndex the index, exclusive, to remove to.
* @throws UnsupportedOperationException if the list does
* not support removing elements.
*/
protected void removeRange(int fromIndex, int toIndex)
{
ListIterator itr = listIterator(fromIndex);
for (int index = fromIndex; index < toIndex; index++)
{
itr.next();
itr.remove();
}
}
/**
* Replace an element of this list with another object (optional operation).
* This implementation always throws an UnsupportedOperationException.
*
* @param index the position within this list of the element to be replaced
* @param o the object to replace it with
* @return the object that was replaced
* @throws UnsupportedOperationException if this list does not support the
* set operation
* @throws IndexOutOfBoundsException if index < 0 || index >= size()
* @throws ClassCastException if o cannot be added to this list due to its
* type
* @throws IllegalArgumentException if o cannot be added to this list for
* some other reason
*/
public Object set(int index, Object o)
{
throw new UnsupportedOperationException();
}
/**
* Obtain a List view of a subsection of this list, from fromIndex
* (inclusive) to toIndex (exclusive). If the two indices are equal, the
* sublist is empty. The returned list should be modifiable if and only
* if this list is modifiable. Changes to the returned list should be
* reflected in this list. If this list is structurally modified in
* any way other than through the returned list, the result of any subsequent
* operations on the returned list is undefined.
* <p>
*
* This implementation returns a subclass of AbstractList. It stores, in
* private fields, the offset and size of the sublist, and the expected
* modCount of the backing list. If the backing list implements RandomAccess,
* the sublist will also.
* <p>
*
* The subclass's <code>set(int, Object)</code>, <code>get(int)</code>,
* <code>add(int, Object)</code>, <code>remove(int)</code>,
* <code>addAll(int, Collection)</code> and
* <code>removeRange(int, int)</code> methods all delegate to the
* corresponding methods on the backing abstract list, after
* bounds-checking the index and adjusting for the offset. The
* <code>addAll(Collection c)</code> method merely returns addAll(size, c).
* The <code>listIterator(int)</code> method returns a "wrapper object"
* over a list iterator on the backing list, which is created with the
* corresponding method on the backing list. The <code>iterator()</code>
* method merely returns listIterator(), and the <code>size()</code> method
* merely returns the subclass's size field.
* <p>
*
* All methods first check to see if the actual modCount of the backing
* list is equal to its expected value, and throw a
* ConcurrentModificationException if it is not.
*
* @param fromIndex the index that the returned list should start from
* (inclusive)
* @param toIndex the index that the returned list should go to (exclusive)
* @return a List backed by a subsection of this list
* @throws IndexOutOfBoundsException if fromIndex < 0
* || toIndex > size()
* @throws IllegalArgumentException if fromIndex > toIndex
* @see ConcurrentModificationException
* @see RandomAccess
*/
public List subList(int fromIndex, int toIndex)
{
// This follows the specification of AbstractList, but is inconsistent
// with the one in List. Don't you love Sun's inconsistencies?
if (fromIndex > toIndex)
throw new IllegalArgumentException(fromIndex + " > " + toIndex);
if (fromIndex < 0 || toIndex > size())
throw new IndexOutOfBoundsException();
if (this instanceof RandomAccess)
return new RandomAccessSubList(this, fromIndex, toIndex);
return new SubList(this, fromIndex, toIndex);
}
/**
* This class follows the implementation requirements set forth in
* {@link AbstractList#subList(int, int)}. It matches Sun's implementation
* by using a non-public top-level class in the same package.
*
* @author Original author unknown
* @author Eric Blake (ebb9@e...)
*/
private static class SubList extends AbstractList
{
// Package visible, for use by iterator.
/** The original list. */
final AbstractList backingList;
/** The index of the first element of the sublist. */
final int offset;
/** The size of the sublist. */
int size;
/**
* Construct the sublist.
*
* @param backing the list this comes from
* @param fromIndex the lower bound, inclusive
* @param toIndex the upper bound, exclusive
*/
SubList(AbstractList backing, int fromIndex, int toIndex)
{
backingList = backing;
modCount = backing.modCount;
offset = fromIndex;
size = toIndex - fromIndex;
}
/**
* This method checks the two modCount fields to ensure that there has
* not been a concurrent modification, returning if all is okay.
*
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
*/
// This can be inlined. Package visible, for use by iterator.
void checkMod()
{
if (modCount != backingList.modCount)
throw new ConcurrentModificationException();
}
/**
* This method checks that a value is between 0 and size (inclusive). If
* it is not, an exception is thrown.
*
* @param index the value to check
* @throws IndexOutOfBoundsException if index < 0 || index > size()
*/
// This will get inlined, since it is private.
private void checkBoundsInclusive(int index)
{
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size);
}
/**
* This method checks that a value is between 0 (inclusive) and size
* (exclusive). If it is not, an exception is thrown.
*
* @param index the value to check
* @throws IndexOutOfBoundsException if index < 0 || index >= size()
*/
// This will get inlined, since it is private.
private void checkBoundsExclusive(int index)
{
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:"
+ size);
}
/**
* Specified by AbstractList.subList to return the private field size.
*
* @return the sublist size
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
*/
public int size()
{
checkMod();
return size;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the location to modify
* @param o the new value
* @return the old value
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws UnsupportedOperationException if the backing list does not
* support the set operation
* @throws IndexOutOfBoundsException if index < 0 || index >= size()
* @throws ClassCastException if o cannot be added to the backing list due
* to its type
* @throws IllegalArgumentException if o cannot be added to the backing list
* for some other reason
*/
public Object set(int index, Object o)
{
checkMod();
checkBoundsExclusive(index);
return backingList.set(index + offset, o);
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the location to get from
* @return the object at that location
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws IndexOutOfBoundsException if index < 0 || index >= size()
*/
public Object get(int index)
{
checkMod();
checkBoundsExclusive(index);
return backingList.get(index + offset);
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the index to insert at
* @param o the object to add
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws IndexOutOfBoundsException if index < 0 || index > size()
* @throws UnsupportedOperationException if the backing list does not
* support the add operation.
* @throws ClassCastException if o cannot be added to the backing list due
* to its type.
* @throws IllegalArgumentException if o cannot be added to the backing
* list for some other reason.
*/
public void add(int index, Object o)
{
checkMod();
checkBoundsInclusive(index);
backingList.add(index + offset, o);
size++;
modCount = backingList.modCount;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the index to remove
* @return the removed object
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws IndexOutOfBoundsException if index < 0 || index >= size()
* @throws UnsupportedOperationException if the backing list does not
* support the remove operation
*/
public Object remove(int index)
{
checkMod();
checkBoundsExclusive(index);
Object o = backingList.remove(index + offset);
size--;
modCount = backingList.modCount;
return o;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
* This does no bounds checking, as it assumes it will only be called
* by trusted code like clear() which has already checked the bounds.
*
* @param fromIndex the lower bound, inclusive
* @param toIndex the upper bound, exclusive
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws UnsupportedOperationException if the backing list does
* not support removing elements.
*/
protected void removeRange(int fromIndex, int toIndex)
{
checkMod();
backingList.removeRange(offset + fromIndex, offset + toIndex);
size -= toIndex - fromIndex;
modCount = backingList.modCount;
}
/**
* Specified by AbstractList.subList to delegate to the backing list.
*
* @param index the location to insert at
* @param c the collection to insert
* @return true if this list was modified, in other words, c is non-empty
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws IndexOutOfBoundsException if index < 0 || index > size()
* @throws UnsupportedOperationException if this list does not support the
* addAll operation
* @throws ClassCastException if some element of c cannot be added to this
* list due to its type
* @throws IllegalArgumentException if some element of c cannot be added
* to this list for some other reason
* @throws NullPointerException if the specified collection is null
*/
public boolean addAll(int index, Collection c)
{
checkMod();
checkBoundsInclusive(index);
int csize = c.size();
boolean result = backingList.addAll(offset + index, c);
size += csize;
modCount = backingList.modCount;
return result;
}
/**
* Specified by AbstractList.subList to return addAll(size, c).
*
* @param c the collection to insert
* @return true if this list was modified, in other words, c is non-empty
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws UnsupportedOperationException if this list does not support the
* addAll operation
* @throws ClassCastException if some element of c cannot be added to this
* list due to its type
* @throws IllegalArgumentException if some element of c cannot be added
* to this list for some other reason
* @throws NullPointerException if the specified collection is null
*/
public boolean addAll(Collection c)
{
return addAll(size, c);
}
/**
* Specified by AbstractList.subList to return listIterator().
*
* @return an iterator over the sublist
*/
public Iterator iterator()
{
return listIterator();
}
/**
* Specified by AbstractList.subList to return a wrapper around the
* backing list's iterator.
*
* @param index the start location of the iterator
* @return a list iterator over the sublist
* @throws ConcurrentModificationException if the backing list has been
* modified externally to this sublist
* @throws IndexOutOfBoundsException if the value is out of range
*/
public ListIterator listIterator(final int index)
{
checkMod();
checkBoundsInclusive(index);
return new ListIterator()
{
private final ListIterator i = backingList.listIterator(index + offset);
private int position = index;
/**
* Tests to see if there are any more objects to
* return.
*
* @return True if the end of the list has not yet been
* reached.
*/
public boolean hasNext()
{
return position < size;
}
/**
* Tests to see if there are objects prior to the
* current position in the list.
*
* @return True if objects exist prior to the current
* position of the iterator.
*/
public boolean hasPrevious()
{
return position > 0;
}
/**
* Retrieves the next object from the list.
*
* @return The next object.
* @throws NoSuchElementException if there are no
* more objects to retrieve.
* @throws ConcurrentModificationException if the
* list has been modified elsewhere.
*/
public Object next()
{
if (position == size)
throw new NoSuchElementException();
position++;
return i.next();
}
/**
* Retrieves the previous object from the list.
*
* @return The next object.
* @throws NoSuchElementException if there are no
* previous objects to retrieve.
* @throws ConcurrentModificationException if the
* list has been modified elsewhere.
*/
public Object previous()
{
if (position == 0)
throw new NoSuchElementException();
position--;
return i.previous();
}
/**
* Returns the index of the next element in the
* list, which will be retrieved by <code>next()</code>
*
* @return The index of the next element.
*/
public int nextIndex()
{
return i.nextIndex() - offset;
}
/**
* Returns the index of the previous element in the
* list, which will be retrieved by <code>previous()</code>
*
* @return The index of the previous element.
*/
public int previousIndex()
{
return i.previousIndex() - offset;
}
/**
* Removes the last object retrieved by <code>next()</code>
* from the list, if the list supports object removal.
*
* @throws IllegalStateException if the iterator is positioned
* before the start of the list or the last object has already
* been removed.
* @throws UnsupportedOperationException if the list does
* not support removing elements.
*/
public void remove()
{
i.remove();
size--;
position = nextIndex();
modCount = backingList.modCount;
}
/**
* Replaces the last object retrieved by <code>next()</code>
* or <code>previous</code> with o, if the list supports object
* replacement and an add or remove operation has not already
* been performed.
*
* @throws IllegalStateException if the iterator is positioned
* before the start of the list or the last object has already
* been removed.
* @throws UnsupportedOperationException if the list doesn't support
* the addition or removal of elements.
* @throws ClassCastException if the type of o is not a valid type
* for this list.
* @throws IllegalArgumentException if something else related to o
* prevents its addition.
* @throws ConcurrentModificationException if the list
* has been modified elsewhere.
*/
public void set(Object o)
{
i.set(o);
}
/**
* Adds the supplied object before the element that would be returned
* by a call to <code>next()</code>, if the list supports addition.
*
* @param o The object to add to the list.
* @throws UnsupportedOperationException if the list doesn't support
* the addition of new elements.
* @throws ClassCastException if the type of o is not a valid type
* for this list.
* @throws IllegalArgumentException if something else related to o
* prevents its addition.
* @throws ConcurrentModificationException if the list
* has been modified elsewhere.
*/
public void add(Object o)
{
i.add(o);
size++;
position++;
modCount = backingList.modCount;
}
// Here is the reason why the various modCount fields are mostly
// ignored in this wrapper listIterator.
// If the backing listIterator is failfast, then the following holds:
// Using any other method on this list will call a corresponding
// method on the backing list *after* the backing listIterator
// is created, which will in turn cause a ConcurrentModException
// when this listIterator comes to use the backing one. So it is
// implicitly failfast.
// If the backing listIterator is NOT failfast, then the whole of
// this list isn't failfast, because the modCount field of the
// backing list is not valid. It would still be *possible* to
// make the iterator failfast wrt modifications of the sublist
// only, but somewhat pointless when the list can be changed under
// us.
// Either way, no explicit handling of modCount is needed.
// However modCount = backingList.modCount must be executed in add
// and remove, and size must also be updated in these two methods,
// since they do not go through the corresponding methods of the subList.
};
}
} // class SubList
/**
* This class is a RandomAccess version of SubList, as required by
* {@link AbstractList#subList(int, int)}.
*
* @author Eric Blake (ebb9@e...)
*/
private static final class RandomAccessSubList extends SubList
implements RandomAccess
{
/**
* Construct the sublist.
*
* @param backing the list this comes from
* @param fromIndex the lower bound, inclusive
* @param toIndex the upper bound, exclusive
*/
RandomAccessSubList(AbstractList backing, int fromIndex, int toIndex)
{
super(backing, fromIndex, toIndex);
}
} // class RandomAccessSubList
} // class AbstractList
1.1 jop/java/target/src/jdk14/java/util/AbstractMap.java
http://www.opencores.org/cvsweb.shtml/jop/java/target/src/jdk14/java/util/AbstractMap.java?rev=1.1&content-type=text/x-cvsweb-markup
Index: AbstractMap.java
===================================================================
/* AbstractMap.java -- Abstract implementation of most of Map
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/**
* An abstract implementation of Map to make it easier to create your own
* implementations. In order to create an unmodifiable Map, subclass
* AbstractMap and implement the <code>entrySet</code> (usually via an
* AbstractSet). To make it modifiable, also implement <code>put</code>,
* and have <code>entrySet().iterator()</code> support <code>remove</code>.
* <p>
*
* It is recommended that classes which extend this support at least the
* no-argument constructor, and a constructor which accepts another Map.
* Further methods in this class may be overridden if you have a more
* efficient implementation.
*
* @author Original author unknown
* @author Bryce McKinlay
* @author Eric Blake (ebb9@e...)
* @see Map
* @see Collection
* @see HashMap
* @see LinkedHashMap
* @see TreeMap
* @see WeakHashMap
* @see IdentityHashMap
* @since 1.2
* @status updated to 1.4
*/
public abstract class AbstractMap implements Map
{
/** An "enum" of iterator types. */
// Package visible for use by subclasses.
static final int KEYS = 0,
VALUES = 1,
ENTRIES = 2;
/**
* The cache for {@link #keySet()}.
*/
// Package visible for use by subclasses.
Set keys;
/**
* The cache for {@link #values()}.
*/
// Package visible for use by subclasses.
Collection values;
/**
* The main constructor, for use by subclasses.
*/
protected AbstractMap()
{
}
/**
* Returns a set view of the mappings in this Map. Each element in the
* set must be an implementation of Map.Entry. The set is backed by
* the map, so that changes in one show up in the other. Modifications
* made while an iterator is in progress cause undefined behavior. If
* the set supports removal, these methods must be valid:
* <code>Iterator.remove</code>, <code>Set.remove</code>,
* <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>.
* Element addition is not supported via this set.
*
* @return the entry set
* @see Map.Entry
*/
public abstract Set entrySet();
/**
* Remove all entries from this Map (optional operation). This default
* implementation calls entrySet().clear(). NOTE: If the entry set does
* not permit clearing, then this will fail, too. Subclasses often
* override this for efficiency. Your implementation of entrySet() should
* not call <code>AbstractMap.clear</code> unless you want an infinite loop.
*
* @throws UnsupportedOperationException if <code>entrySet().clear()</code>
* does not support clearing.
* @see Set#clear()
*/
public void clear()
{
entrySet().clear();
}
/**
* Create a shallow copy of this Map, no keys or values are copied. The
* default implementation simply calls <code>super.clone()</code>.
*
* @return the shallow clone
* @throws CloneNotSupportedException if a subclass is not Cloneable
* @see Cloneable
* @see Object#clone()
*/
protected Object clone() throws CloneNotSupportedException
{
throw new CloneNotSupportedException();
// AbstractMap copy = (AbstractMap) super.clone();
// // Clear out the caches; they are stale.
// copy.keys = null;
// copy.values = null;
// return copy;
}
/**
* Returns true if this contains a mapping for the given key. This
* implementation does a linear search, O(n), over the
* <code>entrySet()</code>, returning <code>true</code> if a match
* is found, <code>false</code> if the iteration ends. Many subclasses
* can implement this more efficiently.
*
* @param key the key to search for
* @return true if the map contains the key
* @throws NullPointerException if key is <code>null</code> but the map
* does not permit null keys
* @see #containsValue(Object)
*/
public boolean containsKey(Object key)
{
Iterator entries = entrySet().iterator();
int pos = size();
while (--pos >= 0)
if (equals(key, ((Map.Entry) entries.next()).getKey()))
return true;
return false;
}
/**
* Returns true if this contains at least one mapping with the given value.
* This implementation does a linear search, O(n), over the
* <code>entrySet()</code>, returning <code>true</code> if a match
* is found, <code>false</code> if the iteration ends. A match is
* defined as a value, v, where <code>(value == null ? v == null :
* value.equals(v))</code>. Subclasses are unlikely to implement
* this more efficiently.
*
* @param value the value to search for
* @return true if the map contains the value
* @see #containsKey(Object)
*/
public boolean containsValue(Object value)
{
Iterator entries = entrySet().iterator();
int pos = size();
while (--pos >= 0)
if (equals(value, ((Map.Entry) entries.next()).getValue()))
return true;
return false;
}
/**
* Compares the specified object with this map for equality. Returns
* <code>true</code> if the other object is a Map with the same mappings,
* that is,<br>
* <code>o instanceof Map && entrySet().equals(((Map) o).entrySet();</code>
*
* @param o the object to be compared
* @return true if the object equals this map
* @see Set#equals(Object)
*/
public boolean equals(Object o)
{
return (o == this ||
(o instanceof Map &&
entrySet().equals(((Map) o).entrySet())));
}
/**
* Returns the value mapped by the given key. Returns <code>null</code> if
* there is no mapping. However, in Maps that accept null values, you
* must rely on <code>containsKey</code> to determine if a mapping exists.
* This iteration takes linear time, searching entrySet().iterator() of
* the key. Many implementations override this method.
*
* @param key the key to look up
* @return the value associated with the key, or null if key not in map
* @throws NullPointerException if this map does not accept null keys
* @see #containsKey(Object)
*/
public Object get(Object key)
{
Iterator entries = entrySet().iterator();
int pos = size();
while (--pos >= 0)
{
Map.Entry entry = (Map.Entry) entries.next();
if (equals(key, entry.getKey()))
return entry.getValue();
}
return null;
}
/**
* Returns the hash code for this map. As defined in Map, this is the sum
* of all hashcodes for each Map.Entry object in entrySet, or basically
* entrySet().hashCode().
*
* @return the hash code
* @see Map.Entry#hashCode()
* @see Set#hashCode()
*/
public int hashCode()
{
return entrySet().hashCode();
}
/**
* Returns true if the map contains no mappings. This is implemented by
* <code>size() == 0</code>.
*
* @return true if the map is empty
* @see #size()
*/
public boolean isEmpty()
{
return size() == 0;
}
/**
* Returns a set view of this map's keys. The set is backed by the map,
* so changes in one show up in the other. Modifications while an iteration
* is in progress produce undefined behavior. The set supports removal
* if entrySet() does, but does not support element addition.
* <p>
*
* This implementation creates an AbstractSet, where the iterator wraps
* the entrySet iterator, size defers to the Map's size, and contains
* defers to the Map's containsKey. The set is created on first use, and
* returned on subsequent uses, although since no synchronization occurs,
* there is a slight possibility of creating two sets.
*
* @return a Set view of the keys
* @see Set#iterator()
* @see #size()
* @see #containsKey(Object)
* @see #values()
*/
public Set keySet()
{
if (keys == null)
keys = new AbstractSet()
{
/**
* Retrieves the number of keys in the backing map.
*
* @return The number of keys.
*/
public int size()
{
return AbstractMap.this.size();
}
/**
* Returns true if the backing map contains the
* supplied key.
*
* @param key The key to search for.
* @return True if the key was found, false otherwise.
*/
public boolean contains(Object key)
{
return containsKey(key);
}
/**
* Returns an iterator which iterates over the keys
* in the backing map, using a wrapper around the
* iterator returned by <code>entrySet()</code>.
*
* @return An iterator over the keys.
*/
public Iterator iterator()
{
return new Iterator()
{
/**
* The iterator returned by <code>entrySet()</code>.
*/
private final Iterator map_iterator = entrySet().iterator();
/**
* Returns true if a call to <code>next()</code> will
* return another key.
*
* @return True if the iterator has not yet reached
* the last key.
*/
public boolean hasNext()
{
return map_iterator.hasNext();
}
/**
* Returns the key from the next entry retrieved
* by the underlying <code>entrySet()</code> iterator.
*
* @return The next key.
*/
public Object next()
{
return ((Map.Entry) map_iterator.next()).getKey();
}
/**
* Removes the map entry which has a key equal
* to that returned by the last call to
* <code>next()</code>.
*
* @throws UnsupportedOperationException if the
* map doesn't support removal.
*/
public void remove()
{
map_iterator.remove();
}
};
}
};
return keys;
}
/**
* Associates the given key to the given value (optional operation). If the
* map already contains the key, its value is replaced. This implementation
* simply throws an UnsupportedOperationException. Be aware that in a map
* that permits <code>null</code> values, a null return does not always
* imply that the mapping was created.
*
* @param key the key to map
* @param value the value to be mapped
* @return the previous value of the key, or null if there was no mapping
* @throws UnsupportedOperationException if the operation is not supported
* @throws ClassCastException if the key or value is of the wrong type
* @throws IllegalArgumentException if something about this key or value
* prevents it from existing in this map
* @throws NullPointerException if the map forbids null keys or values
* @see #containsKey(Object)
*/
public Object put(Object key, Object value)
{
throw new UnsupportedOperationException();
}
/**
* Copies all entries of the given map to this one (optional operation). If
* the map already contains a key, its value is replaced. This implementation
* simply iterates over the map's entrySet(), calling <code>put</code>,
* so it is not supported if puts are not.
*
* @param m the mapping to load into this map
* @throws UnsupportedOperationException if the operation is not supported
* by this map.
* @throws ClassCastException if a key or value is of the wrong type for
* adding to this map.
* @throws IllegalArgumentException if something about a key or value
* prevents it from existing in this map.
* @throws NullPointerException if the map forbids null keys or values.
* @throws NullPointerException if <code>m</code> is null.
* @see #put(Object, Object)
*/
public void putAll(Map m)
{
Iterator entries = m.entrySet().iterator();
int pos = m.size();
while (--pos >= 0)
{
Map.Entry entry = (Map.Entry) entries.next();
put(entry.getKey(), entry.getValue());
}
}
/**
* Removes the mapping for this key if present (optional operation). This
* implementation iterates over the entrySet searching for a matching
* key, at which point it calls the iterator's <code>remove</code> method.
* It returns the result of <code>getValue()</code> on the entry, if found,
* or null if no entry is found. Note that maps which permit null values
* may also return null if the key was removed. If the entrySet does not
* support removal, this will also fail. This is O(n), so many
* implementations override it for efficiency.
*
* @param key the key to remove
* @return the value the key mapped to, or null if not present.
* Null may also be returned if null values are allowed
* in the map and the value of this mapping is null.
* @throws UnsupportedOperationException if deletion is unsupported
* @see Iterator#remove()
*/
public Object remove(Object key)
{
Iterator entries = entrySet().iterator();
int pos = size();
while (--pos >= 0)
{
Map.Entry entry = (Map.Entry) entries.next();
if (equals(key, entry.getKey()))
{
// Must get the value before we remove it from iterator.
Object r = entry.getValue();
entries.remove();
return r;
}
}
return null;
}
/**
* Returns the number of key-value mappings in the map. If there are more
* than Integer.MAX_VALUE mappings, return Integer.MAX_VALUE. This is
* implemented as <code>entrySet().size()</code>.
*
* @return the number of mappings
* @see Set#size()
*/
public int size()
{
return entrySet().size();
}
/**
* Returns a String representation of this map. This is a listing of the
* map entries (which are specified in Map.Entry as being
* <code>getKey() + "=" + getValue()</code>), separated by a comma and
* space (", "), and surrounded by braces ('{' and '}'). This implementation
* uses a StringBuffer and iterates over the entrySet to build the String.
* Note that this can fail with an exception if underlying keys or
* values complete abruptly in toString().
*
* @return a String representation
* @see Map.Entry#toString()
*/
public String toString()
{
Iterator entries = entrySet().iterator();
StringBuffer r = new StringBuffer("{");
for (int pos = size(); pos > 0; pos--)
{
Map.Entry entry = (Map.Entry) entries.next();
r.append(entry.getKey());
r.append('=');
r.append(entry.getValue());
if (pos > 1)
r.append(", ");
}
r.append("}");
return r.toString();
}
/**
* Returns a collection or bag view of this map's values. The collection
* is backed by the map, so changes in one show up in the other.
* Modifications while an iteration is in progress produce undefined
* behavior. The collection supports removal if entrySet() does, but
* does not support element addition.
* <p>
*
* This implementation creates an AbstractCollection, where the iterator
* wraps the entrySet iterator, size defers to the Map's size, and contains
* defers to the Map's containsValue. The collection is created on first
* use, and returned on subsequent uses, although since no synchronization
* occurs, there is a slight possibility of creating two collections.
*
* @return a Collection view of the values
* @see Collection#iterator()
* @see #size()
* @see #containsValue(Object)
* @see #keySet()
*/
public Collection values()
{
if (values == null)
values = new AbstractCollection()
{
/**
* Returns the number of values stored in
* the backing map.
*
* @return The number of values.
*/
public int size()
{
return AbstractMap.this.size();
}
/**
* Returns true if the backing map contains
* the supplied value.
*
* @param value The value to search for.
* @return True if the value was found, false otherwise.
*/
public boolean contains(Object value)
{
return containsValue(value);
}
/**
* Returns an iterator which iterates over the
* values in the backing map, by using a wrapper
* around the iterator returned by <code>entrySet()</code>.
*
* @return An iterator over the values.
*/
public Iterator iterator()
{
return new Iterator()
{
/**
* The iterator returned by <code>entrySet()</code>.
*/
private final Iterator map_iterator = entrySet().iterator();
/**
* Returns true if a call to <code>next()</call> will
* return another value.
*
* @return True if the iterator has not yet reached
* the last value.
*/
public boolean hasNext()
{
return map_iterator.hasNext();
}
/**
* Returns the value from the next entry retrieved
* by the underlying <code>entrySet()</code> iterator.
*
* @return The next value.
*/
public Object next()
{
return ((Map.Entry) map_iterator.next()).getValue();
}
/**
* Removes the map entry which has a key equal
* to that returned by the last call to
* <code>next()</code>.
*
* @throws UnsupportedOperationException if the
* map doesn't support removal.
*/
public void remove()
{
map_iterator.remove();
}
};
}
};
return values;
}
/**
* Compare two objects according to Collection semantics.
*
* @param o1 the first object
* @param o2 the second object
* @return o1 == o2 || (o1 != null && o1.equals(o2))
*/
// Package visible for use throughout java.util.
// It may be inlined since it is final.
static final boolean equals(Object o1, Object o2)
{
return o1 == o2 || (o1 != null && o1.equals(o2));
}
/**
* Hash an object according to Collection semantics.
*
* @param o the object to hash
* @return o1 == null ? 0 : o1.hashCode()
*/
// Package visible for use throughout java.util.
// It may be inlined since it is final.
static final int hashCode(Object o)
{
return o == null ? 0 : o.hashCode();
}
/**
* A class which implements Map.Entry. It is shared by HashMap, TreeMap,
* Hashtable, and Collections. It is not specified by the JDK, but makes
* life much easier.
*
* @author Jon Zeppieri
* @author Eric Blake (ebb9@e...)
*/
// XXX - FIXME Use fully qualified implements as gcj 3.1 workaround.
// Bug still exists in 3.4.1
static class BasicMapEntry implements Map.Entry
{
/**
* The key. Package visible for direct manipulation.
*/
Object key;
/**
* The value. Package visible for direct manipulation.
*/
Object value;
/**
* Basic constructor initializes the fields.
* @param newKey the key
* @param newValue the value
*/
BasicMapEntry(Object newKey, Object newValue)
{
key = newKey;
value = newValue;
}
/**
* Compares the specified object with this entry. Returns true only if
* the object is a mapping of identical key and value. In other words,
* this must be:<br>
* <pre>(o instanceof Map.Entry)
* && (getKey() == null ? ((HashMap) o).getKey() == null
* : getKey().equals(((HashMap) o).getKey()))
* && (getValue() == null ? ((HashMap) o).getValue() == null
* : getValue().equals(((HashMap) o).getValue()))</pre>
*
* @param o the object to compare
* @return <code>true</code> if it is equal
*/
public final boolean equals(Object o)
{
if (! (o instanceof Map.Entry))
return false;
// Optimize for our own entries.
if (o instanceof BasicMapEntry)
{
BasicMapEntry e = (BasicMapEntry) o;
return (AbstractMap.equals(key, e.key)
&& AbstractMap.equals(value, e.value));
}
Map.Entry e = (Map.Entry) o;
return (AbstractMap.equals(key, e.getKey())
&& AbstractMap.equals(value, e.getValue()));
}
/**
* Get the key corresponding to this entry.
*
* @return the key
*/
public final Object getKey()
{
return key;
}
/**
* Get the value corresponding to this entry. If you already called
* Iterator.remove(), the behavior undefined, but in this case it works.
*
* @return the value
*/
public final Object getValue()
{
return value;
}
/**
* Returns the hash code of the entry. This is defined as the exclusive-or
* of the hashcodes of the key and value (using 0 for null). In other
* words, this must be:<br>
* <pre>(getKey() == null ? 0 : getKey().hashCode())
* ^ (getValue() == null ? 0 : getValue().hashCode())</pre>
*
* @return the hash code
*/
public final int hashCode()
{
return (AbstractMap.hashCode(key) ^ AbstractMap.hashCode(value));
}
/**
* Replaces the value with the specified object. This writes through
* to the map, unless you have already called Iterator.remove(). It
* may be overridden to restrict a null value.
*
* @param newVal the new value to store
* @return the old value
* @throws NullPointerException if the map forbids null values.
* @throws UnsupportedOperationException if the map doesn't support
* <code>put()</code>.
* @throws ClassCastException if the value is of a type unsupported
* by the map.
* @throws IllegalArgumentException if something else about this
* value prevents it being stored in the map.
*/
public Object setValue(Object newVal)
{
Object r = value;
value = newVal;
return r;
}
/**
* This provides a string representation of the entry. It is of the form
* "key=value", where string concatenation is used on key and value.
*
* @return the string representation
*/
public final String toString()
{
return key + "=" + value;
}
} // class BasicMapEntry
}
1.1 jop/java/target/src/jdk14/java/util/AbstractSet.java
http://www.opencores.org/cvsweb.shtml/jop/java/target/src/jdk14/java/util/AbstractSet.java?rev=1.1&content-type=text/x-cvsweb-markup
Index: AbstractSet.java
===================================================================
/* AbstractSet.java -- Abstract implementation of most of Set
Copyright (C) 1998, 2000, 2001, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
/**
* An abstract implementation of Set to make it easier to create your own
* implementations. In order to create a Set, subclass AbstractSet and
* implement the same methods that are required for AbstractCollection
* (although these methods must of course meet the requirements that Set puts
* on them - specifically, no element may be in the set more than once). This
* class simply provides implementations of equals() and hashCode() to fulfil
* the requirements placed on them by the Set interface.
*
* @author Original author unknown
* @author Eric Blake (ebb9@e...)
* @see Collection
* @see AbstractCollection
* @see Set
* @see HashSet
* @see TreeSet
* @see LinkedHashSet
* @since 1.2
* @status updated to 1.4
*/
public abstract class AbstractSet extends AbstractCollection implements Set
{
/**
* The main constructor, for use by subclasses.
*/
protected AbstractSet()
{
}
/**
* Tests whether the given object is equal to this Set. This implementation
* first checks whether this set <em>is</em> the given object, and returns
* true if so. Otherwise, if o is a Set and is the same size as this one, it
* returns the result of calling containsAll on the given Set. Otherwise, it
* returns false.
*
* @param o the Object to be tested for equality with this Set
* @return true if the given object is equal to this Set
*/
public boolean equals(Object o)
{
return (o == this ||
(o instanceof Set && ((Set) o).size() == size()
&& containsAll((Collection) o)));
}
/**
* Returns a hash code for this Set. The hash code of a Set is the sum of the
* hash codes of all its elements, except that the hash code of null is
* defined to be zero. This implementation obtains an Iterator over the Set,
* and sums the results.
*
* @return a hash code for this Set
*/
public int hashCode()
{
Iterator itr = iterator();
int hash = 0;
int pos = size();
while (--pos >= 0)
hash += hashCode(itr.next());
return hash;
}
/**
* Removes from this set all elements in the given collection (optional
* operation). This implementation uses <code>size()</code> to determine
* the smaller collection. Then, if this set is smaller, it iterates
* over the set, calling Iterator.remove if the collection contains
* the element. If this set is larger, it iterates over the collection,
* calling Set.remove for all elements in the collection. Note that
* this operation will fail if a remove methods is not supported.
*
* @param c the collection of elements to remove
* @return true if the set was modified as a result
* @throws UnsupportedOperationException if remove is not supported
* @throws NullPointerException if the collection is null
* @see AbstractCollection#remove(Object)
* @see Collection#contains(Object)
* @see Iterator#remove()
*/
public boolean removeAll(Collection c)
{
int oldsize = size();
int count = c.size();
Iterator i;
if (oldsize < count)
{
for (i = iterator(), count = oldsize; count > 0; count--)
if (c.contains(i.next()))
i.remove();
}
else
for (i = c.iterator(); count > 0; count--)
remove(i.next());
return oldsize != size();
}
}
1.1 jop/java/target/src/jdk14/java/util/ArrayList.java
http://www.opencores.org/cvsweb.shtml/jop/java/target/src/jdk14/java/util/ArrayList.java?rev=1.1&content-type=text/x-cvsweb-markup
Index: ArrayList.java
===================================================================
/* ArrayList.java -- JDK1.2's answer to Vector; this is an array-backed
implementation of the List interface
Copyright (C) 1998, 1999, 2000, 2001, 2004, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.util;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Array;
/**
* An array-backed implementation of the List interface. This implements
* all optional list operations, and permits null elements, so that it is
* better than Vector, which it replaces. Random access is roughly constant
* time, and iteration is roughly linear time, so it is nice and fast, with
* less overhead than a LinkedList.
* <p>
*
* Each list has a capacity, and as the array reaches that capacity it
* is automatically transferred to a larger array. You also have access to
* ensureCapacity and trimToSize to control the backing array's size, avoiding
* reallocation or wasted memory.
* <p>
*
* ArrayList is not synchronized, so if you need multi-threaded access,
* consider using:<br>
* <code>List l = Collections.synchronizedList(new ArrayList(...));</code>
* <p>
*
* The iterators are <i>fail-fast</i>, meaning that any structural
* modification, except for <code>remove()</code> called on the iterator
* itself, cause the iterator to throw a
* {@link ConcurrentModificationException} rather than exhibit
* non-deterministic behavior.
*
* @author Jon A. Zeppieri
* @author Bryce McKinlay
* @author Eric Blake (ebb9@e...)
* @see Collection
* @see List
* @see LinkedList
* @see Vector
* @see Collections#synchronizedList(List)
* @see AbstractList
* @status updated to 1.4
*/
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, Serializable
{
/**
* Compatible with JDK 1.2
*/
private static final long serialVersionUID = 8683452581122892189L;
/**
* The default capacity for new ArrayLists.
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* The number of elements in this list.
* @serial the list size
*/
private int size;
/**
* Where the data is stored.
*/
private transient Object[] data;
/**
* Construct a new ArrayList with the supplied initial capacity.
*
* @param capacity initial capacity of this ArrayList
* @throws IllegalArgumentException if capacity is negative
*/
public ArrayList(int capacity)
{
// Must explicitly check, to get correct exception.
if (capacity < 0)
throw new IllegalArgumentException();
data = new Object[capacity];
}
/**
* Construct a new ArrayList with the default capacity (16).
*/
public ArrayList()
{
this(DEFAULT_CAPACITY);
}
/**
* Construct a new ArrayList, and initialize it with the elements
* in the supplied Collection. The initial capacity is 110% of the
* Collection's size.
*
* @param c the collection whose elements will initialize this list
* @throws NullPointerException if c is null
*/
public ArrayList(Collection c)
{
this((int) (c.size() * 1.1f));
addAll(c);
}
/**
* Trims the capacity of this List to be equal to its size;
* a memory saver.
*/
public void trimToSize()
{
// Not a structural change from the perspective of iterators on this list,
// so don't update modCount.
if (size != data.length)
{
Object[] newData = new Object[size];
System.arraycopy(data, 0, newData, 0, size);
data = newData;
}
}
/**
* Guarantees that this list will have at least enough capacity to
* hold minCapacity elements. This implementation will grow the list to
* max(current * 2, minCapacity) if (minCapacity > current). The JCL says
* explictly that "this method increases its capacity to minCap", while
* the JDK 1.3 online docs specify that the list will grow to at least the
* size specified.
*
* @param minCapacity the minimum guaranteed capacity
*/
public void ensureCapacity(int minCapacity)
{
int current = data.length;
if (minCapacity > current)
{
Object[] newData = new Object[Math.max(current * 2, minCapacity)];
System.arraycopy(data, 0, newData, 0, size);
data = newData;
}
}
/**
* Returns the number of elements in this list.
*
* @return the list size
*/
public int size()
{
return size;
}
/**
* Checks if the list is empty.
*
* @return true if there are no elements
*/
public boolean isEmpty()
{
return size == 0;
}
/**
* Returns true iff element is in this ArrayList.
*
* @param e the element whose inclusion in the List is being tested
* @return true if the list contains e
*/
public boolean contains(Object e)
{
return indexOf(e) != -1;
}
/**
* Returns the lowest index at which element appears in this List, or
* -1 if it does not appear.
*
* @param e the element whose inclusion in the List is being tested
* @return the index where e was found
*/
public int indexOf(Object e)
{
for (int i = 0; i < size; i++)
if (equals(e, data[i]))
return i;
return -1;
}
/* |
Browse
