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 |
{@link de.caff.generics.Countable} | Read-only substitute for {@code java.util.Collection} |
{@link de.caff.generics.Indexable} | Read-only subatitute for {@code java.util.List} and arrays |
{@link de.caff.generics.Dict} | Read-only substitute for {@code java.util.Map} |
{@link de.caff.generics.FStack} | Functional implementation similar to {@code 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 {@code Indexable} for objects there are also flavors for all primitive
values, e.g. {@link de.caff.generics.IntIndexable} for {@code 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 {@link java.lang.Iterable},
{@link java.util.Iterator} and {@link java.util.Enumeration}): see
- {@link de.caff.generics.Types#downCast(java.lang.Iterable)} (safe)
- {@link de.caff.generics.Types#downCast(java.util.Iterator)} (safe)
- {@link de.caff.generics.Types#downCast(java.util.Enumeration)} (safe)
- {@link de.caff.generics.Types#cast(java.lang.Iterable)} (unsafe)
- {@link de.caff.generics.Types#cast(java.util.Iterator)} (unsafe)
- {@link de.caff.generics.Types#cast(java.util.Enumeration)} (unsafe)
-
Various standard type conversions, usable for converting between collections, see next point:
- {@link de.caff.generics.Types#TO_STRING}: converting to string, using the toString() method
- {@link de.caff.generics.Types#STR_TO_DOUBLE}: converting strings to Double
- {@link de.caff.generics.Types#STR_TO_FLOAT}: converting strings to Float
- {@link de.caff.generics.Types#STR_TO_LONG}: converting strings to Long
- {@link de.caff.generics.Types#STR_TO_LONG_BASE_16}: converting strings to Long
- {@link de.caff.generics.Types#STR_TO_LONG_BASE_8}: converting strings to Long
- {@link de.caff.generics.Types#STR_TO_LONG_BASE_2}: converting strings to Long
- {@link de.caff.generics.Types#STR_TO_INT}: converting strings to Integer
- {@link de.caff.generics.Types#STR_TO_INT_BASE_16}: converting strings to Integer
- {@link de.caff.generics.Types#STR_TO_INT_BASE_8}: converting strings to Integer
- {@link de.caff.generics.Types#STR_TO_INT_BASE_2}: converting strings to Integer
- {@link de.caff.generics.Types#STR_TO_SHORT}: converting strings to Short
- {@link de.caff.generics.Types#STR_TO_SHORT_BASE_16}: converting strings to Short
- {@link de.caff.generics.Types#STR_TO_SHORT_BASE_8}: converting strings to Short
- {@link de.caff.generics.Types#STR_TO_SHORT_BASE_2}: converting strings to Short
- {@link de.caff.generics.Types#STR_TO_BYTE}: converting strings to Byte
- {@link de.caff.generics.Types#STR_TO_BYTE_BASE_16}: converting strings to Byte
- {@link de.caff.generics.Types#STR_TO_BYTE_BASE_8}: converting strings to Byte
- {@link de.caff.generics.Types#STR_TO_BYTE_BASE_2}: converting strings to Byte
- {@link de.caff.generics.Types#NUMBER_TO_DOUBLE}: converting any {@link java.lang.Number} based type to Double
- {@link de.caff.generics.Types#NUMBER_TO_FLOAT}: converting any {@link java.lang.Number} based type to Float
- {@link de.caff.generics.Types#NUMBER_TO_LONG}: converting any {@link java.lang.Number} based type to Long
- {@link de.caff.generics.Types#NUMBER_TO_INT}: converting any {@link java.lang.Number} based type to Integer
- {@link de.caff.generics.Types#NUMBER_TO_SHORT}: converting any {@link java.lang.Number} based type to Short
- {@link de.caff.generics.Types#NUMBER_TO_BYTE}: converting any {@link java.lang.Number} based type to Byte
-
Mapping of a collection or array to another collection, not allowing conversion exceptions:
- {@link de.caff.generics.Types#map(java.lang.Object[], java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.lang.Iterable, java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.util.Iterator, java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.util.Enumeration, java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.lang.Object[], java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.lang.Iterable, java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.util.Iterator, java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.util.Enumeration, java.util.function.Function)}
- {@link de.caff.generics.Types#map(java.lang.Object[], java.util.function.Function, Object)}
- {@link de.caff.generics.Types#map(java.lang.Iterable, java.util.function.Function, Object)}
- {@link de.caff.generics.Types#map(java.util.Iterator, java.util.function.Function, Object)}
- {@link de.caff.generics.Types#map(java.util.Enumeration, java.util.function.Function, Object)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.lang.Object[], java.util.function.Function, Object)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.lang.Iterable, java.util.function.Function, Object)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.util.Iterator, java.util.function.Function, Object)}
- {@link de.caff.generics.Types#map(java.util.Collection, java.util.Enumeration, java.util.function.Function, Object)}
The same but with possible conversion exceptions:
- {@link de.caff.generics.Types#mapE(java.lang.Object[], de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.lang.Iterable, de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.util.Iterator, de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.util.Enumeration, de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.util.Collection, java.lang.Object[], de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.util.Collection, java.lang.Iterable, de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.util.Collection, java.util.Iterator, de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.util.Collection, java.util.Enumeration, de.caff.generics.FragileTypeConverter)}
- {@link de.caff.generics.Types#mapE(java.lang.Object[], de.caff.generics.FragileTypeConverter, Object)}
- {@link de.caff.generics.Types#mapE(java.lang.Iterable, de.caff.generics.FragileTypeConverter, Object)}
- {@link de.caff.generics.Types#mapE(java.util.Iterator, de.caff.generics.FragileTypeConverter, Object)}
- {@link de.caff.generics.Types#mapE(java.util.Enumeration, de.caff.generics.FragileTypeConverter, Object)}
- {@link de.caff.generics.Types#mapE(java.util.Collection, java.lang.Object[], de.caff.generics.FragileTypeConverter, Object)}
- {@link de.caff.generics.Types#mapE(java.util.Collection, java.lang.Iterable, de.caff.generics.FragileTypeConverter, Object)}
- {@link de.caff.generics.Types#mapE(java.util.Collection, java.util.Iterator, de.caff.generics.FragileTypeConverter, Object)}
- {@link de.caff.generics.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
- {@link de.caff.generics.Types#forEach(java.lang.Object[], de.caff.generics.LoopItemHandler)} (w/o exception)
- {@link de.caff.generics.Types#forEach(java.lang.Object[], de.caff.generics.FragileLoopItemHandler)} (w/ exception)
- {@link de.caff.generics.Types#forEach(java.lang.Iterable, de.caff.generics.LoopItemHandler)} (w/o exception)
- {@link de.caff.generics.Types#forEach(java.lang.Iterable, de.caff.generics.FragileLoopItemHandler)} (w/ exception)
- {@link de.caff.generics.Types#forEach(java.util.Iterator, de.caff.generics.LoopItemHandler)} (w/o exception)
- {@link de.caff.generics.Types#forEach(java.util.Iterator, de.caff.generics.FragileLoopItemHandler)} (w/ exception)
- {@link de.caff.generics.Types#forEach(java.util.Enumeration, de.caff.generics.LoopItemHandler)} (w/o exception)
- {@link de.caff.generics.Types#forEach(java.util.Enumeration, de.caff.generics.FragileLoopItemHandler)} (w/ exception)
-
Pairs of values: see
- {@link de.caff.generics.OrderedPair}: pair with differently typed items
- {@link de.caff.generics.Pair}: pair with items of same type
-
Converting enumerations to iterations and vice versa:
- {@link de.caff.generics.EnumerationIterator}: enumeration to iterator
- {@link de.caff.generics.IteratorEnumeration}: iterator to enumeration
-
The possibility to extract objects of a given type from a collection or array:
- {@link de.caff.generics.Types#extract(java.lang.Object[], java.lang.Class)}: default return
- {@link de.caff.generics.Types#extract(java.util.Collection, java.lang.Object[], java.lang.Class)}: returning predefined collection
- {@link de.caff.generics.Types#extract(java.lang.Iterable, java.lang.Class)}: default return
- {@link de.caff.generics.Types#extract(java.util.Collection, java.lang.Iterable, java.lang.Class)}: returning predefined collection
- {@link de.caff.generics.Types#extract(java.util.Iterator, java.lang.Class)}: default return
- {@link de.caff.generics.Types#extract(java.util.Collection, java.util.Iterator, java.lang.Class)}: returning predefined collection
- {@link de.caff.generics.Types#extract(java.util.Enumeration, java.lang.Class)}: default return
- {@link de.caff.generics.Types#extract(java.util.Collection, java.util.Enumeration, java.lang.Class)}: returning predefined collection
-
Various collections and helper classes for using referenced values:
- {@link de.caff.generics.ReferenceCreator}: create references
- {@link de.caff.generics.References}: simple access to basic reference generators, see above
- {@link de.caff.generics.RefValueHashMap}: a hash map with references values
- {@link de.caff.generics.RefWrapperHashSet}: a hash set with referenced values
- {@link de.caff.generics.RefWrapperList}: a list with referenced values
- {@link de.caff.generics.SoftValueHashMap}: a hash map with softly referenced values
- {@link de.caff.generics.WeakValueHashMap}: a hash map with weakly referenced values
-
A wrapper to use an array as a list which does not copy the array as {@link java.util.Arrays#asList(Object[])} is doing:
{@link de.caff.generics.UnmodifiableListArrayWrapper}, but better use
- {@link de.caff.generics.Types#asList(Object[])}
- {@link de.caff.generics.Types#asList(Object[], int)}
- {@link de.caff.generics.Types#asList(Object[], int, int)}
Even better: these wrappers also exist for primitive arrays, e.g. arrays of int
s.
-
A {@link de.caff.generics.SynchronizedCollection copy on demand implementation of a synchronized collection}
which is easier to use compared to the one returned from {@link java.util.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 {@link de.caff.generics.WeakPropertyChangeListener property change listener which is referenced weakly} or
{@link de.caff.generics.SoftPropertyChangeListener softly}.
-
Support for matching, which is a generalization of the flawed equality concept provided by the
{@link java.lang.Object#equals(java.lang.Object)} method. See
- {@link de.caff.generics.Matcher the basic interface}
- {@link de.caff.generics.UniformMatcher a simplified interface for the most common case}
- the {@link de.caff.generics.matcher.Match} class which provides some basic matchers
-
various methods for checking equality (based on a matcher) for arrays, collections and similar:
- {@link de.caff.generics.Types#areEqual(java.util.Collection, java.util.Collection, java.util.function.BiPredicate)}
- {@link de.caff.generics.Types#areEqual(java.lang.Object[], java.lang.Object[], java.util.function.BiPredicate)}
- {@link de.caff.generics.Types#areEqual(java.lang.Iterable, java.lang.Iterable, java.util.function.BiPredicate)}
- {@link de.caff.generics.Types#areEqual(java.util.Iterator, java.util.Iterator, java.util.function.BiPredicate)}
- {@link de.caff.generics.Types#areEqual(java.util.Enumeration, java.util.Enumeration, java.util.function.BiPredicate)}