Source code
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.LinkedHashMap;
import org.jspecify.annotations.Nullable;
/**
* A {@code Multiset} implementation with predictable iteration order. Its iterator orders elements
* according to when the first occurrence of the element was added. When the multiset contains
* multiple instances of an element, those instances are consecutive in the iteration order. If all
* occurrences of an element are removed, after which that element is added to the multiset, the
* element will appear at the end of the iteration.
*
* <p>See the Guava User Guide article on <a href=
* "https://github.com/google/guava/wiki/NewCollectionTypesExplained#multiset">{@code Multiset}</a>.
*
* @author Kevin Bourrillion
* @author Jared Levy
* @since 2.0
*/
@GwtCompatible
public final class LinkedHashMultiset<E extends @Nullable Object>
extends AbstractMapBasedMultiset<E> {
/** Creates a new, empty {@code LinkedHashMultiset} using the default initial capacity. */
public static <E extends @Nullable Object> LinkedHashMultiset<E> create() {
return new LinkedHashMultiset<>();
}
/**
* Creates a new, empty {@code LinkedHashMultiset} with the specified expected number of distinct
* elements.
*
* @param distinctElements the expected number of distinct elements
* @throws IllegalArgumentException if {@code distinctElements} is negative
*/
public static <E extends @Nullable Object> LinkedHashMultiset<E> create(int distinctElements) {
return new LinkedHashMultiset<>(distinctElements);
}
/**
* Creates a new {@code LinkedHashMultiset} containing the specified elements.
*
* <p>This implementation is highly efficient when {@code elements} is itself a {@link Multiset}.
*
* @param elements the elements that the multiset should contain
*/
public static <E extends @Nullable Object> LinkedHashMultiset<E> create(
Iterable<? extends E> elements) {
LinkedHashMultiset<E> multiset = create(Multisets.inferDistinctElements(elements));
Iterables.addAll(multiset, elements);
return multiset;
}
private LinkedHashMultiset() {
super(new LinkedHashMap<E, Count>());
}
private LinkedHashMultiset(int distinctElements) {
super(Maps.newLinkedHashMapWithExpectedSize(distinctElements));
}
/**
* @serialData the number of distinct elements, the first element, its count, the second element,
* its count, and so on
*/
@GwtIncompatible
@J2ktIncompatible
private void writeObject(ObjectOutputStream stream) throws IOException {
stream.defaultWriteObject();
Serialization.writeMultiset(this, stream);
}
@GwtIncompatible
@J2ktIncompatible
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
stream.defaultReadObject();
int distinctElements = stream.readInt();
setBackingMap(new LinkedHashMap<E, Count>());
Serialization.populateMultiset(this, stream, distinctElements);
}
@GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
}
Run 1
This code demonstrates excellent readability. The structure is logical, with clear separation of factory methods, constructors, and serialization logic. Javadoc documentation is thorough and helpful, particularly for public APIs. Nesting is minimal and flat. Intent is highly clear—each method has a descriptive name and purpose. Code length is appropriate; there's no unnecessary verbosity. Action granularity is good, with one operation per line in most cases. Reading flow is natural and follows a sensible order: class declaration, factory methods, constructors, then serialization. The only minor issues are the odd indentation on the @GwtIncompatible annotations for writeObject and readObject, and the slightly compressed format of the serialVersionUID declaration. These are cosmetic and don't significantly impact readability.
Run 2
The code is well-structured with clear separation of concerns: class-level Javadoc, factory methods, constructors, and serialization logic. Imports are organized. Nesting is minimal — only one level in the `create(Iterable)` method, and none elsewhere. Intent is clear: create a `Multiset` with predictable iteration order. Action granularity is good, with one logical action per line. Reading flow is natural, with static factories first, then constructors, then serialization. Minor issues: the `@GwtIncompatible @J2ktIncompatible` annotations on `writeObject` and `readObject` are oddly indented, breaking visual consistency; the `serialVersionUID` line is compressed, mixing three annotations and a field on one line. The long Javadoc URL is verbose but acceptable. Overall, highly readable with only cosmetic formatting inconsistencies.
Run 3
The code is well-structured, with a logical organization into factory methods, constructors, and serialization logic. Nesting is minimal, with only a few indentation levels in the method signatures. Intent is clear: the class defines a LinkedHashMultiset with predictable iteration order, and each method has a focused responsibility. Length is appropriate, with concise factory methods and serialization delegation to helper utilities. However, the code loses points for readability issues in the serialization methods: the indentation of writeObject and readObject is inconsistent, with the method annotations and visibility modifier indented at an unusual level, disrupting the natural reading flow. Additionally, the serialVersionUID declaration is compressed onto one line, violating the 'one action per line' principle. Despite these minor formatting inconsistencies, the overall structure follows Guava's standard conventions, making it understandable for developers familiar with the library.
Run 1
Code Structure: Logically organized into factory methods, constructors, and serialization hooks, with responsibilities cleanly delegated to helpers. Nesting: Flat methods with no nested control flow make scanning easy. Clarity of intent: Descriptive names and thorough Javadoc clearly explain creation options and iteration behavior; inherited implementation details require some external context. Code length: Methods are concise, and documentation is useful rather than excessive. Action granularity: Each executable statement performs a distinct action on its own line, although the final field declaration compresses annotations and declaration together. Reading flow: Consistent ordering and straightforward statement sequences provide a natural flow. Minor indentation inconsistencies in the serialization method declarations and compressed final annotations slightly reduce polish.
Run 2
Code Structure: Logically groups factory methods, constructors, and serialization hooks, with responsibilities cleanly separated. Nesting: Very shallow; methods contain straightforward statements without nested control flow. Clarity of intent: Descriptive names and useful Javadoc clearly explain creation options and iteration behavior, though inherited helpers require some external context. Code length: Concise implementation; documentation adds meaningful context rather than unnecessary verbosity. Action granularity: Executable statements generally perform one action per line; the final line compresses annotations and a field declaration. Reading flow: Natural progression from public creation methods to private implementation details. Minor formatting inconsistencies, particularly over-indented serialization method declarations, compressed field annotations, and missing spacing after the package declaration, slightly reduce readability.
Run 3
Code Structure: Well organized into factory methods, private constructors, and serialization helpers. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names and useful Javadoc clearly explain behavior, parameters, and iteration order; inherited implementation and helper calls require some external context. Code length: Concise implementation with documentation proportional to its public API. Action granularity: Statements generally perform one action per line, although the final field declaration crowds annotations and modifiers together. Reading flow: The progression from creation to initialization to serialization is natural. Minor formatting issues, including inconsistent indentation of serialization method declarations and missing separation after the package declaration, prevent a near-perfect score.