[guanchengang]

LinkedCaseInsensitiveMap stores its data in a targetMap that is created as an anonymous LinkedHashMap subclass. This anonymous class overrides containsKey(...) and removeEldestEntry(...) with closures that refer back to the enclosing LinkedCaseInsensitiveMap instance via the compiler-generated this$0 field.
The copy constructor, however, does:

this.targetMap = (LinkedHashMap<String, V>) other.targetMap.clone();

Object.clone() is a shallow copy: the clone of the anonymous LinkedHashMap still holds a this$0 reference pointing at the original LinkedCaseInsensitiveMap, not the newly created copy. As a result, calls routed through the copied targetMap's overrides (containsKey, removeEldestEntry) end up operating on the source instance's state instead of the copy's.

The following snippet demonstrates that a copied map cannot be mutated consistently:

LinkedCaseInsensitiveMap<String> map = new LinkedCaseInsensitiveMap<>();
map.put("key", "value");

LinkedCaseInsensitiveMap<String> cmap = map.clone();
cmap.remove("key");

// After remove("key"), the two views of the copy disagree:
System.out.println(cmap.keySet().contains("key")); // true
System.out.println(cmap.containsKey("key")); // false

// this$0 of the copied anonymous targetMap is the original map, not cmap:
Field targetMap = LinkedCaseInsensitiveMap.class.getDeclaredField("targetMap");
targetMap.setAccessible(true);
Object mapTargetMap = targetMap.get(map);
Object cmapTargetMap = targetMap.get(cmap);

Field mapThis$0  = mapTargetMap.getClass().getDeclaredField("this$0");
Field cmapThis$0 = cmapTargetMap.getClass().getDeclaredField("this$0");
mapThis$0.setAccessible(true);
cmapThis$0.setAccessible(true);

System.out.println(mapThis$0.get(mapTargetMap) == cmapThis$0.get(cmapTargetMap)); // true