mirror of
https://github.com/apache/commons-collections.git
synced 2025-03-01 14:29:06 +00:00
Remove redundant calls to super().
This commit is contained in:
Gary Gregory
parent
bd9d3873fe
commit
ce0cadd5e2
@ -54,7 +54,6 @@ public class ArrayStack<E> extends ArrayList<E> {
|
||||
* is controlled by {@code ArrayList} and is currently 10.
|
||||
*/
|
||||
public ArrayStack() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -32,7 +32,6 @@ public class FunctorException extends RuntimeException {
|
||||
* detail message.
|
||||
*/
|
||||
public FunctorException() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -479,7 +479,6 @@ public class IterableUtils {
|
||||
private final Iterable<E> unmodifiable;
|
||||
|
||||
UnmodifiableIterable(final Iterable<E> iterable) {
|
||||
super();
|
||||
this.unmodifiable = iterable;
|
||||
}
|
||||
|
||||
|
||||
@ -41,7 +41,6 @@ public abstract class AbstractBagDecorator<E>
|
||||
* @since 3.1
|
||||
*/
|
||||
protected AbstractBagDecorator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -57,7 +57,6 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
|
||||
* Constructor needed for subclass serialisation.
|
||||
*/
|
||||
protected AbstractMapBag() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -67,7 +66,6 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
|
||||
* @param map the map to assign
|
||||
*/
|
||||
protected AbstractMapBag(final Map<E, MutableInteger> map) {
|
||||
super();
|
||||
this.map = map;
|
||||
}
|
||||
|
||||
|
||||
@ -40,7 +40,6 @@ public abstract class AbstractSortedBagDecorator<E>
|
||||
* @since 3.1
|
||||
*/
|
||||
protected AbstractSortedBagDecorator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -84,7 +84,6 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
|
||||
* {@link #AbstractDualBidiMap(Map, Map)}.
|
||||
*/
|
||||
protected AbstractDualBidiMap() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -102,7 +101,6 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
|
||||
* @since 3.1
|
||||
*/
|
||||
protected AbstractDualBidiMap(final Map<K, V> normalMap, final Map<V, K> reverseMap) {
|
||||
super();
|
||||
this.normalMap = normalMap;
|
||||
this.reverseMap = reverseMap;
|
||||
}
|
||||
@ -117,7 +115,6 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
|
||||
*/
|
||||
protected AbstractDualBidiMap(final Map<K, V> normalMap, final Map<V, K> reverseMap,
|
||||
final BidiMap<V, K> inverseBidiMap) {
|
||||
super();
|
||||
this.normalMap = normalMap;
|
||||
this.reverseMap = reverseMap;
|
||||
this.inverseBidiMap = inverseBidiMap;
|
||||
@ -747,7 +744,6 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
|
||||
* @param parent the parent map
|
||||
*/
|
||||
protected BidiMapIterator(final AbstractDualBidiMap<K, V> parent) {
|
||||
super();
|
||||
this.parent = parent;
|
||||
this.iterator = parent.normalMap.entrySet().iterator();
|
||||
}
|
||||
|
||||
@ -315,7 +315,6 @@ public class DualTreeBidiMap<K, V> extends AbstractDualBidiMap<K, V>
|
||||
* @param parent the parent map
|
||||
*/
|
||||
protected BidiOrderedMapIterator(final AbstractDualBidiMap<K, V> parent) {
|
||||
super();
|
||||
this.parent = parent;
|
||||
iterator = new ArrayList<>(parent.entrySet()).listIterator();
|
||||
}
|
||||
|
||||
@ -122,7 +122,6 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public TreeBidiMap() {
|
||||
super();
|
||||
rootNode = new Node[2];
|
||||
}
|
||||
|
||||
@ -1501,7 +1500,6 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
|
||||
* @param orderType the KEY or VALUE int for the order
|
||||
*/
|
||||
View(final DataElement orderType) {
|
||||
super();
|
||||
this.orderType = orderType;
|
||||
}
|
||||
|
||||
@ -1674,7 +1672,6 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
|
||||
* @param orderType the KEY or VALUE int for the order
|
||||
*/
|
||||
ViewIterator(final DataElement orderType) {
|
||||
super();
|
||||
this.orderType = orderType;
|
||||
expectedModifications = modifications;
|
||||
nextNode = leastNode(rootNode[orderType.ordinal()], orderType);
|
||||
@ -1905,7 +1902,6 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
Node(final K key, final V value) {
|
||||
super();
|
||||
this.key = key;
|
||||
this.value = value;
|
||||
leftNode = new Node[2];
|
||||
|
||||
@ -70,7 +70,6 @@ public abstract class AbstractCollectionDecorator<E>
|
||||
* @since 3.1
|
||||
*/
|
||||
protected AbstractCollectionDecorator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -55,7 +55,6 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
|
||||
* Create an empty CompositeCollection.
|
||||
*/
|
||||
public CompositeCollection() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -64,7 +63,6 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
|
||||
* @param compositeCollection the Collection to be appended to the composite
|
||||
*/
|
||||
public CompositeCollection(final Collection<E> compositeCollection) {
|
||||
super();
|
||||
addComposited(compositeCollection);
|
||||
}
|
||||
|
||||
@ -76,7 +74,6 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
|
||||
*/
|
||||
public CompositeCollection(final Collection<E> compositeCollection1,
|
||||
final Collection<E> compositeCollection2) {
|
||||
super();
|
||||
addComposited(compositeCollection1, compositeCollection2);
|
||||
}
|
||||
|
||||
@ -86,7 +83,6 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
|
||||
* @param compositeCollections the collections to composite
|
||||
*/
|
||||
public CompositeCollection(final Collection<E>... compositeCollections) {
|
||||
super();
|
||||
addComposited(compositeCollections);
|
||||
}
|
||||
|
||||
|
||||
@ -74,7 +74,6 @@ public class ComparableComparator<E extends Comparable<? super E>> implements Co
|
||||
* Please use the {@link #comparableComparator()} method whenever possible.
|
||||
*/
|
||||
public ComparableComparator() {
|
||||
super();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
|
||||
@ -81,7 +81,6 @@ public class FixedOrderComparator<T> implements Comparator<T>, Serializable {
|
||||
* Constructs an empty FixedOrderComparator.
|
||||
*/
|
||||
public FixedOrderComparator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -94,7 +93,6 @@ public class FixedOrderComparator<T> implements Comparator<T>, Serializable {
|
||||
* @throws NullPointerException if the array is null
|
||||
*/
|
||||
public FixedOrderComparator(final T... items) {
|
||||
super();
|
||||
for (final T item : Objects.requireNonNull(items, "items")) {
|
||||
add(item);
|
||||
}
|
||||
@ -110,7 +108,6 @@ public class FixedOrderComparator<T> implements Comparator<T>, Serializable {
|
||||
* @throws NullPointerException if the list is null
|
||||
*/
|
||||
public FixedOrderComparator(final List<T> items) {
|
||||
super();
|
||||
for (final T t : Objects.requireNonNull(items, "items")) {
|
||||
add(t);
|
||||
}
|
||||
|
||||
@ -59,7 +59,6 @@ public final class AndPredicate<T> implements PredicateDecorator<T>, Serializabl
|
||||
* @param predicate2 the second predicate to check, not null
|
||||
*/
|
||||
public AndPredicate(final Predicate<? super T> predicate1, final Predicate<? super T> predicate2) {
|
||||
super();
|
||||
iPredicate1 = predicate1;
|
||||
iPredicate2 = predicate2;
|
||||
}
|
||||
|
||||
@ -86,7 +86,6 @@ public class ChainedClosure<E> implements Closure<E>, Serializable {
|
||||
* @param closures the closures to chain, no nulls
|
||||
*/
|
||||
private ChainedClosure(final boolean clone, final Closure<? super E>... closures) {
|
||||
super();
|
||||
iClosures = clone ? FunctorUtils.copy(closures) : closures;
|
||||
}
|
||||
|
||||
|
||||
@ -86,7 +86,6 @@ public class ChainedTransformer<T> implements Transformer<T, T>, Serializable {
|
||||
* @param transformers the transformers to chain, no nulls
|
||||
*/
|
||||
private ChainedTransformer(final boolean clone, final Transformer<? super T, ? extends T>[] transformers) {
|
||||
super();
|
||||
iTransformers = clone ? FunctorUtils.copy(transformers) : transformers;
|
||||
}
|
||||
|
||||
|
||||
@ -53,7 +53,6 @@ public class CloneTransformer<T> implements Transformer<T, T> {
|
||||
* Constructor.
|
||||
*/
|
||||
private CloneTransformer() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -55,7 +55,6 @@ public class ClosureTransformer<T> implements Transformer<T, T>, Serializable {
|
||||
* @param closure the closure to call, not null
|
||||
*/
|
||||
public ClosureTransformer(final Closure<? super T> closure) {
|
||||
super();
|
||||
iClosure = closure;
|
||||
}
|
||||
|
||||
|
||||
@ -133,7 +133,6 @@ public class ComparatorPredicate<T> implements Predicate<T>, Serializable {
|
||||
* @param criterion the criterion to use to evaluate comparison
|
||||
*/
|
||||
public ComparatorPredicate(final T object, final Comparator<T> comparator, final Criterion criterion) {
|
||||
super();
|
||||
this.object = object;
|
||||
this.comparator = comparator;
|
||||
this.criterion = criterion;
|
||||
|
||||
@ -63,7 +63,6 @@ public class ConstantFactory<T> implements Factory<T>, Serializable {
|
||||
* @param constantToReturn the constant to return each time
|
||||
*/
|
||||
public ConstantFactory(final T constantToReturn) {
|
||||
super();
|
||||
iConstant = constantToReturn;
|
||||
}
|
||||
|
||||
|
||||
@ -75,7 +75,6 @@ public class ConstantTransformer<I, O> implements Transformer<I, O>, Serializabl
|
||||
* @param constantToReturn the constant to return each time
|
||||
*/
|
||||
public ConstantTransformer(final O constantToReturn) {
|
||||
super();
|
||||
iConstant = constantToReturn;
|
||||
}
|
||||
|
||||
|
||||
@ -54,7 +54,6 @@ public class DefaultEquator<T> implements Equator<T>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private DefaultEquator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -89,7 +89,6 @@ public final class EqualPredicate<T> implements Predicate<T>, Serializable {
|
||||
* @since 4.0
|
||||
*/
|
||||
public EqualPredicate(final T object, final Equator<T> equator) {
|
||||
super();
|
||||
iValue = object;
|
||||
this.equator = equator;
|
||||
}
|
||||
|
||||
@ -50,7 +50,6 @@ public final class ExceptionClosure<E> implements Closure<E>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private ExceptionClosure() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -50,7 +50,6 @@ public final class ExceptionFactory<T> implements Factory<T>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private ExceptionFactory() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -50,7 +50,6 @@ public final class ExceptionPredicate<T> implements Predicate<T>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private ExceptionPredicate() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -51,7 +51,6 @@ public final class ExceptionTransformer<I, O> implements Transformer<I, O>, Seri
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private ExceptionTransformer() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -55,7 +55,6 @@ public class FactoryTransformer<I, O> implements Transformer<I, O>, Serializable
|
||||
* @param factory the factory to call, not null
|
||||
*/
|
||||
public FactoryTransformer(final Factory<? extends O> factory) {
|
||||
super();
|
||||
iFactory = factory;
|
||||
}
|
||||
|
||||
|
||||
@ -49,7 +49,6 @@ public final class FalsePredicate<T> implements Predicate<T>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private FalsePredicate() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -66,7 +66,6 @@ public class ForClosure<E> implements Closure<E> {
|
||||
* @param closure the closure to execute, not null
|
||||
*/
|
||||
public ForClosure(final int count, final Closure<? super E> closure) {
|
||||
super();
|
||||
iCount = count;
|
||||
iClosure = closure;
|
||||
}
|
||||
|
||||
@ -34,7 +34,6 @@ class FunctorUtils {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private FunctorUtils() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -55,7 +55,6 @@ public final class IdentityPredicate<T> implements Predicate<T>, Serializable {
|
||||
* @param object the object to compare to
|
||||
*/
|
||||
public IdentityPredicate(final T object) {
|
||||
super();
|
||||
iValue = object;
|
||||
}
|
||||
|
||||
|
||||
@ -100,7 +100,6 @@ public class IfClosure<E> implements Closure<E>, Serializable {
|
||||
*/
|
||||
public IfClosure(final Predicate<? super E> predicate, final Closure<? super E> trueClosure,
|
||||
final Closure<? super E> falseClosure) {
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
iTrueClosure = trueClosure;
|
||||
iFalseClosure = falseClosure;
|
||||
|
||||
@ -93,7 +93,6 @@ public class IfTransformer<I, O> implements Transformer<I, O>, Serializable {
|
||||
final Transformer<? super I, ? extends O> trueTransformer,
|
||||
final Transformer<? super I, ? extends O> falseTransformer) {
|
||||
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
iTrueTransformer = trueTransformer;
|
||||
iFalseTransformer = falseTransformer;
|
||||
|
||||
@ -53,7 +53,6 @@ public final class InstanceofPredicate implements Predicate<Object>, Serializabl
|
||||
* @param type the type to check for
|
||||
*/
|
||||
public InstanceofPredicate(final Class<?> type) {
|
||||
super();
|
||||
iType = type;
|
||||
}
|
||||
|
||||
|
||||
@ -79,7 +79,6 @@ public class InstantiateFactory<T> implements Factory<T> {
|
||||
* @param classToInstantiate the class to instantiate
|
||||
*/
|
||||
public InstantiateFactory(final Class<T> classToInstantiate) {
|
||||
super();
|
||||
iClassToInstantiate = classToInstantiate;
|
||||
iParamTypes = null;
|
||||
iArgs = null;
|
||||
@ -95,7 +94,6 @@ public class InstantiateFactory<T> implements Factory<T> {
|
||||
* @param args the constructor arguments, cloned
|
||||
*/
|
||||
public InstantiateFactory(final Class<T> classToInstantiate, final Class<?>[] paramTypes, final Object[] args) {
|
||||
super();
|
||||
iClassToInstantiate = classToInstantiate;
|
||||
iParamTypes = paramTypes.clone();
|
||||
iArgs = args.clone();
|
||||
|
||||
@ -81,7 +81,6 @@ public class InstantiateTransformer<T> implements Transformer<Class<? extends T>
|
||||
* Constructor for no arg instance.
|
||||
*/
|
||||
private InstantiateTransformer() {
|
||||
super();
|
||||
iParamTypes = null;
|
||||
iArgs = null;
|
||||
}
|
||||
@ -96,7 +95,6 @@ public class InstantiateTransformer<T> implements Transformer<Class<? extends T>
|
||||
* @param args the constructor arguments
|
||||
*/
|
||||
public InstantiateTransformer(final Class<?>[] paramTypes, final Object[] args) {
|
||||
super();
|
||||
iParamTypes = paramTypes != null ? paramTypes.clone() : null;
|
||||
iArgs = args != null ? args.clone() : null;
|
||||
}
|
||||
|
||||
@ -89,7 +89,6 @@ public class InvokerTransformer<I, O> implements Transformer<I, O> {
|
||||
* @param methodName the method to call
|
||||
*/
|
||||
private InvokerTransformer(final String methodName) {
|
||||
super();
|
||||
iMethodName = methodName;
|
||||
iParamTypes = null;
|
||||
iArgs = null;
|
||||
@ -106,7 +105,6 @@ public class InvokerTransformer<I, O> implements Transformer<I, O> {
|
||||
* @param args the constructor arguments
|
||||
*/
|
||||
public InvokerTransformer(final String methodName, final Class<?>[] paramTypes, final Object[] args) {
|
||||
super();
|
||||
iMethodName = methodName;
|
||||
iParamTypes = paramTypes != null ? paramTypes.clone() : null;
|
||||
iArgs = args != null ? args.clone() : null;
|
||||
|
||||
@ -59,7 +59,6 @@ public final class MapTransformer<I, O> implements Transformer<I, O>, Serializab
|
||||
* @param map the map to use for lookup, not cloned
|
||||
*/
|
||||
private MapTransformer(final Map<? super I, ? extends O> map) {
|
||||
super();
|
||||
iMap = map;
|
||||
}
|
||||
|
||||
|
||||
@ -49,7 +49,6 @@ public final class NOPClosure<E> implements Closure<E>, Serializable {
|
||||
* Constructor.
|
||||
*/
|
||||
private NOPClosure() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -49,7 +49,6 @@ public class NOPTransformer<T> implements Transformer<T, T>, Serializable {
|
||||
* Constructor.
|
||||
*/
|
||||
private NOPTransformer() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -49,7 +49,6 @@ public final class NotNullPredicate<T> implements Predicate<T>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private NotNullPredicate() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -53,7 +53,6 @@ public final class NotPredicate<T> implements PredicateDecorator<T>, Serializabl
|
||||
* @param predicate the predicate to call after the null check
|
||||
*/
|
||||
public NotPredicate(final Predicate<? super T> predicate) {
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
}
|
||||
|
||||
|
||||
@ -54,7 +54,6 @@ public final class NullIsExceptionPredicate<T> implements PredicateDecorator<T>,
|
||||
* @param predicate the predicate to call after the null check
|
||||
*/
|
||||
public NullIsExceptionPredicate(final Predicate<? super T> predicate) {
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
}
|
||||
|
||||
|
||||
@ -53,7 +53,6 @@ public final class NullIsFalsePredicate<T> implements PredicateDecorator<T>, Ser
|
||||
* @param predicate the predicate to call after the null check
|
||||
*/
|
||||
public NullIsFalsePredicate(final Predicate<? super T> predicate) {
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
}
|
||||
|
||||
|
||||
@ -53,7 +53,6 @@ public final class NullIsTruePredicate<T> implements PredicateDecorator<T>, Seri
|
||||
* @param predicate the predicate to call after the null check
|
||||
*/
|
||||
public NullIsTruePredicate(final Predicate<? super T> predicate) {
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
}
|
||||
|
||||
|
||||
@ -49,7 +49,6 @@ public final class NullPredicate<T> implements Predicate<T>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private NullPredicate() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -59,7 +59,6 @@ public final class OrPredicate<T> implements PredicateDecorator<T>, Serializable
|
||||
* @param predicate2 the second predicate to check, not null
|
||||
*/
|
||||
public OrPredicate(final Predicate<? super T> predicate1, final Predicate<? super T> predicate2) {
|
||||
super();
|
||||
iPredicate1 = predicate1;
|
||||
iPredicate2 = predicate2;
|
||||
}
|
||||
|
||||
@ -57,7 +57,6 @@ public class PredicateTransformer<T> implements Transformer<T, Boolean>, Seriali
|
||||
* @param predicate the predicate to call, not null
|
||||
*/
|
||||
public PredicateTransformer(final Predicate<? super T> predicate) {
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
}
|
||||
|
||||
|
||||
@ -91,7 +91,6 @@ public class PrototypeFactory {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private PrototypeFactory() {
|
||||
super();
|
||||
}
|
||||
|
||||
// PrototypeCloneFactory
|
||||
@ -110,7 +109,6 @@ public class PrototypeFactory {
|
||||
* Constructor to store prototype.
|
||||
*/
|
||||
private PrototypeCloneFactory(final T prototype, final Method method) {
|
||||
super();
|
||||
iPrototype = prototype;
|
||||
iCloneMethod = method;
|
||||
}
|
||||
@ -163,7 +161,6 @@ public class PrototypeFactory {
|
||||
* Constructor to store prototype
|
||||
*/
|
||||
private PrototypeSerializationFactory(final T prototype) {
|
||||
super();
|
||||
iPrototype = prototype;
|
||||
}
|
||||
|
||||
|
||||
@ -50,7 +50,6 @@ public final class StringValueTransformer<T> implements Transformer<T, String>,
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private StringValueTransformer() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -117,7 +117,6 @@ public class SwitchClosure<E> implements Closure<E>, Serializable {
|
||||
@SuppressWarnings("unchecked")
|
||||
private SwitchClosure(final boolean clone, final Predicate<? super E>[] predicates,
|
||||
final Closure<? super E>[] closures, final Closure<? super E> defaultClosure) {
|
||||
super();
|
||||
iPredicates = clone ? FunctorUtils.copy(predicates) : predicates;
|
||||
iClosures = clone ? FunctorUtils.copy(closures) : closures;
|
||||
iDefault = (Closure<? super E>) (defaultClosure == null ? NOPClosure.<E>nopClosure() : defaultClosure);
|
||||
|
||||
@ -128,7 +128,6 @@ public class SwitchTransformer<I, O> implements Transformer<I, O>, Serializable
|
||||
private SwitchTransformer(final boolean clone, final Predicate<? super I>[] predicates,
|
||||
final Transformer<? super I, ? extends O>[] transformers,
|
||||
final Transformer<? super I, ? extends O> defaultTransformer) {
|
||||
super();
|
||||
iPredicates = clone ? FunctorUtils.copy(predicates) : predicates;
|
||||
iTransformers = clone ? FunctorUtils.copy(transformers) : transformers;
|
||||
iDefault = (Transformer<? super I, ? extends O>) (defaultTransformer == null ?
|
||||
|
||||
@ -58,7 +58,6 @@ public class TransformerClosure<E> implements Closure<E>, Serializable {
|
||||
* @param transformer the transformer to call, not null
|
||||
*/
|
||||
public TransformerClosure(final Transformer<? super E, ?> transformer) {
|
||||
super();
|
||||
iTransformer = transformer;
|
||||
}
|
||||
|
||||
|
||||
@ -55,7 +55,6 @@ public final class TransformerPredicate<T> implements Predicate<T>, Serializable
|
||||
* @param transformer the transformer to decorate
|
||||
*/
|
||||
public TransformerPredicate(final Transformer<? super T, Boolean> transformer) {
|
||||
super();
|
||||
iTransformer = transformer;
|
||||
}
|
||||
|
||||
|
||||
@ -49,7 +49,6 @@ public final class TruePredicate<T> implements Predicate<T>, Serializable {
|
||||
* Restricted constructor.
|
||||
*/
|
||||
private TruePredicate() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -52,7 +52,6 @@ public final class UniquePredicate<T> implements Predicate<T>, Serializable {
|
||||
* Use {@code uniquePredicate} if you want that.
|
||||
*/
|
||||
public UniquePredicate() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -67,7 +67,6 @@ public class WhileClosure<E> implements Closure<E> {
|
||||
* @param doLoop true to act as a do-while loop, always executing the closure once
|
||||
*/
|
||||
public WhileClosure(final Predicate<? super E> predicate, final Closure<? super E> closure, final boolean doLoop) {
|
||||
super();
|
||||
iPredicate = predicate;
|
||||
iClosure = closure;
|
||||
iDoLoop = doLoop;
|
||||
|
||||
@ -29,7 +29,6 @@ abstract class AbstractEmptyIterator<E> {
|
||||
* Constructor.
|
||||
*/
|
||||
protected AbstractEmptyIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
public boolean hasNext() {
|
||||
|
||||
@ -29,7 +29,6 @@ public abstract class AbstractEmptyMapIterator<K, V> extends AbstractEmptyIterat
|
||||
* Create a new AbstractEmptyMapIterator.
|
||||
*/
|
||||
public AbstractEmptyMapIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
public K getKey() {
|
||||
|
||||
@ -39,7 +39,6 @@ public class AbstractListIteratorDecorator<E> implements ListIterator<E> {
|
||||
* @throws NullPointerException if the iterator is null
|
||||
*/
|
||||
public AbstractListIteratorDecorator(final ListIterator<E> iterator) {
|
||||
super();
|
||||
this.iterator = Objects.requireNonNull(iterator, "iterator");
|
||||
}
|
||||
|
||||
|
||||
@ -42,7 +42,6 @@ public class AbstractMapIteratorDecorator<K, V> implements MapIterator<K, V> {
|
||||
* @throws NullPointerException if the iterator is null
|
||||
*/
|
||||
public AbstractMapIteratorDecorator(final MapIterator<K, V> iterator) {
|
||||
super();
|
||||
this.iterator = Objects.requireNonNull(iterator, "iterator");
|
||||
}
|
||||
|
||||
|
||||
@ -42,7 +42,6 @@ public class AbstractOrderedMapIteratorDecorator<K, V> implements OrderedMapIter
|
||||
* @throws NullPointerException if the iterator is null
|
||||
*/
|
||||
public AbstractOrderedMapIteratorDecorator(final OrderedMapIterator<K, V> iterator) {
|
||||
super();
|
||||
this.iterator = Objects.requireNonNull(iterator, "iterator");
|
||||
}
|
||||
|
||||
|
||||
@ -39,7 +39,6 @@ public abstract class AbstractUntypedIteratorDecorator<I, O> implements Iterator
|
||||
* @throws NullPointerException if the iterator is null
|
||||
*/
|
||||
protected AbstractUntypedIteratorDecorator(final Iterator<I> iterator) {
|
||||
super();
|
||||
this.iterator = Objects.requireNonNull(iterator, "iterator");
|
||||
}
|
||||
|
||||
|
||||
@ -86,8 +86,6 @@ public class ArrayIterator<E> implements ResettableIterator<E> {
|
||||
* @throws IndexOutOfBoundsException if either index is invalid
|
||||
*/
|
||||
public ArrayIterator(final Object array, final int startIndex, final int endIndex) {
|
||||
super();
|
||||
|
||||
this.array = array;
|
||||
this.startIndex = startIndex;
|
||||
this.endIndex = endIndex;
|
||||
|
||||
@ -68,7 +68,6 @@ public class EmptyIterator<E> extends AbstractEmptyIterator<E> implements Resett
|
||||
* Constructor.
|
||||
*/
|
||||
protected EmptyIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -69,7 +69,6 @@ public class EmptyListIterator<E> extends AbstractEmptyIterator<E> implements
|
||||
* Constructor.
|
||||
*/
|
||||
protected EmptyListIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -50,7 +50,6 @@ public class EmptyMapIterator<K, V> extends AbstractEmptyMapIterator<K, V> imple
|
||||
* Constructor.
|
||||
*/
|
||||
protected EmptyMapIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -48,7 +48,6 @@ public class EmptyOrderedIterator<E> extends AbstractEmptyIterator<E>
|
||||
* Constructor.
|
||||
*/
|
||||
protected EmptyOrderedIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -50,7 +50,6 @@ public class EmptyOrderedMapIterator<K, V> extends AbstractEmptyMapIterator<K, V
|
||||
* Constructor.
|
||||
*/
|
||||
protected EmptyOrderedMapIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -51,7 +51,6 @@ public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableI
|
||||
* @param map the map to iterate over
|
||||
*/
|
||||
public EntrySetMapIterator(final Map<K, V> map) {
|
||||
super();
|
||||
this.map = map;
|
||||
this.iterator = map.entrySet().iterator();
|
||||
}
|
||||
|
||||
@ -64,7 +64,6 @@ public class EnumerationIterator<E> implements Iterator<E> {
|
||||
* @param collection the collection to remove elements from
|
||||
*/
|
||||
public EnumerationIterator(final Enumeration<? extends E> enumeration, final Collection<? super E> collection) {
|
||||
super();
|
||||
this.enumeration = enumeration;
|
||||
this.collection = collection;
|
||||
this.last = null;
|
||||
|
||||
@ -47,7 +47,6 @@ public class FilterIterator<E> implements Iterator<E> {
|
||||
* until {@link #setIterator(Iterator) setIterator} is invoked.
|
||||
*/
|
||||
public FilterIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -57,7 +56,6 @@ public class FilterIterator<E> implements Iterator<E> {
|
||||
* @param iterator the iterator to use
|
||||
*/
|
||||
public FilterIterator(final Iterator<? extends E> iterator) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
@ -69,7 +67,6 @@ public class FilterIterator<E> implements Iterator<E> {
|
||||
* @param predicate the predicate to use
|
||||
*/
|
||||
public FilterIterator(final Iterator<? extends E> iterator, final Predicate<? super E> predicate) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
this.predicate = predicate;
|
||||
}
|
||||
|
||||
@ -74,7 +74,6 @@ public class FilterListIterator<E> implements ListIterator<E> {
|
||||
* and {@link #setPredicate(Predicate) setPredicate} are invoked.
|
||||
*/
|
||||
public FilterListIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -84,7 +83,6 @@ public class FilterListIterator<E> implements ListIterator<E> {
|
||||
* @param iterator the iterator to use
|
||||
*/
|
||||
public FilterListIterator(final ListIterator<? extends E> iterator ) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
@ -95,7 +93,6 @@ public class FilterListIterator<E> implements ListIterator<E> {
|
||||
* @param predicate the predicate to use
|
||||
*/
|
||||
public FilterListIterator(final ListIterator<? extends E> iterator, final Predicate<? super E> predicate) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
this.predicate = predicate;
|
||||
}
|
||||
@ -107,7 +104,6 @@ public class FilterListIterator<E> implements ListIterator<E> {
|
||||
* @param predicate the predicate to use.
|
||||
*/
|
||||
public FilterListIterator(final Predicate<? super E> predicate) {
|
||||
super();
|
||||
this.predicate = predicate;
|
||||
}
|
||||
|
||||
|
||||
@ -76,7 +76,6 @@ public class IteratorChain<E> implements Iterator<E> {
|
||||
* iterators after using this constructor.
|
||||
*/
|
||||
public IteratorChain() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -93,7 +92,6 @@ public class IteratorChain<E> implements Iterator<E> {
|
||||
* @throws NullPointerException if the iterator is null
|
||||
*/
|
||||
public IteratorChain(final Iterator<? extends E> iterator) {
|
||||
super();
|
||||
addIterator(iterator);
|
||||
}
|
||||
|
||||
@ -108,7 +106,6 @@ public class IteratorChain<E> implements Iterator<E> {
|
||||
* @throws NullPointerException if either iterator is null
|
||||
*/
|
||||
public IteratorChain(final Iterator<? extends E> first, final Iterator<? extends E> second) {
|
||||
super();
|
||||
addIterator(first);
|
||||
addIterator(second);
|
||||
}
|
||||
@ -123,7 +120,6 @@ public class IteratorChain<E> implements Iterator<E> {
|
||||
* @throws NullPointerException if iterators array is or contains null
|
||||
*/
|
||||
public IteratorChain(final Iterator<? extends E>... iteratorChain) {
|
||||
super();
|
||||
for (final Iterator<? extends E> element : iteratorChain) {
|
||||
addIterator(element);
|
||||
}
|
||||
@ -142,7 +138,6 @@ public class IteratorChain<E> implements Iterator<E> {
|
||||
* iterator
|
||||
*/
|
||||
public IteratorChain(final Collection<Iterator<? extends E>> iteratorChain) {
|
||||
super();
|
||||
for (final Iterator<? extends E> iterator : iteratorChain) {
|
||||
addIterator(iterator);
|
||||
}
|
||||
|
||||
@ -115,7 +115,6 @@ public class IteratorIterable<E> implements Iterable<E> {
|
||||
* @param multipleUse {@code true} if the new iterable can be used in multiple iterations
|
||||
*/
|
||||
public IteratorIterable(final Iterator<? extends E> iterator, final boolean multipleUse) {
|
||||
super();
|
||||
if (multipleUse && !(iterator instanceof ResettableIterator)) {
|
||||
this.iterator = new ListIteratorWrapper<>(iterator);
|
||||
} else {
|
||||
|
||||
@ -76,7 +76,6 @@ public class ListIteratorWrapper<E> implements ResettableListIterator<E> {
|
||||
* @throws NullPointerException if the iterator is null
|
||||
*/
|
||||
public ListIteratorWrapper(final Iterator<? extends E> iterator) {
|
||||
super();
|
||||
this.iterator = Objects.requireNonNull(iterator, "iterator");
|
||||
}
|
||||
|
||||
|
||||
@ -80,7 +80,6 @@ public class ObjectArrayIterator<E> implements ResettableIterator<E> {
|
||||
* @throws NullPointerException if {@code array} is {@code null}
|
||||
*/
|
||||
public ObjectArrayIterator(final E array[], final int start, final int end) {
|
||||
super();
|
||||
if (start < 0) {
|
||||
throw new ArrayIndexOutOfBoundsException("Start index must not be less than zero");
|
||||
}
|
||||
|
||||
@ -104,7 +104,6 @@ public class ObjectGraphIterator<E> implements Iterator<E> {
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public ObjectGraphIterator(final E root, final Transformer<? super E, ? extends E> transformer) {
|
||||
super();
|
||||
if (root instanceof Iterator) {
|
||||
this.currentIterator = (Iterator<? extends E>) root;
|
||||
} else {
|
||||
@ -124,7 +123,6 @@ public class ObjectGraphIterator<E> implements Iterator<E> {
|
||||
* @param rootIterator the root iterator, null will result in an empty iterator
|
||||
*/
|
||||
public ObjectGraphIterator(final Iterator<? extends E> rootIterator) {
|
||||
super();
|
||||
this.currentIterator = rootIterator;
|
||||
this.transformer = null;
|
||||
}
|
||||
|
||||
@ -70,7 +70,6 @@ public class PushbackIterator<E> implements Iterator<E> {
|
||||
* @param iterator the iterator to decorate
|
||||
*/
|
||||
public PushbackIterator(final Iterator<? extends E> iterator) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
|
||||
@ -53,7 +53,6 @@ public class ReverseListIterator<E> implements ResettableListIterator<E> {
|
||||
* @throws NullPointerException if the list is null
|
||||
*/
|
||||
public ReverseListIterator(final List<E> list) {
|
||||
super();
|
||||
this.list = Objects.requireNonNull(list, "list");
|
||||
iterator = list.listIterator(list.size());
|
||||
}
|
||||
|
||||
@ -58,7 +58,6 @@ public class SingletonIterator<E>
|
||||
* @since 3.1
|
||||
*/
|
||||
public SingletonIterator(final E object, final boolean removeAllowed) {
|
||||
super();
|
||||
this.object = object;
|
||||
this.removeAllowed = removeAllowed;
|
||||
}
|
||||
|
||||
@ -40,7 +40,6 @@ public class SingletonListIterator<E> implements ResettableListIterator<E> {
|
||||
* @param object the single object to return from the iterator
|
||||
*/
|
||||
public SingletonListIterator(final E object) {
|
||||
super();
|
||||
this.object = object;
|
||||
}
|
||||
|
||||
|
||||
@ -39,7 +39,6 @@ public class TransformIterator<I, O> implements Iterator<O> {
|
||||
* {@link #setTransformer(Transformer)} methods are invoked.
|
||||
*/
|
||||
public TransformIterator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -49,7 +48,6 @@ public class TransformIterator<I, O> implements Iterator<O> {
|
||||
* @param iterator the iterator to use
|
||||
*/
|
||||
public TransformIterator(final Iterator<? extends I> iterator) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
@ -63,7 +61,6 @@ public class TransformIterator<I, O> implements Iterator<O> {
|
||||
*/
|
||||
public TransformIterator(final Iterator<? extends I> iterator,
|
||||
final Transformer<? super I, ? extends O> transformer) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
this.transformer = transformer;
|
||||
}
|
||||
|
||||
@ -63,7 +63,6 @@ public final class UnmodifiableIterator<E> implements Iterator<E>, Unmodifiable
|
||||
* @param iterator the iterator to decorate
|
||||
*/
|
||||
private UnmodifiableIterator(final Iterator<? extends E> iterator) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
|
||||
@ -61,7 +61,6 @@ public final class UnmodifiableListIterator<E> implements ListIterator<E>, Unmod
|
||||
* @param iterator the iterator to decorate
|
||||
*/
|
||||
private UnmodifiableListIterator(final ListIterator<? extends E> iterator) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
|
||||
@ -64,7 +64,6 @@ public final class UnmodifiableMapIterator<K, V> implements MapIterator<K, V>, U
|
||||
* @param iterator the iterator to decorate
|
||||
*/
|
||||
private UnmodifiableMapIterator(final MapIterator<? extends K, ? extends V> iterator) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
|
||||
@ -65,7 +65,6 @@ public final class UnmodifiableOrderedMapIterator<K, V> implements OrderedMapIte
|
||||
* @param iterator the iterator to decorate
|
||||
*/
|
||||
private UnmodifiableOrderedMapIterator(final OrderedMapIterator<K, ? extends V> iterator) {
|
||||
super();
|
||||
this.iterator = iterator;
|
||||
}
|
||||
|
||||
|
||||
@ -40,7 +40,6 @@ public abstract class AbstractKeyValue<K, V> implements KeyValue<K, V> {
|
||||
* @param value the value for the entry, may be null
|
||||
*/
|
||||
protected AbstractKeyValue(final K key, final V value) {
|
||||
super();
|
||||
this.key = key;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
@ -217,7 +217,6 @@ public class MultiKey<K> implements Serializable {
|
||||
* @since 3.1
|
||||
*/
|
||||
public MultiKey(final K[] keys, final boolean makeClone) {
|
||||
super();
|
||||
Objects.requireNonNull(keys, "keys");
|
||||
this.keys = makeClone ? keys.clone() : keys;
|
||||
calculateHashCode(keys);
|
||||
|
||||
@ -50,7 +50,6 @@ public class TiedMapEntry<K, V> implements Map.Entry<K, V>, KeyValue<K, V>, Seri
|
||||
* @param key the key
|
||||
*/
|
||||
public TiedMapEntry(final Map<K, V> map, final K key) {
|
||||
super();
|
||||
this.map = map;
|
||||
this.key = key;
|
||||
}
|
||||
|
||||
@ -75,7 +75,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
|
||||
* method must be called.
|
||||
*/
|
||||
protected AbstractLinkedList() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -84,7 +83,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
|
||||
* @param coll the collection to copy
|
||||
*/
|
||||
protected AbstractLinkedList(final Collection<? extends E> coll) {
|
||||
super();
|
||||
init();
|
||||
addAll(coll);
|
||||
}
|
||||
@ -670,7 +668,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
|
||||
* Constructs a new header node.
|
||||
*/
|
||||
protected Node() {
|
||||
super();
|
||||
previous = this;
|
||||
next = this;
|
||||
}
|
||||
@ -681,7 +678,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
|
||||
* @param value the value to store
|
||||
*/
|
||||
protected Node(final E value) {
|
||||
super();
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
@ -693,7 +689,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
|
||||
* @param value the value to store
|
||||
*/
|
||||
protected Node(final Node<E> previous, final Node<E> next, final E value) {
|
||||
super();
|
||||
this.previous = previous;
|
||||
this.next = next;
|
||||
this.value = value;
|
||||
@ -807,7 +802,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
|
||||
*/
|
||||
protected LinkedListIterator(final AbstractLinkedList<E> parent, final int fromIndex)
|
||||
throws IndexOutOfBoundsException {
|
||||
super();
|
||||
this.parent = parent;
|
||||
this.expectedModCount = parent.modCount;
|
||||
this.next = parent.getNode(fromIndex, true);
|
||||
|
||||
@ -42,7 +42,6 @@ public abstract class AbstractListDecorator<E> extends AbstractCollectionDecorat
|
||||
* @since 3.1
|
||||
*/
|
||||
protected AbstractListDecorator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -71,7 +71,6 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
|
||||
* Constructor that creates.
|
||||
*/
|
||||
public CursorableLinkedList() {
|
||||
super();
|
||||
init(); // must call init() as use super();
|
||||
}
|
||||
|
||||
|
||||
@ -92,7 +92,6 @@ public class NodeCachingLinkedList<E> extends AbstractLinkedList<E> implements S
|
||||
* @param maximumCacheSize the maximum cache size
|
||||
*/
|
||||
public NodeCachingLinkedList(final int maximumCacheSize) {
|
||||
super();
|
||||
this.maximumCacheSize = maximumCacheSize;
|
||||
init(); // must call init() as use super();
|
||||
}
|
||||
|
||||
@ -77,7 +77,6 @@ public class TreeList<E> extends AbstractList<E> {
|
||||
* Constructs a new empty list.
|
||||
*/
|
||||
public TreeList() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -87,7 +86,6 @@ public class TreeList<E> extends AbstractList<E> {
|
||||
* @throws NullPointerException if the collection is null
|
||||
*/
|
||||
public TreeList(final Collection<? extends E> coll) {
|
||||
super();
|
||||
if (!coll.isEmpty()) {
|
||||
root = new AVLNode<>(coll);
|
||||
size = coll.size();
|
||||
@ -1018,7 +1016,6 @@ public class TreeList<E> extends AbstractList<E> {
|
||||
* @param fromIndex the index to start at
|
||||
*/
|
||||
protected TreeListIterator(final TreeList<E> parent, final int fromIndex) throws IndexOutOfBoundsException {
|
||||
super();
|
||||
this.parent = parent;
|
||||
this.expectedModCount = parent.modCount;
|
||||
this.next = parent.root == null ? null : parent.root.get(fromIndex);
|
||||
|
||||
@ -98,7 +98,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
* Constructor only used in deserialization, do not use otherwise.
|
||||
*/
|
||||
protected AbstractHashedMap() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -110,7 +109,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
protected AbstractHashedMap(final int initialCapacity, final float loadFactor, final int threshold) {
|
||||
super();
|
||||
this.loadFactor = loadFactor;
|
||||
this.data = new HashEntry[initialCapacity];
|
||||
this.threshold = threshold;
|
||||
@ -139,7 +137,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
protected AbstractHashedMap(int initialCapacity, final float loadFactor) {
|
||||
super();
|
||||
if (initialCapacity < 0) {
|
||||
throw new IllegalArgumentException("Initial capacity must be a non negative number");
|
||||
}
|
||||
@ -846,7 +843,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
private final AbstractHashedMap<K, V> parent;
|
||||
|
||||
protected EntrySet(final AbstractHashedMap<K, V> parent) {
|
||||
super();
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
@ -946,7 +942,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
private final AbstractHashedMap<K, ?> parent;
|
||||
|
||||
protected KeySet(final AbstractHashedMap<K, ?> parent) {
|
||||
super();
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
@ -1035,7 +1030,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
private final AbstractHashedMap<?, V> parent;
|
||||
|
||||
protected Values(final AbstractHashedMap<?, V> parent) {
|
||||
super();
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
@ -1101,7 +1095,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
protected Object value;
|
||||
|
||||
protected HashEntry(final HashEntry<K, V> next, final int hashCode, final Object key, final V value) {
|
||||
super();
|
||||
this.next = next;
|
||||
this.hashCode = hashCode;
|
||||
this.key = key;
|
||||
@ -1177,7 +1170,6 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
|
||||
private int expectedModCount;
|
||||
|
||||
protected HashIterator(final AbstractHashedMap<K, V> parent) {
|
||||
super();
|
||||
this.parent = parent;
|
||||
final HashEntry<K, V>[] data = parent.data;
|
||||
int i = data.length;
|
||||
|
||||
@ -51,7 +51,6 @@ abstract class AbstractInputCheckedMapDecorator<K, V>
|
||||
* Constructor only used in deserialization, do not use otherwise.
|
||||
*/
|
||||
protected AbstractInputCheckedMapDecorator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -75,7 +75,6 @@ public abstract class AbstractLinkedMap<K, V> extends AbstractHashedMap<K, V> im
|
||||
* Constructor only used in deserialization, do not use otherwise.
|
||||
*/
|
||||
protected AbstractLinkedMap() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -555,7 +554,6 @@ public abstract class AbstractLinkedMap<K, V> extends AbstractHashedMap<K, V> im
|
||||
protected int expectedModCount;
|
||||
|
||||
protected LinkIterator(final AbstractLinkedMap<K, V> parent) {
|
||||
super();
|
||||
this.parent = parent;
|
||||
this.next = parent.header.after;
|
||||
this.expectedModCount = parent.modCount;
|
||||
|
||||
@ -50,7 +50,6 @@ public abstract class AbstractMapDecorator<K, V> extends AbstractIterableMap<K,
|
||||
* @since 3.1
|
||||
*/
|
||||
protected AbstractMapDecorator() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user