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;
@GwtCompatible
public final class LinkedHashMultiset<E extends @Nullable Object>
extends AbstractMapBasedMultiset<E> {
public static <E extends @Nullable Object> LinkedHashMultiset<E> create() {
return new LinkedHashMultiset<>();
}
public static <E extends @Nullable Object> LinkedHashMultiset<E> create(int distinctElements) {
return new LinkedHashMultiset<>(distinctElements);
}
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));
}
@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 well-structured with clear separation of concerns: constructors, factory methods, and serialization logic are logically organized. The class purpose is evident from its name and inheritance pattern. Nesting is minimal, with only a single-level conditional in the factory method. Action granularity is mostly one action per line, particularly in constructors and factory methods. The reading flow is natural, progressing from public API to implementation details. However, there are several readability issues: excessive blank lines after imports and before annotations, inconsistent indentation in the writeObject/readObject methods (annotations and methods are misaligned), and the serialization methods have slightly convoluted logic that could benefit from comments explaining the distinct element handling. The score reflects good overall structure but with formatting inconsistencies that make the code feel less polished than it could be.
Run 2
The code is generally well-structured with clear class hierarchy, sensible method organization, and good use of static factory methods. The class purpose is evident, and the methods follow logical grouping. However, there are notable readability issues: excessive blank lines (13 consecutive empty lines after imports), inconsistent indentation before @GwtIncompatible annotations on writeObject and readObject methods, and some formatting inconsistencies that disrupt reading flow. The generic type parameter syntax with @Nullable adds complexity but is understandable. Action granularity is mostly one action per line. The code could be improved with cleaner formatting and removing unnecessary blank lines to enhance readability.
Run 3
The code has reasonably good structure overall: a clear class with factory methods and serialization logic. It is mostly flat, with only one nested method and no deep nesting. Intent is mostly clear, especially for the factory methods and constructors. However, readability is reduced by inconsistent indentation in the writeObject/readObject methods, excessive blank lines, and verbose Javadoc placeholder comments. Some actions are grouped, but the irregular formatting disrupts the natural reading flow. The code is concise overall, but the formatting inconsistencies and redundant comments slightly obscure the clarity of intent.
Run 1
Code Structure: Factory methods, constructors, and serialization methods are logically grouped, with responsibilities delegated to helpers. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive class and method names make the purpose clear, although serialization details depend on external helpers and there is no explanatory documentation. Code length: The implementation is concise, but excessive blank lines unnecessarily stretch the file. Action granularity: Statements generally perform one action per line; the final line compresses annotations and a field declaration. Reading flow: The ordering is natural, but large whitespace gaps and inconsistent indentation of serialization methods interrupt scanning.
Run 2
Code Structure: Factory methods, constructors, and serialization methods are logically grouped. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names and straightforward operations communicate purpose, although some behavior depends on inherited methods and external utilities. Code length: Executable code is concise, but excessive blank lines unnecessarily lengthen the presentation. Action granularity: Statements generally perform one action per line; the final field declaration compresses annotations and modifiers onto one line. Reading flow: The ordering is natural, but large whitespace gaps and inconsistent indentation of serialization method declarations interrupt scanning.
Run 3
Code Structure: Factory methods, constructors, and serialization hooks are logically grouped. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names and straightforward delegation make the purpose clear, although inherited behavior and serialization helpers require external context. Code length: The implementation is concise, but excessive blank lines unnecessarily expand its visual length. Action granularity: Statements generally perform one action per line; the final line compresses two annotations and a field declaration. Reading flow: The member order is natural, but large whitespace gaps and inconsistent indentation of serialization methods interrupt scanning. Overall, the code is readable and well organized, with formatting issues accounting for most deductions.