1001         @SuppressWarnings("unchecked")
1002         Entry<K,V> e = (Entry<K,V>)tab[index];
1003         for (Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
1004             if ((e.hash == hash) && e.key.equals(key) && e.value.equals(value)) {
1005                 modCount++;
1006                 if (prev != null) {
1007                     prev.next = e.next;
1008                 } else {
1009                     tab[index] = e.next;
1010                 }
1011                 count--;
1012                 e.value = null;
1013                 return true;
1014             }
1015         }
1016         return false;
1017     }
1018 
1019     @Override
1020     public synchronized boolean replace(K key, V oldValue, V newValue) {


1021         Entry<?,?> tab[] = table;
1022         int hash = hash(key);
1023         int index = (hash & 0x7FFFFFFF) % tab.length;
1024         @SuppressWarnings("unchecked")
1025         Entry<K,V> e = (Entry<K,V>)tab[index];
1026         for (; e != null; e = e.next) {
1027             if ((e.hash == hash) && e.key.equals(key)) {
1028                 if (e.value.equals(oldValue)) {
1029                     e.value = newValue;
1030                     return true;
1031                 } else {
1032                     return false;
1033                 }
1034             }
1035         }
1036         return false;
1037     }
1038 
1039     @Override
1040     public synchronized V replace(K key, V value) {

1041         Entry<?,?> tab[] = table;
1042         int hash = hash(key);
1043         int index = (hash & 0x7FFFFFFF) % tab.length;
1044         @SuppressWarnings("unchecked")
1045         Entry<K,V> e = (Entry<K,V>)tab[index];
1046         for (; e != null; e = e.next) {
1047             if ((e.hash == hash) && e.key.equals(key)) {
1048                 V oldValue = e.value;
1049                 e.value = value;
1050                 return oldValue;
1051             }
1052         }
1053         return null;
1054     }
1055 
1056     @Override
1057     public synchronized V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
1058         Objects.requireNonNull(mappingFunction);
1059 
1060         Entry<?,?> tab[] = table;

1001         @SuppressWarnings("unchecked")
1002         Entry<K,V> e = (Entry<K,V>)tab[index];
1003         for (Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
1004             if ((e.hash == hash) && e.key.equals(key) && e.value.equals(value)) {
1005                 modCount++;
1006                 if (prev != null) {
1007                     prev.next = e.next;
1008                 } else {
1009                     tab[index] = e.next;
1010                 }
1011                 count--;
1012                 e.value = null;
1013                 return true;
1014             }
1015         }
1016         return false;
1017     }
1018 
1019     @Override
1020     public synchronized boolean replace(K key, V oldValue, V newValue) {
1021         Objects.requireNonNull(oldValue);
1022         Objects.requireNonNull(newValue);
1023         Entry<?,?> tab[] = table;
1024         int hash = hash(key);
1025         int index = (hash & 0x7FFFFFFF) % tab.length;
1026         @SuppressWarnings("unchecked")
1027         Entry<K,V> e = (Entry<K,V>)tab[index];
1028         for (; e != null; e = e.next) {
1029             if ((e.hash == hash) && e.key.equals(key)) {
1030                 if (e.value.equals(oldValue)) {
1031                     e.value = newValue;
1032                     return true;
1033                 } else {
1034                     return false;
1035                 }
1036             }
1037         }
1038         return false;
1039     }
1040 
1041     @Override
1042     public synchronized V replace(K key, V value) {
1043         Objects.requireNonNull(value);
1044         Entry<?,?> tab[] = table;
1045         int hash = hash(key);
1046         int index = (hash & 0x7FFFFFFF) % tab.length;
1047         @SuppressWarnings("unchecked")
1048         Entry<K,V> e = (Entry<K,V>)tab[index];
1049         for (; e != null; e = e.next) {
1050             if ((e.hash == hash) && e.key.equals(key)) {
1051                 V oldValue = e.value;
1052                 e.value = value;
1053                 return oldValue;
1054             }
1055         }
1056         return null;
1057     }
1058 
1059     @Override
1060     public synchronized V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
1061         Objects.requireNonNull(mappingFunction);
1062 
1063         Entry<?,?> tab[] = table;