# Package de.caff.generics

Generics tools package.

See: Description

- Interface Summary
  Interface | Description
  --- | ---
  Accessor<T> | Abstraction for getting and setting a value.
  ActiveListListener<T> | A listener for `active lists`.
  ArrayFactory<T> | Factory for array creation.
  BooleanIndexable | Class which allows readonly access of raw booleans by index.
  BooleanIndexable.EntryConsumer | Consumer for index-value pairs with `int` values.
  ByteIndexable | Class which allows readonly access of raw bytes by index.
  CharIndexable | Class which allows readonly access of raw chars by index.
  Copier<T> | Get copies of items of a given class.
  Copyable<T> | Enhanced cloning support.
  Countable<T> | Something containing a defined number of arbitrary elements which can be iterated over.
  CountingSet<T> | A set which counts the number of additions.
  Dict<K,V> | A dictionary.
  DoubleIndexable | Class which allows readonly access of raw doubles by index.
  ExpandableDoubleIndexable | Immutable expandable primitive double indexable.
  ExpandableIndexable<T> | Immutable expandable indexable.
  ExpandableIntIndexable | Immutable expandable primitive integer indexable.
  ExpandableLongIndexable | Immutable expandable primitive long indexable.
  Factory<T> | A factory knows how to create objects of a given type.
  FloatIndexable | Class which allows readonly access of raw floats by index.
  FragileLoopItemHandler<T,E extends java.lang.Exception> | A generic handler for loop items which may throw an exception.
  FragileTypeConverter<T,S> | Converter which knows how to convert one type into another, but may throw an exception in certain cases..
  FStack<T> | A functional stack.
  HashCodeCalculator<T> | Calculator interface for generalized hash code calculation.
  Indexable<T> | Class which allows readonly access by index.
  IntCountable | Something containing a defined number of int values which can be iterated over.
  IntIndexable | Class which allows readonly access of raw integers by index.
  IntIndexable.EntryConsumer | Consumer for index-value pairs with `int` values.
  Lazy<T> | Support for lazy evaluation.
  LongIndexable | Class which allows readonly access of raw long integers by index.
  LoopHandler | Handler for loops.
  LoopItemHandler<T> | Generic handler of items during a loop..
  Matcher<T1,T2> |
  MutableBooleanIndexable | Primitive boolean indexable with fixed length but mutable content.
  MutableByteIndexable | Primitive byte indexable with fixed length but mutable content.
  MutableCharIndexable | Primitive char indexable with fixed length but mutable content.
  MutableDoubleIndexable | Primitive double indexable with fixed length but mutable content.
  MutableFloatIndexable | Primitive float indexable with fixed length but mutable content.
  MutableIndexable<T> | Indexable with fixed length but mutable content.
  MutableIntIndexable | Primitive int indexable with fixed length but mutable content.
  MutableLongIndexable | Primitive long indexable with fixed length but mutable content.
  MutableShortIndexable | Primitive short indexable with fixed length but mutable content.
  NamedNullableValue<T> | A nullable value with a name.
  NamedValue<T> | A non-null value with a name.
  NullableAccessor<T> | Abstractign for getting and setting a value.
  PrimitiveBooleanIterable | Iterable which iterates over a primitive boolean.
  PrimitiveBooleanIterator | An iterator specialized for `boolean` values.
  PrimitiveByteIterable | Iterable which iterates over a primitive byte.
  PrimitiveByteIterator | An iterator specialized for `short` values.
  PrimitiveCharIterable | Iterable which iterates over a primitive char.
  PrimitiveCharIterator | An iterator specialized for `cahr` values.
  PrimitiveDoubleIterable | Iterable which iterates over a primitive double.
  PrimitiveFloatIterable | Iterable which iterates over a primitive float.
  PrimitiveFloatIterator | An iterator specialized for `float` values.
  PrimitiveIntIterable | Iterable which iterates over a primitive int.
  PrimitiveLongIterable | Iterable which iterates over a primitive long.
  PrimitiveShortIterable | Iterable which iterates over a primitive short.
  PrimitiveShortIterator | An iterator specialized for `short` values.
  ReferenceCreator<R extends java.lang.ref.Reference<? super V>,V> | Reference creator.
  ShortIndexable | Class which allows readonly access of raw short integers by index.
  Sizeable | Something which has an integer size.
  Subject<T> | This is mainly a marker interface for subjectivized objects.
  Subjective<T> | Type-based information how to create a `Subject` from an object.
  TwoWayChoice<T> | A choice between two values.
  TwoWayChoiceN<T> | A choice between two values which may be `null`.
  TwoWayTypeConverter<T,S> | Type converter which can convert between two types in both ways.
  UniformMatcher<T> | A uniform matcher is a `Matcher` which can only compare objects of the same type.

- Class Summary
  Class | Description
  --- | ---
  AbstractBasicCopyable<T extends java.lang.Cloneable> | Basic implementation of copyable object.
  AbstractBasicCountingSet<T> | Basic implementation for counting sets.
  AbstractBasicUnmodifiableList<T> | Basic implementation of an unmodifiable list.
  ActiveList<T> | An active lists sends events on changes.
  ArrayIterator<T> | An iterator over an array.
  BasicLoop<T extends BasicLoop.Item<T>> | Wrapper around a double linked list which forms a loop.
  BasicLoop.Item<V extends BasicLoop.Item<V>> | Base implementation of a double linked loop item.
  BooleanIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  BooleanPair | A pair of primitive boolean values.
  ByteIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  BytePair | A pair of primitive byte values.
  CharIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  CharPair | A pair of primitive char values.
  ConcatenatedIterables<T> | Concatenated iterables.
  ConcatenatedIterators<T> | Concatenated iterators.
  CopierFStackImpl<T> | Implementation of a functional stack which takes care of mutable elements by copying them.
  CopierFStackImpl.Empty<T> | Empty copier stack implementation.
  Countable.Base<TT> | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  CountingHashSet<T> | A set which also counts how often any element was added.
  CountingTreeSet<T> | A sorted set which also counts how often any element was added.
  Dict.Base<KK,VV> | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  Dict.Entry<EK,EV> | Entry access.
  DoubleIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  DoubleIndexable.DoubleIndexableSpliterator | Spliterator for double indexables.
  DoublePair | A pair of primitive double values.
  Empty | This interface just contains various constant empty items (especially arrays): These can be used as defaults in various circumstances.
  EnumerationIterator<T> | Iterator wrapper for an enumeration.
  Enums | Toolbox for enums.
  ExpandableDoubleIndexableImpl | Default implementation used for immutable expandable double indexable.
  ExpandableIndexableImpl | Default implementation used for immutable expandable indexable.
  ExpandableIntIndexableImpl | Default implementation used for immutable expandable integer indexable.
  ExpandableLongIndexableImpl | Default implementation used for immutable expandable long indexable.
  FilteringIteratorWrapper<T> | A wrapper for a standard iterator which only iterates over selected elements.
  FloatIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  FloatPair | A pair of primitive float values.
  FStackImpl<T> | Implementation of a functional stack.
  HashCacheWrapper<T> | Helper class which is caching a hash value.
  HashCoder<T> | Helper interface for `HashCoderMap`.
  HashCoderMap<K,V> | A hashmap implementation that allows to provide a dedicated hashcode implementation for its elements.
  HashCoderSet<V> | A hashset implementation which allows to provide a dedicated hashcode implementation for its elements.
  IdentityHashSet<T> | Hash set based on identities.
  Indexable.Base<TT> | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  Indexable.IndexableSpliterator<TElem> | A spliterator for indexables.
  Indexable.ListView<T> | Helper class for viewing a mutable indexable as a standard list.
  IndexableHelper | Helper class for indexables.
  IntCountable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  IntIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  IntIndexable.IntIndexableSpliterator | Spliterator for int indexables.
  IntPair | A pair of primitive int values.
  IterableConverter<T,S> |
  IteratorConverter<T,S> | Convert an iterator to another type.
  IteratorEnumeration<T> | Enumeration wrapper for an iterator.
  LeastRecentlyUsedCache<K,V> | A map which implements a least recently used cache.
  ListIteratorConverter<T,S> | A list iterator which maps the returned value.
  LongIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  LongIndexable.LongIndexableSpliterator | Spliterator for long indexables.
  LongPair | A pair of primitive long values.
  Loop<T> | Generic version of a loop where loop items can contain any value.
  Loop.Item<T> | Generic loop item.
  MatchSet<E> | A set which is using an `UniformMatcher` for checker for equality.
  MutableBooleanIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableByteIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableCharIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableDoubleIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableFloatIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableIndexable.Base<TT> | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableIndexable.ListView<T> | Helper class for viewing a mutable indexable as a standard list.
  MutableIntIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableLongIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  MutableShortIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  NullableUnion<T1,T2> | This class defines a union structure for two values, where only one of them exists.
  OrderedPair<S,T> | A simple ordered pair.
  Pair<T> | An ordered pair with equal types for first and second.
  Primitives | Primitives helper tool.
  Pythonesque | Helper class for pythionesque indexing.
  RecreatingLeastRecentlyUsedCache<K,V> | A least recently used cache which also allows to predefine a way to recreate lost entries.
  References | Helper for reference creation.
  RefValueHashMap<K,V> | A hashmap with strong keys and soft referenced values.
  RefWrapperHashSet<V> | A hash st which holds its elements as references.
  RefWrapperList<V> | A list which holds its elements as references.
  Sequences | Equality and comparability for sequences.
  ShortIndexable.Base | Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
  ShortPair | A pair of primitive short values.
  SingletonIterator<T> | An iterator which iterates over a single element.
  SoftPropertyChangeListener | Wrapper for a property change listener which reference the original change listener softly.
  SoftValueHashMap<K,V> | A hashmap with strong keys and soft referenced values.
  Subject.Base<TT> |
  Subjectivity | A subjective view on objects.
  SynchronizedCollection<T> | Synchronized collection.
  SynchronizedList<T> | Synchronized list.
  Types | Tool with helpful methods for type conversion.
  TypesImpFilter | Partial class used by Types, defining the filter algorithms.
  TypesImplFolding | Partial class used by Types, defining the folding algorithms.
  TypesImplMap | Partial class used by Types, defining the map algorithms.
  Union<T1,T2> | This class defines a union structure for two exclusive values of different types.
  UnionBase<T1,T2> | Helper interface for a union of two exclusive values of different types.
  UnmodifiableListArrayWrapper<T> | Let an array appear as an unmodifiable list.
  UnmodifiableListBooleanArrayWrapper | Let an array appear as an unmodifiable list.
  UnmodifiableListByteArrayWrapper | Let an array appear as an unmodifiable list.
  UnmodifiableListDoubleArrayWrapper | Let an array appear as an unmodifiable list.
  UnmodifiableListFloatArrayWrapper | Let an array appear as an unmodifiable list.
  UnmodifiableListIntArrayWrapper | Let an int array appear as an unmodifiable list.
  UnmodifiableListLongArrayWrapper | Let an array appear as an unmodifiable list.
  UnmodifiableListShortArrayWrapper | Let an array appear as an unmodifiable list.
  WeakPropertyChangeListener | Wrapper for a property change listener which reference the original change listener weakly.
  WeakValueHashMap<K,V> | A hashmap with strong keys and weakly referenced values.

- Enum Summary
  Enum | Description
  --- | ---
  Order | Order of two values.

- Exception Summary
  Exception | Description
  --- | ---
  LazyEvalutionFailure | Exception thrown when a `lazy evaluation` fails because of a checked exception.
  TypeConverterException | Exception thrown during type conversion.
  WrappedFragileException | A runtime exception wrapper for a checked exception which occurred in places where there is no way to handle it.

- Error Summary
  Error | Description
  --- | ---
  EmptyLoopError | Empty loop error thrown when accessing elements of an empty `BasicLoop`.
  FactoryError | Error which the `Factory.create()` method may throw.

## Package de.caff.generics Description

Generics tools package.

## Package Specification

Most items in this package are no longer necessary when using Java 8 and later.

This package contains classes using generics to allow for functional programming without the overhead of streams and also have dedicated read-only collections.

### Read-only Collection Interfaces

The package provides some read-only substitutes for standard collections. Basically they can be used in places where a standard collection with an unmodifiable wrapper is used, with the main advantage that using one of the classes here substitutes the implicit don't modify (or you'll get an excpetion) with a much clearer can't modify (because there are no methods for that). The classes are

Interface from this Package | Purpose
--- | ---
`Countable` | Read-only substitute for `java.util.Collection`
`Indexable` | Read-only subatitute for `java.util.List` and arrays
`Dict` | Read-only substitute for `java.util.Map`
`FStack` | Functional implementation similar to `java.util.Stack`, used a bit differently

As these interfaces only provide read-only methiods it's simple to view them as if they have different contents.

Similar to `Indexable` for objects there are also flavors for all primitive values, e.g. `IntIndexable` for `int`. In many cases these can be used instead of arrays, again with the advantage that they are not modifiable. So they can be used as public constants which would be a bad idea with an array. Also useful when an array field is returned from a method. Using arrays usually a copy is necessary when returning such a field when the receiver should not be able to modify the array's content.

### Handling Standard Collections

Copying one collection into another while modifying it is possible with streams, but sometimes this is a bit over the top. In these cases many methods provided here are still useful.

- Easy type conversion for iterating over collections and similar (i.e. any `Iterable`, `Iterator` and `Enumeration`): see
  - `Types.downCast(java.lang.Iterable)` (safe)
  - `Types.downCast(java.util.Iterator)` (safe)
  - `Types.downCast(java.util.Enumeration)` (safe)
  - `Types.cast(java.lang.Iterable)` (unsafe)
  - `Types.cast(java.util.Iterator)` (unsafe)
  - `Types.cast(java.util.Enumeration)` (unsafe)
- Various standard type conversions, usable for converting between collections, see next point:
  - `Types.TO_STRING`: converting to string, using the toString() method
  - `Types.STR_TO_DOUBLE`: converting strings to Double
  - `Types.STR_TO_FLOAT`: converting strings to Float
  - `Types.STR_TO_LONG`: converting strings to Long
  - `Types.STR_TO_LONG_BASE_16`: converting strings to Long
  - `Types.STR_TO_LONG_BASE_8`: converting strings to Long
  - `Types.STR_TO_LONG_BASE_2`: converting strings to Long
  - `Types.STR_TO_INT`: converting strings to Integer
  - `Types.STR_TO_INT_BASE_16`: converting strings to Integer
  - `Types.STR_TO_INT_BASE_8`: converting strings to Integer
  - `Types.STR_TO_INT_BASE_2`: converting strings to Integer
  - `Types.STR_TO_SHORT`: converting strings to Short
  - `Types.STR_TO_SHORT_BASE_16`: converting strings to Short
  - `Types.STR_TO_SHORT_BASE_8`: converting strings to Short
  - `Types.STR_TO_SHORT_BASE_2`: converting strings to Short
  - `Types.STR_TO_BYTE`: converting strings to Byte
  - `Types.STR_TO_BYTE_BASE_16`: converting strings to Byte
  - `Types.STR_TO_BYTE_BASE_8`: converting strings to Byte
  - `Types.STR_TO_BYTE_BASE_2`: converting strings to Byte
  - `Types.NUMBER_TO_DOUBLE`: converting any `Number` based type to Double
  - `Types.NUMBER_TO_FLOAT`: converting any `Number` based type to Float
  - `Types.NUMBER_TO_LONG`: converting any `Number` based type to Long
  - `Types.NUMBER_TO_INT`: converting any `Number` based type to Integer
  - `Types.NUMBER_TO_SHORT`: converting any `Number` based type to Short
  - `Types.NUMBER_TO_BYTE`: converting any `Number` based type to Byte
- Mapping of a collection or array to another collection, not allowing conversion exceptions:
  - `Types.map(java.lang.Object[], java.util.function.Function)`
  - `Types.map(java.lang.Iterable, java.util.function.Function)`
  - `Types.map(java.util.Iterator, java.util.function.Function)`
  - `Types.map(java.util.Enumeration, java.util.function.Function)`
  - `Types.map(java.util.Collection, java.lang.Object[], java.util.function.Function)`
  - `Types.map(java.util.Collection, java.lang.Iterable, java.util.function.Function)`
  - `Types.map(java.util.Collection, java.util.Iterator, java.util.function.Function)`
  - `Types.map(java.util.Collection, java.util.Enumeration, java.util.function.Function)`
  - `Types.map(java.lang.Object[], java.util.function.Function, Object)`
  - `Types.map(java.lang.Iterable, java.util.function.Function, Object)`
  - `Types.map(java.util.Iterator, java.util.function.Function, Object)`
  - `Types.map(java.util.Enumeration, java.util.function.Function, Object)`
  - `Types.map(java.util.Collection, java.lang.Object[], java.util.function.Function, Object)`
  - `Types.map(java.util.Collection, java.lang.Iterable, java.util.function.Function, Object)`
  - `Types.map(java.util.Collection, java.util.Iterator, java.util.function.Function, Object)`
  - `Types.map(java.util.Collection, java.util.Enumeration, java.util.function.Function, Object)`
  The same but with possible conversion exceptions:
  - `Types.mapE(java.lang.Object[], de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.lang.Iterable, de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.util.Iterator, de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.util.Enumeration, de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.util.Collection, java.lang.Object[], de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.util.Collection, java.lang.Iterable, de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.util.Collection, java.util.Iterator, de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.util.Collection, java.util.Enumeration, de.caff.generics.FragileTypeConverter)`
  - `Types.mapE(java.lang.Object[], de.caff.generics.FragileTypeConverter, Object)`
  - `Types.mapE(java.lang.Iterable, de.caff.generics.FragileTypeConverter, Object)`
  - `Types.mapE(java.util.Iterator, de.caff.generics.FragileTypeConverter, Object)`
  - `Types.mapE(java.util.Enumeration, de.caff.generics.FragileTypeConverter, Object)`
  - `Types.mapE(java.util.Collection, java.lang.Object[], de.caff.generics.FragileTypeConverter, Object)`
  - `Types.mapE(java.util.Collection, java.lang.Iterable, de.caff.generics.FragileTypeConverter, Object)`
  - `Types.mapE(java.util.Collection, java.util.Iterator, de.caff.generics.FragileTypeConverter, Object)`
  - `Types.mapE(java.util.Collection, java.util.Enumeration, de.caff.generics.FragileTypeConverter, Object)`
- Doing something for each item in a collection or an array: see
  - `Types.forEach(java.lang.Object[], de.caff.generics.LoopItemHandler)` (w/o exception)
  - `Types.forEach(java.lang.Object[], de.caff.generics.FragileLoopItemHandler)` (w/ exception)
  - `Types.forEach(java.lang.Iterable, de.caff.generics.LoopItemHandler)` (w/o exception)
  - `Types.forEach(java.lang.Iterable, de.caff.generics.FragileLoopItemHandler)` (w/ exception)
  - `Types.forEach(java.util.Iterator, de.caff.generics.LoopItemHandler)` (w/o exception)
  - `Types.forEach(java.util.Iterator, de.caff.generics.FragileLoopItemHandler)` (w/ exception)
  - `Types.forEach(java.util.Enumeration, de.caff.generics.LoopItemHandler)` (w/o exception)
  - `Types.forEach(java.util.Enumeration, de.caff.generics.FragileLoopItemHandler)` (w/ exception)
- Pairs of values: see
  - `OrderedPair`: pair with differently typed items
  - `Pair`: pair with items of same type
- Converting enumerations to iterations and vice versa:
  - `EnumerationIterator`: enumeration to iterator
  - `IteratorEnumeration`: iterator to enumeration
- The possibility to extract objects of a given type from a collection or array:
  - `Types.extract(java.lang.Object[], java.lang.Class)`: default return
  - `Types.extract(java.util.Collection, java.lang.Object[], java.lang.Class)`: returning predefined collection
  - `Types.extract(java.lang.Iterable, java.lang.Class)`: default return
  - `Types.extract(java.util.Collection, java.lang.Iterable, java.lang.Class)`: returning predefined collection
  - `Types.extract(java.util.Iterator, java.lang.Class)`: default return
  - `Types.extract(java.util.Collection, java.util.Iterator, java.lang.Class)`: returning predefined collection
  - `Types.extract(java.util.Enumeration, java.lang.Class)`: default return
  - `Types.extract(java.util.Collection, java.util.Enumeration, java.lang.Class)`: returning predefined collection
- Various collections and helper classes for using referenced values:
  - `ReferenceCreator`: create references
  - `References`: simple access to basic reference generators, see above
  - `RefValueHashMap`: a hash map with references values
  - `RefWrapperHashSet`: a hash set with referenced values
  - `RefWrapperList`: a list with referenced values
  - `SoftValueHashMap`: a hash map with softly referenced values
  - `WeakValueHashMap`: a hash map with weakly referenced values
- A wrapper to use an array as a list which does not copy the array as `Arrays.asList(Object[])` is doing: `UnmodifiableListArrayWrapper`, but better use
  - `Types.asList(Object[])`
  - `Types.asList(Object[], int)`
  - `Types.asList(Object[], int, int)`
  Even better: these wrappers also exist for primitive arrays, e.g. arrays of `int`s.
- A `copy on demand implementation of a synchronized collection` which is easier to use compared to the one returned from `Collections.synchronizedCollection(java.util.Collection)` (especially there's no need for explicit synchronization), and is highly performant in situations where the underlying collection is often iterated over, but rarely changed. The last is usually true for listener collections.
- A `property change listener which is referenced weakly` or `softly`.
- Support for matching, which is a generalization of the flawed equality concept provided by the `Object.equals(java.lang.Object)` method. See
  - `the basic interface`
  - `a simplified interface for the most common case`
  - the `Match` class which provides some basic matchers
  - various methods for checking equality (based on a matcher) for arrays, collections and similar:
    - `Types.areEqual(java.util.Collection, java.util.Collection, java.util.function.BiPredicate)`
    - `Types.areEqual(java.lang.Object[], java.lang.Object[], java.util.function.BiPredicate)`
    - `Types.areEqual(java.lang.Iterable, java.lang.Iterable, java.util.function.BiPredicate)`
    - `Types.areEqual(java.util.Iterator, java.util.Iterator, java.util.function.BiPredicate)`
    - `Types.areEqual(java.util.Enumeration, java.util.Enumeration, java.util.function.BiPredicate)`