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;
/**
* Implementation of the {@code equals}, {@code hashCode}, and {@code toString} methods of {@code
* Entry}.
*
* @author Jared Levy
*/
@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());
}
/** Returns a string representation of the form {@code {key}={value}}. */
@Override
public String toString() {
return getKey() + "=" + getValue();
}
}
Run 1
The code is well-structured with clear separation of concerns: abstract getters, a default setter throwing UnsupportedOperationException, and overridden equals/hashCode/toString methods. Nesting is minimal (one level in equals). Intent is explicit through method names, Javadoc, and use of Objects.equals. The equals method is concise and correct, used with instanceof pattern and wildcard cast. hashCode follows the standard Entry contract with null checks via ternary operators. toString is a simple one-liner matching its contract. Minor readability improvements could include extracting the null-handling logic into helper methods or using Objects.hashCode, but the current style is consistent and idiomatic for Guava. Overall, the code maintains a natural reading flow and one action per line, with no excessive length or ambiguity.
Run 2
The code is highly readable with clear structure, minimal nesting, and concise methods. It follows standard Java conventions, uses meaningful names, and separates concerns logically. The equals method is straightforward, with a single level of nesting and clear intent. HashCode and toString are concise and easy to follow. Nullability annotations add clarity for API consumers. Minor deductions: the @Nullable annotations on type parameters may slightly reduce readability for those unfamiliar with JSpecify, and the package-private abstract class could benefit from a class-level Javadoc describing its role beyond the existing summary.
Run 3
The code is highly readable due to its logical structure, minimal nesting, and clear intent. Each method has a single, well-defined responsibility, and the class follows standard conventions for implementing Map.Entry. The equals method uses a clean instanceof pattern with early return, avoiding deep nesting. Type parameters and annotations are consistent and aid clarity. The hashCode implementation is compact but could be slightly clearer with a helper for null-safe hashing, though it remains understandable. Overall, the code is concise, well-organized, and easy to follow.
Run 1
Code Structure: Methods are logically organized within a small abstraction, with clear separation of entry access and standard object behavior. Nesting: Only one shallow conditional appears in equals; other methods are flat. Clarity of intent: Standard method names, overrides, and documentation make the purpose clear, though abbreviated variables k and v and the XOR hash expression require minor interpretation. Code length: The implementation is concise without unnecessary helpers or repetition. Action granularity: Each statement performs a focused action; compound expressions directly represent equality and hashing rules. Reading flow: Consistent formatting and conventional method ordering support smooth reading. Nullness annotations add slight visual density but communicate useful constraints.
Run 2
Code Structure: Methods are logically organized around the Map.Entry contract, with consistent formatting and annotations. Nesting: Only one shallow conditional appears in equals; other methods are flat. Clarity of intent: Class documentation, conventional method names, and standard equality and hashing patterns make the purpose clear. Short variable names k and v slightly reduce descriptiveness. Code length: The implementation is concise without unnecessary abstractions or repetition. Action granularity: Statements generally perform one action each; the combined hash expression is compact but requires some attention. Reading flow: Abstract accessors precede the default mutation behavior and object methods, creating a natural progression. Nullability annotations add minor visual density but communicate useful constraints.
Run 3
Code Structure: Methods are logically organized in a small, cohesive class implementing standard map-entry behavior. Nesting: Only one shallow conditional appears in equals; other methods are flat. Clarity of intent: Familiar method names, overrides, and documentation make the purpose clear, though abbreviated hashCode variables and nullness annotations add minor reading overhead. Code length: The implementation is concise without unnecessary repetition. Action granularity: Statements generally perform one action each; compound equality and hash expressions remain compact and understandable. Reading flow: Consistent formatting and a natural progression from accessors to equality, hashing, and string representation support easy reading.