A DESCRIPTION OF THE REQUEST :
AbstractMap.keySet() and AbstractMap.values() should delegate clear() and isEmpty() to AbstractMap.clear() and AbstractMap.isEmpty(). The current keySet() and values() use the AbstractCollection implementation of clear() requires linear time when a faster version may be available.
ConcurrentMap implementation usually have an isEmpty() method that runs faster than size(). The internal views always delegate to size().

The ConcurrentHashMap collection views fail to override isEmpty().

JUSTIFICATION :
Improve performance. Make all of the isEmpty() and clear() operations perform in a uniform way.

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
All clear and isEmpty method perform the same for the Map and the view collections.

C:\Temp>diff -u c:\temp\AbstractMap.java C:\temp\patch\AbstractMap.java
--- c:\temp\AbstractMap.java 2006-06-26 13:57:27.877009000 -0500
+++ C:\temp\patch\AbstractMap.java 2007-01-25 09:01:23.747605200 -0600
@@ -318,6 +318,14 @@
                     };
                }

+ public void clear() {
+ AbstractMap.this.clear();
+ }
+
+ public boolean isEmpty() {
+ return AbstractMap.this.isEmpty();
+ }
+
                public int size() {
                    return AbstractMap.this.size();
                }
@@ -365,6 +373,14 @@
                        }
                     };
                 }
+
+ public void clear() {
+ AbstractMap.this.clear();
+ }
+
+ public boolean isEmpty() {
+ return AbstractMap.this.isEmpty();
+ }

                public int size() {
                    return AbstractMap.this.size();
ACTUAL -
Test number=1
ClearEmptyTest$TestMap.keySet().isEmpty()=517105
ClearEmptyTest$TestMap.values().isEmpty()=215111
ClearEmptyTest$TestMap.keySet().clear()=37462862
ClearEmptyTest$TestMap.values().clear()=29864130
java.util.TreeMap.keySet().isEmpty()=88279
java.util.TreeMap.values().isEmpty()=5588
java.util.TreeMap.keySet().clear()=7264
java.util.TreeMap.values().clear()=65093
ClearEmptyTest$TestMap.keySet().isEmpty()=5513270
ClearEmptyTest$TestMap.values().isEmpty()=4802007
ClearEmptyTest$TestMap.keySet().clear()=119777793
ClearEmptyTest$TestMap.values().clear()=130156207
java.util.concurrent.ConcurrentSkipListMap.keySet().isEmpty()=267073
java.util.concurrent.ConcurrentSkipListMap.values().isEmpty()=46374
java.util.concurrent.ConcurrentSkipListMap.keySet().clear()=19835
java.util.concurrent.ConcurrentSkipListMap.values().clear()=117892

---------- BEGIN SOURCE ----------
import java.util.*;
import java.util.concurrent.*;

public class ClearEmptyTest {

  public static void main(String[] args) {
    
    for(int retries=1; retries<=1; retries++) {
      System.out.println("Test number="+ 1);
      Map<Integer, Integer> map = new TestMap(new TreeMap());
      fill(map);
      testIsEmpty(map);
      testClear(map);
      
      System.runFinalization();
      System.gc();
      System.runFinalization();
      
      map = new TreeMap();
      fill(map);
      testIsEmpty(map);
      testClear(map);

      System.runFinalization();
      System.gc();
      System.runFinalization();
      
      map = new TestMap(new ConcurrentSkipListMap());
      fill(map);
      testIsEmpty(map);
      testClear(map);

      System.runFinalization();
      System.gc();
      System.runFinalization();
      
      map = new ConcurrentSkipListMap();
      fill(map);
      testIsEmpty(map);
      testClear(map);
    }
  }
  
  private static void testIsEmpty(Map map) {
    long start = System.nanoTime();
    long end;
    map.keySet().isEmpty();
    end = System.nanoTime();
    System.out.println(map.getClass().getName() +".keySet().isEmpty()="
                       + (end - start));
    
    start = System.nanoTime();
    map.values().isEmpty();
    end = System.nanoTime();
    System.out.println(map.getClass().getName() +".values().isEmpty()="
                       + (end - start));
  }
  
  private static void testClear(Map map) {
    long start = System.nanoTime();
    long end;
    map.keySet().clear();
    end = System.nanoTime();
    System.out.println(map.getClass().getName() +".keySet().clear()="
                       + (end - start));
    fill(map);
    
    start = System.nanoTime();
    map.values().clear();
    end = System.nanoTime();
    System.out.println(map.getClass().getName() +".values().clear()="
                       + (end - start));
  }
  
  private static void fill(Map<Integer, Integer> map) {
    for(int i=0; i<100000; i++) {
      Integer kv = Integer.valueOf(i);
      map.put(kv, kv);
    }
  }
  
  private static class TestMap extends AbstractMap<Integer, Integer> {
    private final Map<Integer, Integer> m;
    
    public TestMap(final Map<Integer, Integer> m) {
      this.m = m;
    }
    
    public Set<Map.Entry<Integer, Integer>> entrySet() {
      return m.entrySet();
    }
    
    public Integer put(Integer key, Integer value) {
      return m.put(key, value);
    }
  };
}
---------- END SOURCE ----------

CUSTOMER SUBMITTED WORKAROUND :
Override keySet() and values() like most map implementations.