3 files changed, 78 insertions, 4 deletions

diff --git a/api/current.xml b/api/current.xml
index 1cdf0e9..5f732e1 100644
--- a/api/current.xml
+++ b/api/current.xml
@@ -206346,6 +206346,19 @@
  visibility="public"
 >
 </method>
+<method name="remove"
+ return="V"
+ abstract="false"
+ native="false"
+ synchronized="true"
+ static="false"
+ final="true"
+ deprecated="not deprecated"
+ visibility="public"
+>
+<parameter name="key" type="K">
+</parameter>
+</method>
 <method name="size"
  return="int"
  abstract="false"
@@ -265592,7 +265605,7 @@
  deprecated="not deprecated"
  visibility="public"
 >
-<parameter name="t" type="T">
+<parameter name="arg0" type="T">
 </parameter>
 </method>
 </interface>
diff --git a/core/java/android/util/LruCache.java b/core/java/android/util/LruCache.java
index 2122050..5578e6a 100644
--- a/core/java/android/util/LruCache.java
+++ b/core/java/android/util/LruCache.java
@@ -51,6 +51,10 @@ import java.util.Map;
  *         cache.put(key, value);
  *     }
  *   }}</pre>
+ *
+ * <p>This class does not allow null to be used as a key or value. A return
+ * value of null from {@link #get}, {@link #put} or {@link #remove} is
+ * unambiguous: the key was not in the cache.
  */
 public class LruCache<K, V> {
     private final LinkedHashMap<K, V> map;
@@ -86,7 +90,7 @@ public class LruCache<K, V> {
      */
     public synchronized final V get(K key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
 
         V result = map.get(key);
@@ -118,7 +122,7 @@ public class LruCache<K, V> {
      */
     public synchronized final V put(K key, V value) {
         if (key == null || value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null || value == null");
         }
 
         putCount++;
@@ -133,7 +137,7 @@ public class LruCache<K, V> {
 
     private void trimToSize(int maxSize) {
         while (size > maxSize) {
-            Map.Entry<K, V> toEvict = map.eldest();
+            Map.Entry<K, V> toEvict = map.eldest(); // equal to map.entrySet().iterator().next();
             if (toEvict == null) {
                 break; // map is empty; if size is not 0 then throw an error below
             }
@@ -155,6 +159,24 @@ public class LruCache<K, V> {
     }
 
     /**
+     * Removes the entry for {@code key} if it exists.
+     *
+     * @return the previous value mapped by {@code key}. Although that entry is
+     *     no longer cached, it has not been passed to {@link #entryEvicted}.
+     */
+    public synchronized final V remove(K key) {
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        }
+
+        V previous = map.remove(key);
+        if (previous != null) {
+            size -= safeSizeOf(key, previous);
+        }
+        return previous;
+    }
+
+    /**
      * Called for entries that have reached the tail of the least recently used
      * queue and are be removed. The default implementation does nothing.
      */
diff --git a/core/tests/coretests/src/android/util/LruCacheTest.java b/core/tests/coretests/src/android/util/LruCacheTest.java
index 506315d..cf252e6 100644
--- a/core/tests/coretests/src/android/util/LruCacheTest.java
+++ b/core/tests/coretests/src/android/util/LruCacheTest.java
@@ -337,6 +337,45 @@ public final class LruCacheTest extends TestCase {
         assertSnapshot(cache);
     }
 
+    public void testRemoveDoesNotCallEntryEvicted() {
+        LruCache<String, String> cache = new LruCache<String, String>(10) {
+            @Override protected void entryEvicted(String key, String value) {
+                fail();
+            }
+        };
+        cache.put("a", "A");
+        assertEquals("A", cache.remove("a"));
+    }
+
+    public void testRemoveWithCustomSizes() {
+        LruCache<String, String> cache = new LruCache<String, String>(10) {
+            @Override protected int sizeOf(String key, String value) {
+                return value.length();
+            }
+        };
+        cache.put("a", "123456");
+        cache.put("b", "1234");
+        cache.remove("a");
+        assertEquals(4, cache.size());
+    }
+
+    public void testRemoveAbsentElement() {
+        LruCache<String, String> cache = new LruCache<String, String>(10);
+        cache.put("a", "A");
+        cache.put("b", "B");
+        assertEquals(null, cache.remove("c"));
+        assertEquals(2, cache.size());
+    }
+
+    public void testRemoveNullThrows() {
+        LruCache<String, String> cache = new LruCache<String, String>(10);
+        try {
+            cache.remove(null);
+            fail();
+        } catch (NullPointerException expected) {
+        }
+    }
+
     private LruCache<String, String> newCreatingCache() {
         return new LruCache<String, String>(3) {
             @Override protected String create(String key) {