1003         @SuppressWarnings("unchecked")
1004         Entry<K,V> e = (Entry<K,V>)tab[index];
1005         for (Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
1006             if ((e.hash == hash) && e.key.equals(key) && e.value.equals(value)) {
1007                 modCount++;
1008                 if (prev != null) {
1009                     prev.next = e.next;
1010                 } else {
1011                     tab[index] = e.next;
1012                 }
1013                 count--;
1014                 e.value = null;
1015                 return true;
1016             }
1017         }
1018         return false;
1019     }
1020 
1021     @Override
1022     public synchronized boolean replace(K key, V oldValue, V 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         Entry<?,?> tab[] = table;
1044         int hash = hash(key);
1045         int index = (hash & 0x7FFFFFFF) % tab.length;
1046         @SuppressWarnings("unchecked")
1047         Entry<K,V> e = (Entry<K,V>)tab[index];
1048         for (; e != null; e = e.next) {
1049             if ((e.hash == hash) && e.key.equals(key)) {
1050                 V oldValue = e.value;
1051                 e.value = value;
1052                 return oldValue;
1053             }
1054         }
1055         return null;
1056     }
1057 
1058     @Override
1059     public synchronized V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
1060         Objects.requireNonNull(mappingFunction);
1061 
1062         Entry<?,?> tab[] = table;

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