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
The code is highly readable. It follows a clear, conventional structure with package, imports, Javadocs, factory methods, constructors, and serialization logic arranged logically. Javadocs are thorough and explain intent well. Methods are concise and focused, with most lines performing one action. Nesting is minimal; only method signatures and a few annotations create indentation depth. The use of descriptive names like 'distinctElements' and 'inferDistinctElements' enhances clarity. Minor readability drawbacks include slightly awkward indentation before 'writeObject' and 'readObject' annotations, and the serialized form documentation is brief. Overall the code is well organized, easy to follow, and maintains a natural reading flow.
Run 2
The code is highly readable with clear structure and intent. It follows a logical organization: class documentation, static factory methods, constructors, serialization methods, and a serialization field. Nesting is minimal with no deep conditional blocks. Each action is on its own line, and methods are concise, delegating complex logic to helper utilities. The Javadoc is thorough, and method names clearly express their purpose. Minor stylistic issues, such as inconsistent indentation on annotations for writeObject/readObject and slightly long type signatures, prevent a perfect score, but these do not significantly impair readability. Overall, the code reads naturally and is maintainable.
Run 3
The code is highly readable with clear class-level documentation explaining iteration order guarantees. The structure is logical: factory methods are grouped together, constructors are private and minimal, and serialization methods are separate. Nesting is flat, with no complex control flow. Each method has a single clear purpose, and actions are concise—one statement per line in most cases. The Javadoc is informative without being excessive. Minor issues: the @GwtIncompatible/@J2ktIncompatible annotations are placed on separate lines from method signatures, which slightly disrupts visual flow, and serialVersionUID placement at the end feels slightly inconsistent with conventional ordering. The use of static factory methods and delegation to helper utilities (Multisets.inferDistinctElements, Iterables.addAll) enhances clarity by abstracting complex logic. Overall, this is well-structured, idiomatic Guava code that clearly communicates intent with minimal ambiguity.
Run 1
Code Structure: Factory methods, constructors, and serialization hooks are logically grouped with clear responsibilities. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names and useful Javadocs explain creation options and iteration semantics; inherited behavior and serialization helpers require some external context. Code length: The implementation is concise, and documentation adds useful context rather than unnecessary complexity. Action granularity: Each executable statement performs a focused action on its own line, although the final annotations and field declaration are compressed together. Reading flow: The progression from public factories to private implementation details is natural. Minor formatting inconsistencies, particularly over-indented serialization method declarations and the crowded serialVersionUID declaration, slightly reduce readability.
Run 2
Code Structure: Factory methods, constructors, and serialization hooks are logically grouped. Nesting: Methods are flat, with no deeply nested control flow. Clarity of intent: Descriptive names and useful Javadoc clearly explain creation options and iteration behavior; inherited implementation and serialization helpers require some external context. Code length: The implementation is concise, and documentation adds relevant detail rather than unnecessary verbosity. Action granularity: Statements generally perform one action per line; the final line compresses annotations and a field declaration. Reading flow: Consistent method ordering and short bodies make the code easy to follow, but extra indentation on serialization method declarations, crowded final annotations, and missing spacing after the package declaration slightly disrupt visual consistency.
Run 3
Code Structure: Clearly organized into factory methods, constructors, and serialization helpers. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive names and useful documentation explain iteration order, factory behavior, and serialization; inherited helpers require some external context. Code length: Concise implementation, with documentation adding useful context rather than unnecessary complexity. Action granularity: Statements generally perform one action per line, although the final field declaration combines annotations and modifiers. Reading flow: Logical method ordering and consistent spacing make the class easy to follow. Minor formatting issues—over-indented serialization method declarations, compressed final annotations, and no separation between the package and imports—slightly reduce polish.