Fix LinkedCaseInsensitiveMap collection methods

Ensure that results returned from keySet, entrySet & values are tracked
to remove case insensitive keys from the source map.

Closes gh-22821

Author: philwebb

spring-core/src/main/java/org/springframework/util/LinkedCaseInsensitiveMap.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +17,17 @@
 package org.springframework.util;
 
 import java.io.Serializable;
+import java.util.AbstractCollection;
+import java.util.AbstractSet;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.springframework.lang.Nullable;
@@ -37,6 +42,7 @@
  * <p>Does <i>not</i> support {@code null} keys.
  *
  * @author Juergen Hoeller
+ * @author Phillip Webb
  * @since 3.0
  * @param <V> the value type
  */
@@ -49,6 +55,12 @@ public class LinkedCaseInsensitiveMap<V> implements Map<String, V>, Serializable
 
 	private final Locale locale;
 
+	private transient Set<String> keySet;
+
+	private transient Collection<V> values;
+
+	private transient Set<Entry<String, V>> entrySet;
+
 
 	/**
 	 * Create a new LinkedCaseInsensitiveMap that stores case-insensitive keys
@@ -98,7 +110,7 @@ public boolean containsKey(Object key) {
 			protected boolean removeEldestEntry(Map.Entry<String, V> eldest) {
 				boolean doRemove = LinkedCaseInsensitiveMap.this.removeEldestEntry(eldest);
 				if (doRemove) {
-					caseInsensitiveKeys.remove(convertKey(eldest.getKey()));
+					removeCaseInsensitiveKey(eldest.getKey());
 				}
 				return doRemove;
 			}
@@ -208,7 +220,7 @@ public V computeIfAbsent(String key, Function<? super String, ? extends V> mappi
 	@Nullable
 	public V remove(Object key) {
 		if (key instanceof String) {
-			String caseInsensitiveKey = this.caseInsensitiveKeys.remove(convertKey((String) key));
+			String caseInsensitiveKey = removeCaseInsensitiveKey((String) key);
 			if (caseInsensitiveKey != null) {
 				return this.targetMap.remove(caseInsensitiveKey);
 			}
@@ -224,17 +236,32 @@ public void clear() {
 
 	@Override
 	public Set<String> keySet() {
-		return this.targetMap.keySet();
+		Set<String> keySet = this.keySet;
+		if (keySet == null) {
+			keySet = new KeySet(this.targetMap.keySet());
+			this.keySet = keySet;
+		}
+		return keySet;
 	}
 
 	@Override
 	public Collection<V> values() {
-		return this.targetMap.values();
+		Collection<V> values = this.values;
+		if (values == null) {
+			values = new Values(this.targetMap.values());
+			this.values = values;
+		}
+		return values;
 	}
 
 	@Override
 	public Set<Entry<String, V>> entrySet() {
-		return this.targetMap.entrySet();
+		Set<Entry<String, V>> entrySet = this.entrySet;
+		if (entrySet == null) {
+			entrySet = new EntrySet(this.targetMap.entrySet());
+			this.entrySet = entrySet;
+		}
+		return entrySet;
 	}
 
 	@Override
@@ -293,4 +320,216 @@ protected boolean removeEldestEntry(Map.Entry<String, V> eldest) {
 		return false;
 	}
 
+	private String removeCaseInsensitiveKey(String key) {
+		return this.caseInsensitiveKeys.remove(convertKey(key));
+	}
+
+
+	private class KeySet extends AbstractSet<String> {
+
+		private final Set<String> delegate;
+
+
+		KeySet(Set<String> delegate) {
+			this.delegate = delegate;
+		}
+
+
+		@Override
+		public int size() {
+			return this.delegate.size();
+		}
+
+		@Override
+		public boolean contains(Object o) {
+			return this.delegate.contains(o);
+		}
+
+		@Override
+		public Iterator<String> iterator() {
+			return new KeySetIterator();
+		}
+
+		@Override
+		public boolean remove(Object o) {
+			return LinkedCaseInsensitiveMap.this.remove(o) != null;
+		}
+
+		@Override
+		public void clear() {
+			LinkedCaseInsensitiveMap.this.clear();
+		}
+
+		@Override
+		public Spliterator<String> spliterator() {
+			return this.delegate.spliterator();
+		}
+
+		@Override
+		public void forEach(Consumer<? super String> action) {
+			this.delegate.forEach(action);
+		}
+
+	}
+
+
+	private class Values extends AbstractCollection<V> {
+
+		private final Collection<V> delegate;
+
+
+		Values(Collection<V> delegate) {
+			this.delegate = delegate;
+		}
+
+
+		@Override
+		public int size() {
+			return this.delegate.size();
+		}
+
+		@Override
+		public boolean contains(Object o) {
+			return this.delegate.contains(o);
+		}
+
+		@Override
+		public Iterator<V> iterator() {
+			return new ValuesIterator();
+		}
+
+		@Override
+		public void clear() {
+			LinkedCaseInsensitiveMap.this.clear();
+		}
+
+		@Override
+		public Spliterator<V> spliterator() {
+			return this.delegate.spliterator();
+		}
+
+		@Override
+		public void forEach(Consumer<? super V> action) {
+			this.delegate.forEach(action);
+		}
+
+	}
+
+
+	private class EntrySet extends AbstractSet<Entry<String, V>> {
+
+		private final Set<Entry<String, V>> delegate;
+
+
+		public EntrySet(Set<Entry<String, V>> delegate) {
+			this.delegate = delegate;
+		}
+
+
+		@Override
+		public int size() {
+			return this.delegate.size();
+		}
+
+		@Override
+		public boolean contains(Object o) {
+			return this.delegate.contains(o);
+		}
+
+		@Override
+		public Iterator<Entry<String, V>> iterator() {
+			return new EntrySetIterator();
+		}
+
+
+		@Override
+		@SuppressWarnings("unchecked")
+		public boolean remove(Object o) {
+			if (this.delegate.remove(o)) {
+				removeCaseInsensitiveKey(((Map.Entry<String, V>) o).getKey());
+				return true;
+			}
+			return false;
+		}
+
+
+		@Override
+		public void clear() {
+			this.delegate.clear();
+			caseInsensitiveKeys.clear();
+		}
+
+		@Override
+		public Spliterator<Entry<String, V>> spliterator() {
+			return this.delegate.spliterator();
+		}
+
+		@Override
+		public void forEach(Consumer<? super Entry<String, V>> action) {
+			this.delegate.forEach(action);
+		}
+
+	}
+
+
+	private class EntryIterator {
+
+		private final Iterator<Entry<String, V>> delegate;
+
+		private Entry<String, V> last;
+
+		public EntryIterator() {
+			this.delegate = targetMap.entrySet().iterator();
+		}
+
+		public Entry<String, V> nextEntry() {
+			Entry<String, V> entry = this.delegate.next();
+			this.last = entry;
+			return entry;
+		}
+
+		public boolean hasNext() {
+			return this.delegate.hasNext();
+		}
+
+		public void remove() {
+			this.delegate.remove();
+			if(this.last != null) {
+				removeCaseInsensitiveKey(this.last.getKey());
+				this.last = null;
+			}
+		}
+
+	}
+
+
+	private class KeySetIterator extends EntryIterator implements Iterator<String> {
+
+		@Override
+		public String next() {
+			return nextEntry().getKey();
+		}
+
+	}
+
+
+	private class ValuesIterator extends EntryIterator implements Iterator<V> {
+
+		@Override
+		public V next() {
+			return nextEntry().getValue();
+		}
+
+	}
+
+
+	private class EntrySetIterator extends EntryIterator implements Iterator<Entry<String, V>> {
+
+		@Override
+		public Entry<String, V> next() {
+			return nextEntry();
+		}
+
+	}
+
 }