AbstractCollection.java (addAll): Use size() instead of hasNext() in iterator loop.

2000-10-29  Bryce McKinlay  <bryce@albatross.co.nz>

	* java/util/AbstractCollection.java (addAll): Use size() instead of
	hasNext() in iterator loop.
	(clear): Ditto.
	(contains): Ditto. Simplify loop.
	(containsAll): Ditto.
	(remove): Ditto.
	(removeAll): Ditto.
	(retainAll): Ditto.
	(toArray): Ditto.
	(toString): Ditto. Use string concatenation operators, not
	StringBuffer.
	* java/util/AbstractList.java (addAll): Use size() instead of
	hasNext() in iterator loop.
	(equals): Ditto.
	(hashCode): Ditto.
	(indexOf): Ditto. Don't take null check outside of the loop.
	(iterator): Return an AbstractListItr instead of anonymous class.
	(lastIndexOf): Use a for loop bounded by size() instead of
	hasPrevious() in iterator loop.
	(listIterator): Return an AbstractListItr.
	(removeRange): Remove bounds checking code and docs.
	(AbstractListItr): New inner class. Code moved here from
	listIterator().
	(SubList.iterator): Removed. Use default implementation from
	AbstractList instead.
	(SubList.listIterator): As above.
	* java/util/AbstractMap.java (clear): Use a for loop bounded by size()
	instead of hasNext() in iterator loop.
	(containsValue): Ditto.
	(equals): Ditto.
	(get): Ditto.
	(put): Ditto.
	(putAll): Ditto.
	(remove): Ditto.
	(toString): Ditto. Use string concatenation operators, not
	StringBuffer.
	* java/util/AbstractSequentialList.java (addAll): Use a for loop
	bounded by size() instead of hasNext() in iterator loop.
	* java/util/AbstractSet.java (hashCode): Don't catch exception as
	part of normal execution flow. Do an explicit null check instead.
	* java/util/ArrayList.java (_iSize): Rename to `size'.
	(_arData): Rename to `data'.
	(get): Check lower bounds also. Simplify IndexOutOfBoundsException
	message.
	(remove): Ditto.
	(removeRange): Make protected. Don't check bounds.
	(add): Check lower bounds also. Simplify IndexOutOfBoundsException
	message.
	(addAll (Collection)): Use a size-bounded for loop instead of hasNext()
	check.
	(addAll (int, Collection)): Check lower bounds. Simplify exception
	string.
	(clone): Clone the data array too.
	(indexOf): Inline doesEqual().
	(lastIndexOf): Ditto.
	(clear): Don't set array data to null.
	(set): Check lower bounds. Simplify exception string.
	(toArray): Correct comment.
	(trimToSize): Don't update modCount, this is not a structural change.
	Add comment.

	* java/util/BitSet.java: Merged with classpath, new JDK 1.2 methods
	implemented.
	(toString): Declare `bit' as long, not int.
	(data): Made package-private, not private.

From-SVN: r37116

libjava/ChangeLog

+2000-10-29  Bryce McKinlay  <bryce@albatross.co.nz>
+
+	* java/util/AbstractCollection.java (addAll): Use size() instead of
+	hasNext() in iterator loop.
+	(clear): Ditto.
+	(contains): Ditto. Simplify loop.
+	(containsAll): Ditto.
+	(remove): Ditto.
+	(removeAll): Ditto.
+	(retainAll): Ditto.
+	(toArray): Ditto.
+	(toString): Ditto. Use string concatenation operators, not
+	StringBuffer.
+	* java/util/AbstractList.java (addAll): Use size() instead of
+	hasNext() in iterator loop.
+	(equals): Ditto.
+	(hashCode): Ditto.
+	(indexOf): Ditto. Don't take null check outside of the loop.
+	(iterator): Return an AbstractListItr instead of anonymous class.
+	(lastIndexOf): Use a for loop bounded by size() instead of 
+	hasPrevious() in iterator loop.
+	(listIterator): Return an AbstractListItr.
+	(removeRange): Remove bounds checking code and docs.
+	(AbstractListItr): New inner class. Code moved here from 
+	listIterator().
+	(SubList.iterator): Removed. Use default implementation from 
+	AbstractList instead.
+	(SubList.listIterator): As above.
+	* java/util/AbstractMap.java (clear): Use a for loop bounded by size() 
+	instead of hasNext() in iterator loop.
+	(containsValue): Ditto.
+	(equals): Ditto.
+	(get): Ditto.
+	(put): Ditto.
+	(putAll): Ditto.
+	(remove): Ditto.
+	(toString): Ditto. Use string concatenation operators, not
+	StringBuffer.
+	* java/util/AbstractSequentialList.java (addAll): Use a for loop 
+	bounded by size() instead of hasNext() in iterator loop.
+	* java/util/AbstractSet.java (hashCode): Don't catch exception as
+	part of normal execution flow. Do an explicit null check instead.
+	* java/util/ArrayList.java (_iSize): Rename to `size'.
+	(_arData): Rename to `data'.
+	(get): Check lower bounds also. Simplify IndexOutOfBoundsException
+	message.
+	(remove): Ditto.
+	(removeRange): Make protected. Don't check bounds.
+	(add): Check lower bounds also. Simplify IndexOutOfBoundsException
+	message.
+	(addAll (Collection)): Use a size-bounded for loop instead of hasNext() 
+	check.
+	(addAll (int, Collection)): Check lower bounds. Simplify exception
+	string.
+	(clone): Clone the data array too.
+	(indexOf): Inline doesEqual().
+	(lastIndexOf): Ditto.
+	(clear): Don't set array data to null.
+	(set): Check lower bounds. Simplify exception string.
+	(toArray): Correct comment.
+	(trimToSize): Don't update modCount, this is not a structural change.
+	Add comment.
+	
+	* java/util/BitSet.java: Merged with classpath, new JDK 1.2 methods
+	implemented.
+	(toString): Declare `bit' as long, not int.
+	(data): Made package-private, not private.	
+
 2000-10-27  Warren Levy  <warrenl@cygnus.com>
 
 	* java/util/natGregorianCalendar.cc (computeFields): Set the isSet__

libjava/java/util/AbstractCollection.java

 /* AbstractCollection.java -- Abstract implementation of most of Collection
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 2000 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -7,7 +7,7 @@ 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
@@ -43,8 +43,8 @@ import java.lang.reflect.Array;
  * precise implementation used by AbstractCollection is documented, so that
  * subclasses can tell which methods could be implemented more efficiently.
  */
-public abstract class AbstractCollection implements Collection {
-
+public abstract class AbstractCollection implements Collection
+{
   /**
    * Return an Iterator over this collection. The iterator must provide the
    * hasNext and next methods and should in addition provide remove if the
@@ -67,7 +67,8 @@ public abstract class AbstractCollection implements Collection {
    * @exception UnsupportedOperationException if the add operation is not
    *   supported on this collection
    */
-  public boolean add(Object o) {
+  public boolean add(Object o)
+  {
     throw new java.lang.UnsupportedOperationException();
   }
 
@@ -82,12 +83,15 @@ public abstract class AbstractCollection implements Collection {
    * @exception UnsupportedOperationException if the add operation is not
    *   supported on this collection
    */
-  public boolean addAll(Collection c) {
-    Iterator i = c.iterator();
+  public boolean addAll(Collection c)
+  {
+    Iterator itr = c.iterator();
+    int size = c.size();
     boolean modified = false;
-    while (i.hasNext()) {
-      modified |= add(i.next());
-    }
+    for (int pos = 0; pos < size; pos++)
+      {
+	modified |= add(itr.next());
+      }
     return modified;
   }
 
@@ -101,12 +105,15 @@ public abstract class AbstractCollection implements Collection {
    * @exception UnsupportedOperationException if the Iterator returned by
    *   iterator does not provide an implementation of remove
    */
-  public void clear() {
-    Iterator i = iterator();
-    while (i.hasNext()) {
-      i.next();
-      i.remove();
-    }
+  public void clear()
+  {
+    Iterator itr = iterator();
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	itr.next();
+	itr.remove();
+      }
   }
 
   /**
@@ -120,25 +127,15 @@ public abstract class AbstractCollection implements Collection {
    * @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 i = iterator();
-
-    // This looks crazily inefficient, but it takes the test o==null outside
-    // the loop, saving time, and also saves needing to store the result of
-    // i.next() each time.
-    if (o == null) {
-      while (i.hasNext()) {
-        if (i.next() == null) {
-          return true;
-        }
-      }
-    } else {
-      while (i.hasNext()) {
-        if (o.equals(i.next())) {
-          return true;
-        }
+  public boolean contains(Object o)
+  {
+    Iterator itr = iterator();
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	if (o == null ? itr.next() == null : o.equals(itr.next()))
+	  return true;
       }
-    }
     return false;
   }
 
@@ -152,13 +149,15 @@ public abstract class AbstractCollection implements Collection {
    * @return true if this collection contains all the elements in the given
    *   collection
    */
-  public boolean containsAll(Collection c) {
-    Iterator i = c.iterator();
-    while (i.hasNext()) {
-      if (!contains(i.next())) {
-        return false;
+  public boolean containsAll(Collection c)
+  {
+    Iterator itr = c.iterator();
+    int size = c.size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	if (!contains(itr.next()))
+	  return false;
       }
-    }
     return true;
   }
 
@@ -168,7 +167,8 @@ public abstract class AbstractCollection implements Collection {
    *
    * @return true if this collection is empty.
    */
-  public boolean isEmpty() {
+  public boolean isEmpty()
+  {
     return size() == 0;
   }
 
@@ -189,27 +189,18 @@ public abstract class AbstractCollection implements Collection {
    * @exception UnsupportedOperationException if this collection's Iterator
    *   does not support the remove method
    */
-  public boolean remove(Object o) {
-    Iterator i = iterator();
-
-    // This looks crazily inefficient, but it takes the test o==null outside
-    // the loop, saving time, and also saves needing to store the result of
-    // i.next() each time.
-    if (o == null) {
-      while (i.hasNext()) {
-        if (i.next() == null) {
-          i.remove();
-	  return true;
-        }
+  public boolean remove(Object o)
+  {
+    Iterator itr = iterator();
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	if (o == null ? itr.next() == null : o.equals(itr.next()))
+	  {
+	    itr.remove();
+	    return true;
+	  }
       }
-    } else {
-      while (i.hasNext()) {
-        if (o.equals(i.next())) {
-          i.remove();
-          return true;
-        }
-      }
-    }
     return false;
   }
 
@@ -226,16 +217,20 @@ public abstract class AbstractCollection implements Collection {
    * @exception UnsupportedOperationException if this collection's Iterator
    *   does not support the remove method
    */
-  public boolean removeAll(Collection c) {
-    Iterator i = iterator();
-    boolean changed = false;
-    while (i.hasNext()) {
-      if (c.contains(i.next())) {
-        i.remove();
-        changed = true;
+  public boolean removeAll(Collection c)
+  {
+    Iterator itr = iterator();
+    int size = size();
+    boolean modified = false;
+    for (int pos = 0; pos < size; pos++)
+      {
+	if (c.contains(itr.next()))
+	  {
+	    itr.remove();
+	    modified = true;
+	  }
       }
-    }
-    return changed;
+    return modified;
   }
 
   /**
@@ -251,16 +246,20 @@ public abstract class AbstractCollection implements Collection {
    * @exception UnsupportedOperationException if this collection's Iterator
    *   does not support the remove method
    */
-  public boolean retainAll(Collection c) {
-    Iterator i = iterator();
-    boolean changed = false;
-    while (i.hasNext()) {
-      if (!c.contains(i.next())) {
-        i.remove();
-        changed = true;
+  public boolean retainAll(Collection c)
+  {
+    Iterator itr = iterator();
+    int size = size();
+    boolean modified = false;
+    for (int pos = 0; pos < size; pos++)
+      {
+	if (!c.contains(itr.next()))
+	  {
+	    itr.remove();
+	    modified = true;
+	  }
       }
-    }
-    return changed;
+    return modified;
   }
 
   /**
@@ -271,12 +270,14 @@ public abstract class AbstractCollection implements Collection {
    *
    * @return an array containing the elements of this collection
    */
-  public Object[] toArray() {
-    Object[] a = new Object[size()];
-    Iterator i = iterator();
-    for (int pos = 0; pos < a.length; pos++) {
-      a[pos] = i.next();
-    }
+  public Object[] toArray()
+  {
+    Iterator itr = iterator();
+    Object[]a = new Object[size()];
+    for (int pos = 0; pos < a.length; pos++)
+      {
+	a[pos] = itr.next();
+      }
     return a;
   }
 
@@ -298,18 +299,23 @@ public abstract class AbstractCollection implements Collection {
    * @exception ClassCastException if the type of the array precludes holding
    *   one of the elements of the Collection
    */
-  public Object[] toArray(Object[] a) {
-    final int n = size();
-    if (a.length < n) {
-      a = (Object[])Array.newInstance(a.getClass().getComponentType(), n);
-    }
-    Iterator i = iterator();
-    for (int pos = 0; pos < n; pos++) {
-      a[pos] = i.next();
-    }
-    if (a.length > n) {
-      a[n] = null;
-    }
+  public Object[] toArray(Object[]a)
+  {
+    int size = size();
+    if (a.length < size)
+      {
+	a = (Object[])Array.newInstance(a.getClass().getComponentType(),
+					size);
+      }
+    Iterator itr = iterator();
+    for (int pos = 0; pos < size; pos++)
+      {
+	a[pos] = itr.next();
+      }
+    if (a.length > size)
+      {
+	a[size] = null;
+      }
     return a;
   }
 
@@ -322,18 +328,18 @@ public abstract class AbstractCollection implements Collection {
    *
    * @return a String representation of the Collection
    */
-  public String toString() {
-    StringBuffer s = new StringBuffer();
-    s.append('[');
-    Iterator i = iterator();
-    boolean more = i.hasNext();
-    while(more) {
-      s.append(i.next());
-      if (more = i.hasNext()) {
-        s.append(", ");
+  public String toString()
+  {
+    Iterator itr = iterator();
+    int size = size();
+    String r = "[";
+    for (int pos = 0; pos < size; pos++)
+      {
+	r += itr.next();
+	if (pos < size - 1)
+	  r += ", ";
       }
-    }
-    s.append(']');
-    return s.toString();
+    r += "]";
+    return r;
   }
 }

libjava/java/util/AbstractMap.java

@@ -7,7 +7,7 @@ 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
@@ -31,88 +31,90 @@ executable file might be covered by the GNU General Public License. */
 
 package java.util;
 
-public abstract class AbstractMap implements Map {
-  
+public abstract class AbstractMap implements Map
+{
+  /**
+   * Remove all entries from this Map. This default implementation calls
+   * entrySet().clear().
+   *
+   * @throws UnsupportedOperationException
+   * @specnote The JCL book claims that this implementation always throws 
+   *           UnsupportedOperationException, while the online docs claim it
+   *           calls entrySet().clear(). We take the later to be correct.
+   */
   public void clear()
   {
     entrySet().clear();
   }
 
-  public boolean containsKey( Object key )
+  public boolean containsKey(Object key)
   {
     Object k;
-    Iterator entries = entrySet().iterator();
-  
-    while( entries.hasNext() )
-    {
-      k = ((Map.Entry)entries.next()).getKey();
-      if( key == null ? k == null : key.equals( k ) )
-	return true;
-    }
-
+    Set es = entrySet();
+    Iterator entries = es.iterator();
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	k = ((Map.Entry) entries.next()).getKey();
+	if (key == null ? k == null : key.equals(k))
+	  return true;
+      }
     return false;
   }
 
-  public boolean containsValue( Object value )
+  public boolean containsValue(Object value)
   {
     Object v;
-    Iterator entries = entrySet().iterator();
-  
-    while( entries.hasNext() )
-    {
-      v = ((Map.Entry)entries.next()).getValue();
-      if( value == null ? v == null : value.equals( v ) )
-	return true;
-    }
-
-    return false; 
+    Set es = entrySet();
+    Iterator entries = es.iterator();
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	v = ((Map.Entry) entries.next()).getValue();
+	if (value == null ? v == null : value.equals(v))
+	  return true;
+      }
+    return false;
   }
 
   public abstract Set entrySet();
 
-  public boolean equals( Object o )
+  public boolean equals(Object o)
   {
-    if( this == o )
+    if (o == this)
       return true;
-    
-    if( o == null || !( o instanceof Map ) )
+    if (!(o instanceof Map))
       return false;
-    
-    Map m = (Map)o;
-    if( m.size() != size() )
+
+    Map m = (Map) o;
+    Set s = m.entrySet();
+    Iterator itr = entrySet().iterator();
+    int size = size();
+
+    if (m.size() != size)
       return false;
-    
-    Object key, value1, value2;
-    Map.Entry entry;
-    Iterator entries = entrySet().iterator();
-    while( entries.hasNext() )
-    {
-      entry = (Map.Entry)entries.next();
-      key = entry.getKey();
-      value1 = entry.getValue();
-      value2 = m.get( key );
-      
-      if( !( ( value1 == null && value2 == null )
-	     || value1.equals( value2 ) ) )
-	return false;
-    }
-
-    return true;    
+
+    for (int pos = 0; pos < size; pos++)
+      {
+	if (!s.contains(itr.next()))
+	  return false;
+      }
+    return true;
   }
 
-  public Object get( Object key )
+  public Object get(Object key)
   {
-    Object k;
-    Map.Entry entry;
-    Iterator entries = entrySet().iterator();
-  
-    while( entries.hasNext() )
-    {
-      entry = (Map.Entry)entries.next();
-      k = entry.getKey();
-      if( key == null ? k == null : key.equals( k ) )
-	return entry.getValue();
-    }
+    Set s = entrySet();
+    Iterator entries = s.iterator();
+    int size = size();
+
+    for (int pos = 0; pos < size; pos++)
+      {
+	Map.Entry entry = (Map.Entry) entries.next();
+	Object k = entry.getKey();
+	if (key == null ? k == null : key.equals(k))
+	  return entry.getValue();
+      }
 
     return null;
   }
@@ -120,11 +122,12 @@ public abstract class AbstractMap implements Map {
   public int hashCode()
   {
     int hashcode = 0;
-    Iterator entries = entrySet().iterator();
-  
-    while( entries.hasNext() )
-      hashcode += entries.next().hashCode();
-
+    Iterator itr = entrySet().iterator();
+    int size = size();
+    for (int pos = 0; pos < size; pos++)
+      {
+	hashcode += itr.next().hashCode();
+      }
     return hashcode;
   }
 
@@ -135,13 +138,12 @@ public abstract class AbstractMap implements Map {
 
   public Set keySet()
   {
-    if( this.keySet == null )
-    {
-      this.keySet =
-	new AbstractSet()
+    if (this.keySet == null)
+      {
+	this.keySet = new AbstractSet()
 	{
 	  public int size()
-          {
+	  {
 	    return AbstractMap.this.size();
 	  }
 
@@ -149,70 +151,71 @@ public abstract class AbstractMap implements Map {
 	  {
 	    return AbstractMap.this.containsKey(key);
 	  }
-	  
+
 	  public Iterator iterator()
-          {
+	  {
 	    return new Iterator()
-            {
+	    {
 	      Iterator map_iterator = AbstractMap.this.entrySet().iterator();
-	      
+
 	      public boolean hasNext()
-              {
+	      {
 		return map_iterator.hasNext();
 	      }
 
 	      public Object next()
-              {
-		return ((Map.Entry)map_iterator.next()).getKey();
+	      {
+		return ((Map.Entry) map_iterator.next()).getKey();
 	      }
-	      
+
 	      public void remove()
-              {
+	      {
 		map_iterator.remove();
 	      }
 	    };
 	  }
 	};
-    }
-    
-    return this.keySet;    
+      }
+
+    return this.keySet;
   }
 
-  public Object put( Object key, Object value )
+  public Object put(Object key, Object value)
   {
     throw new UnsupportedOperationException();
   }
 
-  public void putAll( Map m )
+  public void putAll(Map m)
   {
     Map.Entry entry;
     Iterator entries = m.entrySet().iterator();
-    while( entries.hasNext() )
-    {
-      entry = (Map.Entry)entries.next();
-      put( entry.getKey(), entry.getValue() );
-    }
+    int size = m.size();
+
+    for (int pos = 0; pos < size; pos++)
+      {
+	entry = (Map.Entry) entries.next();
+	put(entry.getKey(), entry.getValue());
+      }
   }
 
-  public Object remove( Object key )
+  public Object remove(Object key)
   {
-    Object k, value;
-    Map.Entry entry;
     Iterator entries = entrySet().iterator();
-  
-    while( entries.hasNext() )
-    {
-      entry = (Map.Entry)entries.next();
-      k = entry.getKey();
-      if( key == null ? k == null : key.equals( k ) )
+    int size = size();
+
+    for (int pos = 0; pos < size; pos++)
       {
-	value = entry.getValue();
-	entries.remove();
-	return value;
+	Map.Entry entry = (Map.Entry) entries.next();
+	Object k = entry.getKey();
+	if (key == null ? k == null : key.equals(k))
+	  {
+	    Object value = entry.getValue();
+	    entries.remove();
+	    return value;
+	  }
       }
-    }
 
-    return null;    
+    return null;
   }
 
   public int size()
@@ -222,62 +225,58 @@ public abstract class AbstractMap implements Map {
 
   public String toString()
   {
-    StringBuffer sb = new StringBuffer("{");
-    String comma = "";
     Iterator entries = entrySet().iterator();
-  
-    while( entries.hasNext() )
-    {
-      Map.Entry entry = (Map.Entry)entries.next();
-      sb.append(comma).append(entry.getKey())
-	.append('=').append(entry.getValue());
-      comma = ", ";
-    }
-
-    return sb.append('}').toString();
+    int size = size();
+    String r = "{";
+    for (int pos = 0; pos < size; pos++)
+      {
+	r += entries.next();
+	if (pos < size - 1)
+	  r += ", ";
+      }
+    r += "}";
+    return r;
   }
 
   public Collection values()
   {
-    if( this.valueCollection == null )
-    {
-      this.valueCollection =
-	new AbstractCollection()
+    if (this.valueCollection == null)
+      {
+	this.valueCollection = new AbstractCollection()
 	{
 	  public int size()
-          {
+	  {
 	    return AbstractMap.this.size();
 	  }
-	  
+
 	  public Iterator iterator()
-          {
+	  {
 	    return new Iterator()
-            {
+	    {
 	      Iterator map_iterator = AbstractMap.this.entrySet().iterator();
-	      
+
 	      public boolean hasNext()
-              {
+	      {
 		return map_iterator.hasNext();
 	      }
 
 	      public Object next()
-              {
-		return ((Map.Entry)map_iterator.next()).getValue();
+	      {
+		return ((Map.Entry) map_iterator.next()).getValue();
 	      }
-	      
+
 	      public void remove()
-              {
+	      {
 		map_iterator.remove();
 	      }
 	    };
 	  }
 	};
-    }
-    
+      }
+
     return this.valueCollection;
   }
 
-
   private Collection valueCollection = null;
   private Set keySet = null;
 }

libjava/java/util/AbstractSequentialList.java

 /* AbstractSequentialList.java -- List implementation for sequential access
-   Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -7,7 +7,7 @@ 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
@@ -36,7 +36,8 @@ package java.util;
  * Abstract superclass to make it easier to implement the List interface when
  * backed by a sequential-access store, such as a linked list.
  */
-public abstract class AbstractSequentialList extends AbstractList {
+public abstract class AbstractSequentialList extends AbstractList
+{
 
   /**
    * Returns a ListIterator over the list, starting from position index.
@@ -57,27 +58,30 @@ public abstract class AbstractSequentialList extends AbstractList {
    * @exception UnsupportedOperationException if the iterator returned by
    *   listIterator(index) does not support the add method.
    */
-  public void add(int index, Object o) {
+  public void add(int index, Object o)
+  {
     ListIterator i = listIterator(index);
     i.add(o);
   }
 
-  public boolean addAll(int index, Collection c) {
-    boolean changed = false;
+  public boolean addAll(int index, Collection c)
+  {
+    boolean modified = false;
     Iterator ci = c.iterator();
+    int size = c.size();
     ListIterator i = listIterator(index);
-    while (ci.hasNext()) {
-      i.add(ci.next());
-      changed = true;
-    }
-    return changed;
+    for (int pos = 0; pos < size; pos++)
+      {
+	i.add(ci.next());
+      }
+    return (size > 0);
   }
 
-  public Object get(int index) {
+  public Object get(int index)
+  {
     ListIterator i = listIterator(index);
-    if (!i.hasNext()) {
+    if (index < 0 || index > size())
       throw new IndexOutOfBoundsException();
-    }
     return i.next();
   }
 
@@ -87,25 +91,26 @@ public abstract class AbstractSequentialList extends AbstractList {
    *
    * @return an Iterator over this List
    */
-  public Iterator iterator() {
+  public Iterator iterator()
+  {
     return listIterator();
   }
 
-  public Object remove(int index) {
+  public Object remove(int index)
+  {
     ListIterator i = listIterator(index);
-    if (!i.hasNext()) {
+    if (index < 0 || index > size())
       throw new IndexOutOfBoundsException();
-    }
     Object removed = i.next();
     i.remove();
     return removed;
   }
 
-  public Object set(int index, Object o) {
+  public Object set(int index, Object o)
+  {
     ListIterator i = listIterator(index);
-    if (!i.hasNext()) {
+    if (index < 0 || index > size())
       throw new IndexOutOfBoundsException();
-    }
     Object old = i.next();
     i.set(o);
     return old;

libjava/java/util/AbstractSet.java

 /* AbstractSet.java -- Abstract implementation of most of Set
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 2000 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -7,7 +7,7 @@ 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
@@ -36,7 +36,8 @@ package java.util;
  * class simply provides implementations of equals() and hashCode() to fulfil
  * the requirements placed on them by the Set interface.
  */
-public abstract class AbstractSet extends AbstractCollection implements Set {
+public abstract class AbstractSet extends AbstractCollection implements Set
+{
 
   /**
    * Tests whether the given object is equal to this Set. This implementation
@@ -48,14 +49,14 @@ public abstract class AbstractSet extends AbstractCollection implements Set {
    * @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) {
-    if (o == this) {
+  public boolean equals(Object o)
+  {
+    if (o == this)
       return true;
-    } else if (o instanceof Set && ((Set)o).size() == size()) {
-      return containsAll((Collection)o);
-    } else {
+    else if (o instanceof Set && ((Set) o).size() == size())
+      return containsAll((Collection) o);
+    else
       return false;
-    }
   }
 
   /**
@@ -66,15 +67,17 @@ public abstract class AbstractSet extends AbstractCollection implements Set {
    *
    * @return a hash code for this Set
    */
-  public int hashCode() {
+  public int hashCode()
+  {
+    Iterator itr = iterator();
+    int size = size();
     int hash = 0;
-    Iterator i = iterator();
-    while (i.hasNext()) {
-      try {
-        hash += i.next().hashCode();
-      } catch (NullPointerException e) {
+    for (int pos = 0; pos < size; pos++)
+      {
+	Object obj = itr.next();
+	if (obj != null)
+	  hash += obj.hashCode();
       }
-    }
     return hash;
   }
 }