Source code
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import java.util.Map.Entry;
import java.util.Objects;
import org.jspecify.annotations.Nullable;
@GwtCompatible
abstract class AbstractMapEntry<K extends @Nullable Object, V extends @Nullable Object>
implements Entry<K, V> {
@Override
@ParametricNullness
public abstract K getKey();
@Override
@ParametricNullness
public abstract V getValue();
@Override
@ParametricNullness
public V setValue(@ParametricNullness V value) {
throw new UnsupportedOperationException();
}
@Override
public boolean equals(@Nullable Object object) {
if (object instanceof Entry) {
Entry<?, ?> that = (Entry<?, ?>) object;
return Objects.equals(this.getKey(), that.getKey())
&& Objects.equals(this.getValue(), that.getValue());
}
return false;
}
@Override
public int hashCode() {
K k = getKey();
V v = getValue();
return ((k == null) ? 0 : k.hashCode()) ^ ((v == null) ? 0 : v.hashCode());
}
@Override
public String toString() {
return getKey() + "=" + getValue();
}
}
Run 1
The code is highly readable. It has a clear, logical structure with each method separated and focused on a single responsibility. Nesting is minimal, with only one level for the instanceof check in equals(); the early return pattern is used effectively. Intent is clear: it's an abstract Map.Entry implementation with standard method overrides. The code is concise, avoiding unnecessary verbosity while remaining complete. Action granularity is excellent—only the equals method combines operations on a single line in a reasonable, standard way. The reading flow is natural, following the typical order of key, value, setter, equals, hashCode, and toString. Minor deductions come from the unused import of java.util.Map.Entry (Entry is already in scope via the interface) and the blank lines at the top, but these do not materially affect readability.
Run 2
The code is highly readable. It is logically organized, with methods like equals, hashCode, and toString following standard conventions. Nesting is minimal, with only one conditional block in equals. Intent is clear: it provides a skeletal implementation of Map.Entry with sensible defaults. Code length is concise and appropriate for the abstraction. Action granularity is good, with each line performing a single logical operation, especially in equals and hashCode. Reading flow is natural, following a standard class structure: abstract accessors, default methods, and object method overrides. Minor deductions include the slightly verbose generic type declarations and redundant cast in equals, but overall readability is excellent.
Run 3
The code is highly readable with a clear structure and logical organization. It implements a simple map entry abstraction, and each method has a single, obvious purpose. Nesting is minimal, with only one level inside equals(). Naming is clear and follows Guava conventions. Nullability annotations improve clarity. The code is concise, with no unnecessary verbosity. While the equals() method has a slightly deep type cast and conditional, it remains easy to follow. Reading flow is natural, from key/value accessors to equality, hashing, and string conversion.
Run 1
Code Structure: Methods are logically organized within a focused abstract Map.Entry implementation. Nesting: Only one shallow conditional appears in equals, making control flow easy to follow. Clarity of intent: Standard method names, overrides, and straightforward implementations clearly communicate entry behavior; single-letter hashCode variables are slightly less descriptive. Code length: The implementation is concise, although excessive blank lines add visual clutter. Action granularity: Each statement performs one clear action, with compound equality and hash calculations remaining readable. Reading flow: The progression from accessors to mutation behavior, equality, hashing, and string representation is natural. Minor whitespace inconsistencies and a somewhat dense hashCode expression prevent a perfect score.
Run 2
Code Structure: Methods are logically organized around the Map.Entry contract, with clear separation of responsibilities. Nesting: Only one shallow conditional appears, keeping control flow easy to follow. Clarity of intent: Standard method names and familiar implementations clearly express equality, hashing, string representation, and unsupported mutation; abbreviated variables k and v slightly reduce clarity. Code length: The implementation is concise, although excessive blank lines add unnecessary visual space. Action granularity: Statements generally perform one action each; the compact hash calculation remains understandable. Reading flow: Consistent formatting and straightforward method bodies support natural reading, with minor disruption from irregular whitespace and annotation density.
Run 3
Code Structure: Methods are logically organized around the Map.Entry contract, with clear separation of responsibilities. Nesting: Minimal nesting, limited to one conditional in equals. Clarity of intent: Familiar method names, annotations, and straightforward implementations make the purpose clear; terse variables k and v slightly reduce clarity. Code length: Concise overall, though excessive blank lines add visual noise. Action granularity: Statements generally perform one action each; the hashCode expression combines null handling and hashing but remains manageable. Reading flow: Consistent formatting and standard override ordering support natural reading, with minor interruptions from redundant parentheses and uneven whitespace.