Source code
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.jspecify.annotations.Nullable;
@GwtCompatible
public interface ListMultimap<K extends @Nullable Object, V extends @Nullable Object>
extends Multimap<K, V> {
@Override
List<V> get(@ParametricNullness K key);
@CanIgnoreReturnValue
@Override
List<V> removeAll(@Nullable Object key);
@CanIgnoreReturnValue
@Override
List<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values);
@Override
Map<K, Collection<V>> asMap();
@Override
boolean equals(@Nullable Object obj);
}
Run 1
This code is highly readable. It follows a logical structure with clear interface inheritance and standard Javadoc-style comment formatting. The nesting is minimal and appropriate for an interface declaration. The intent is explicit—defining a ListMultimap contract—and the method overrides are concise and focused. Each method is on a single line, adhering to good action granularity. The reading flow is natural, starting with imports, then the interface declaration, followed by logical method groupings. The only minor issue is the excessive blank lines after imports and between methods, which slightly disrupts the flow. Otherwise, it is clean, well-annotated, and easy to follow.
Run 2
The code is highly readable. It uses a clear interface structure with traditional method declarations, consistent Javadoc placeholders, and annotations. There is no unnecessary nesting, method names clearly express intent, and each method is concise. The file is short and focused. The only deductions are from excessive blank lines between members and the lack of actual Javadoc content, which slightly disrupts reading flow.
Run 3
The code is well-structured and highly readable. It is a clean interface definition with clear inheritance from Multimap. Nesting is minimal, and intent is unambiguous - the method signatures clearly define a ListMultimap contract. The code is concise, with one action per line, and follows natural Java interface conventions. The many blank lines between annotations and method declarations are slightly excessive and disrupt the reading flow, but this is a minor issue. Overall, the code is easy to understand, well-organized, and maintains good readability.
Run 1
Code Structure: The interface is logically organized, with imports, annotations, and related method declarations clearly separated. Nesting: Minimal nesting makes it easy to scan. Clarity of intent: The ListMultimap name, inheritance, descriptive method names, and List return types communicate its purpose; annotations clarify nullability and return-value handling. Code length: The declarations are concise, but excessive blank lines unnecessarily lengthen the snippet and obscure its compact structure. Action granularity: Each method declaration occupies its own line, with annotations separately presented. Reading flow: The declaration order is natural, but large whitespace gaps interrupt continuity and require unnecessary scrolling.
Run 2
Code Structure: The interface is logically organized, with imports followed by related method declarations. Nesting: Minimal nesting makes it easy to scan. Clarity of intent: The interface name, descriptive method names, return types, and annotations clearly communicate its purpose, though specialized nullness annotations require familiarity. Code length: The declarations are concise, but excessive blank lines unnecessarily lengthen the file. Action granularity: Each method declaration stands alone, with annotations on separate lines. Reading flow: The declaration order is natural, but large whitespace gaps interrupt continuity and make related methods harder to view together.
Run 3
Code Structure: The interface is logically organized, with imports, annotations, and related method declarations clearly separated. Nesting: Minimal nesting makes it easy to scan. Clarity of intent: Descriptive method names, explicit return types, and nullability annotations communicate the API well, though the reason for redeclaring inherited methods is not explained. Code length: The declarations are concise, but excessive blank lines unnecessarily lengthen the file. Action granularity: Each declaration occupies its own line, with annotations appropriately separated. Reading flow: Method ordering is coherent, but large gaps between declarations interrupt the flow and require needless scrolling.