List<V> oldValues = getCopy(key);
    ListIterator<V> keyValues = new ValueForKeyIterator(key);
    Iterator<? extends V> newValues = values.iterator();

    // Replace existing values, if any.
    while (keyValues.hasNext() && newValues.hasNext()) {
      keyValues.next();
      keyValues.set(newValues.next());
    }

    // Remove remaining old values, if any.
    while (keyValues.hasNext()) {
      keyValues.next();

    return (K) keys[index];
  }

  int getValue(int index) {
    checkElementIndex(index, size);
    return values[index];
  }

  void setValue(int index, int newValue) {
    checkElementIndex(index, size);
    values[index] = newValue;
  }

  Entry<K> getEntry(int index) {
    checkElementIndex(index, size);
    return new MapEntry(index);
  }

  @CollectionSize.Require(absent = ZERO)
  public void testComputeIfAbsent_nullTreatedAsAbsent() {
    initMapWithNullValue();
    assertEquals(
        "computeIfAbsent(presentAssignedToNull, function) should return newValue",
        getValueForNullKey(),
        getMap()
            .computeIfAbsent(
                getKeyForNullValue(),
                k -> {
                  assertEquals(getKeyForNullValue(), k);

                    V newValue = (oldValue == null) ? e.getValue() : remapping.merge(oldValue, e.getValue());
                    if (newValue == null) {
                        remove(key);
                    } else if (newValue != oldValue) {
                        map.put(key, newValue);
                    }
                }
            } else {

  @CollectionSize.Require(absent = ZERO)
  public void testComputeIfAbsent_nullTreatedAsAbsent() {
    initMapWithNullValue();
    assertEquals(
        "computeIfAbsent(presentAssignedToNull, function) should return newValue",
        getValueForNullKey(),
        getMap()
            .computeIfAbsent(
                getKeyForNullValue(),
                k -> {
                  assertEquals(getKeyForNullValue(), k);

   *     flooding attack
   */
  @CanIgnoreReturnValue
  static <K, V> @Nullable ImmutableMapEntry<K, V> checkNoConflictInKeyBucket(
      Object key,
      Object newValue,
      @Nullable ImmutableMapEntry<K, V> keyBucketHead,
      boolean throwIfDuplicateKeys)
      throws BucketOverflowException {
    int bucketSize = 0;

        }

        @Override
        public boolean remove(Object key, Object value) {
            throw uoe();
        }

        @Override
        public boolean replace(K key, V oldValue, V newValue) {
            throw uoe();
        }

        @Override
        public V replace(K key, V value) {
            throw uoe();
        }

        @Override

  }

  @CanIgnoreReturnValue
  @Override
  public boolean replace(K key, @Nullable V oldValue, V newValue) {
    checkNotNull(key);
    checkNotNull(newValue);
    if (oldValue == null) {
      return false;
    }
    int hash = hash(key);
    return segmentFor(hash).replace(key, hash, oldValue, newValue);
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable V replace(K key, V value) {

```Python hl_lines="1"
async def needy_dependency(fresh_value: Annotated[str, Depends(get_value, use_cache=False)]):
    return {"fresh_value": fresh_value}
```

////

//// tab | Python 3.10+ 非Annotated

/// tip | 豆知識

可能であれば`Annotated`版を使うことを推奨します。

///

```Python hl_lines="1"
async def needy_dependency(fresh_value: str = Depends(get_value, use_cache=False)):
    return {"fresh_value": fresh_value}
```

////

      @ParametricNullness K key,
      boolean containedKey,
      @Nullable V oldValue,
      @ParametricNullness V newValue) {
    if (containedKey) {
      // The cast is safe because of the containedKey check.
      removeFromInverseMap(uncheckedCastNullableTToT(oldValue));
    }
    inverse.delegate.put(newValue, key);
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable V remove(@Nullable Object key) {