Added methods isEmpty(), putAll(), toArray() to interfaces List and Map

classpath/java/util/ArrayList.java

@@ -14,6 +14,13 @@ public class ArrayList<T> implements List<T> {
     this(0);
   }
 
+  public ArrayList(Collection<T> source) {
+    this(source.size());
+    for (T o : source) {
+      add(o);
+    }
+  }
+
   private void grow() {
     if (array == null || size >= array.length) {
       resize(array == null ? MinimumCapacity : array.length * 2);
@@ -118,6 +125,27 @@ public class ArrayList<T> implements List<T> {
     return false;
   }
 
+  public boolean isEmpty() {
+    return size() == 0;
+  }
+
+  public <S> S[] toArray(S[] a) {
+    Object[] retVal = null;
+
+    if (a.length >= size) {
+      retVal = a;
+    } else {
+      retVal = new Object[size];
+    }
+    for (int i = 0; i < size; ++i) {
+      retVal[i] = array[i];
+    }
+    if (a.length > size) {
+      a[size] = null;
+    }
+    return (S[])retVal;
+  }
+
   public void clear() {
     array = null;
     size = 0;

classpath/java/util/Arrays.java

@@ -38,6 +38,14 @@ public class Arrays {
         return array[index];
       }
 
+      public <S> S[] toArray(S[] a) {
+        return (S[])array;
+      }
+
+      public boolean isEmpty() {
+        return size() == 0;
+      }
+
       public T remove(int index) {
         throw new UnsupportedOperationException();        
       }

classpath/java/util/HashMap.java

@@ -44,6 +44,10 @@ public class HashMap<K, V> implements Map<K, V> {
     return r;
   }
 
+  public boolean isEmpty() {
+    return size() == 0;
+  }
+
   public int size() {
     return size;
   }
@@ -179,6 +183,12 @@ public class HashMap<K, V> implements Map<K, V> {
     return (c == null ? null : c.getValue());
   }
 
+  public void putAll(Map<? extends K,? extends V> elts) {
+    for (Map.Entry<? extends K, ? extends V> entry : elts.entrySet()) {
+      put(entry.getKey(), entry.getValue());
+    }
+  }
+
   public V remove(K key) {
     Cell<K, V> c = removeCell(key);
     return (c == null ? null : c.getValue());

classpath/java/util/Hashtable.java

@@ -15,6 +15,10 @@ public class Hashtable<K, V> implements Map<K, V> {
     return map.toString();
   }
 
+  public synchronized boolean isEmpty() {
+    return map.isEmpty();
+  }
+
   public synchronized int size() {
     return map.size();
   }
@@ -35,6 +39,10 @@ public class Hashtable<K, V> implements Map<K, V> {
     return map.put(key, value);
   }
 
+  public synchronized void putAll(Map<? extends K,? extends V> elts) {
+    map.putAll(elts);
+  }
+
   public synchronized V remove(K key) {
     return map.remove(key);
   }

classpath/java/util/IdentityHashMap.java

@@ -11,6 +11,10 @@ public class IdentityHashMap<K, V> implements Map<K, V> {
     this(0);
   }
 
+  public boolean isEmpty() {
+    return map.isEmpty();
+  }
+
   public int size() {
     return map.size();
   }
@@ -31,6 +35,10 @@ public class IdentityHashMap<K, V> implements Map<K, V> {
     return map.put(key, value);
   }
 
+  public void putAll(Map<? extends K,? extends V> elts) {
+    map.putAll(elts);
+  }
+
   public V remove(K key) {
     return map.remove(key);
   }

classpath/java/util/LinkedList.java

@@ -73,6 +73,23 @@ public class LinkedList<T> implements List<T> {
     }
   }
 
+  public <S> S[] toArray(S[] a) {
+    Object[] retVal = null;
+    if (a.length >= size) {
+      retVal = a;
+    } else {
+      retVal = new Object[size];
+    }
+    int i=0;
+    for (Object o : this) {
+      retVal[i++] = o;
+    }
+    if (a.length > size) {
+      a[size] = null;
+    }
+    return (S[])retVal;
+  }
+
   public int size() {
     return size;
   }
@@ -124,6 +141,10 @@ public class LinkedList<T> implements List<T> {
     return c.value;
   }
 
+  public boolean isEmpty() {
+    return size() == 0;
+  }
+
   public T removeFirst() {
     if (front != null) {
       T v = front.value;

classpath/java/util/List.java

@@ -4,4 +4,8 @@ public interface List<T> extends Collection<T> {
   public T get(int index);
 
   public T remove(int index);
+
+  public boolean isEmpty();
+
+  public <S> S[] toArray(S[] a);
 }

classpath/java/util/Map.java

@@ -1,6 +1,8 @@
 package java.util;
 
 public interface Map<K, V> {
+  public boolean isEmpty();
+
   public int size();
 
   public boolean containsKey(K key);
@@ -11,6 +13,8 @@ public interface Map<K, V> {
 
   public V put(K key, V value);
 
+  public void putAll(Map<? extends K,? extends V> elts);
+
   public V remove(K key);
 
   public void clear();

classpath/java/util/Vector.java

@@ -11,6 +11,13 @@ public class Vector<T> implements List<T> {
     this(0);
   }
 
+  public Vector(List<T> list) {
+    this(list.size());
+    for (T o : list) {
+      add(o);
+    }
+  }
+
   public synchronized int size() {
     return list.size();
   }
@@ -39,6 +46,14 @@ public class Vector<T> implements List<T> {
     return list.remove(index);
   }
 
+  public synchronized boolean isEmpty() {
+    return list.isEmpty();
+  }
+
+  public synchronized <S> S[] toArray(S[] a) {
+    return list.toArray(a);
+  }
+
   public T removeElementAt(int index) {
     return remove(index);
   }

classpath/java/util/WeakHashMap.java

@@ -26,6 +26,10 @@ public class WeakHashMap<K, V> implements Map<K, V> {
     }
   }
 
+  public boolean isEmpty() {
+    return map.isEmpty();
+  }
+
   public int size() {
     return map.size();
   }
@@ -50,6 +54,10 @@ public class WeakHashMap<K, V> implements Map<K, V> {
     return map.put(key, value);
   }
 
+  public void putAll(Map<? extends K,? extends V> elts) {
+    map.putAll(elts);
+  }
+
   public V remove(K key) {
     poll();
     return map.remove(key);