All Classes and Interfaces
Class
Description
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
T item to it.Indicates that a type can have its contents change position, without specifying the type of contents.
An empty interface that merges Arrangeable and java.util.List APIs.
A binary heap that stores nodes which each have a float value and are sorted either lowest first or highest first.
A binary heap node.
A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
boolean item to it.An unordered List of boolean items.
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order (false then true)
A type-specific comparator mimicking the opposite of the natural order (the opposite being true then false).
A resizable, insertion-ordered double-ended queue of primitive
boolean with efficient add and remove at the
beginning and end.A
BooleanIterator over the elements of a BooleanDeque.An Iterator specialized for
boolean values.A resizable, insertion-ordered boolean list.
A
BooleanIterator, plus ListIterator methods, over the elements of a BooleanList.A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
byte item to it.An unordered List of byte items.
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A type-specific comparator that compares items in the natural order, but as if they are unsigned
(so, all negative items are greater than any non-negative items).
A type-specific comparator that compares items in the opposite of the natural order, but as if they
are unsigned.
A resizable, insertion-ordered double-ended queue of primitive
byte with efficient add and remove at the
beginning and end.A
ByteIterator over the elements of a ByteDeque.An Iterator specialized for
byte values.A resizable, insertion-ordered byte list.
A
ByteIterator, plus ListIterator methods, over the elements of a ByteList.A custom variant on ObjectObjectMap that always uses CharSequence keys and compares them as case-insensitive.
A custom variant on ObjectObjectOrderedMap that always uses CharSequence keys and compares them as case-insensitive.
A custom variant on ObjectOrderedSet that always uses CharSequence keys and compares them as case-insensitive.
A custom variant on ObjectSet that always uses CharSequence keys and compares them as case-insensitive.
This mostly-internal class only exists to help case-insensitive comparisons and hashing.
A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
byte item to it.An unordered List of char items.
A bit set, which can be seen as a set of char positions in the Unicode Basic Multilingual Plane (the first
65536 chars in Unicode).
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A resizable, insertion-ordered double-ended queue of primitive
char with efficient add and remove at the
beginning and end.A
CharIterator over the elements of a CharDeque.A small class that holds two functional-interface values used for filtering and editing characters, and a name they
are associated with.
An Iterator specialized for
char values.A resizable, insertion-ordered char list.
A
CharIterator, plus ListIterator methods, over the elements of a CharList.Predefined CharPredicate tests that will work identically on all target platforms.
A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
double item to it.An unordered List of double items.
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A resizable, insertion-ordered double-ended queue of primitive
double with efficient add and remove at the
beginning and end.A
DoubleIterator over the elements of a DoubleDeque.An Iterator specialized for
double values.A resizable, insertion-ordered double list.
A
DoubleIterator, plus ListIterator methods, over the elements of a DoubleList.Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Wraps an Iterator so that it calls a function on each item it would otherwise return, and returns that function's
result.
Augments
Collection with default methods that can usually use the same implementation across subtypes.An unordered map where the keys are
Enums and values are primitive floats.An insertion-ordered map where the keys are
Enums and values are primitive floats.An unordered map where the keys are
Enums and values are primitive ints.An insertion-ordered map where the keys are
Enums and values are primitive ints.An unordered map where the keys are
Enums and values are primitive longs.An insertion-ordered map where the keys are
Enums and values are primitive longs.An unordered map where the keys are
Enums and values are objects.An
EnumMap that also stores keys in an ObjectList using the insertion order.An
EnumSet that also stores keys in an ObjectList using the insertion order.A naturally-ordered Set of Enum items.
Produces
Comparators that can sort Strings and Collections while filtering out chars/items that don't match a predicate,
and/or altering chars/items when they are compared.A customizable variant on ObjectMap that uses Iterable keys made of K sub-keys, and only considers a sub-key (for
equality and hashing purposes) if that sub-key satisfies a predicate.
A customizable variant on ObjectMap that uses Iterable keys made of K sub-keys, and only considers a sub-key (for
equality and hashing purposes) if that sub-key satisfies a predicate.
A customizable variant on ObjectOrderedSet that uses Iterable items made of T sub-items, and only considers a sub-item (for
equality and hashing purposes) if that sub-item satisfies a predicate.
A customizable variant on ObjectSet that uses Iterable items made of T sub-items, and only considers a sub-item (for
equality and hashing purposes) if that sub-item satisfies a predicate.
A custom variant on ObjectObjectMap that always uses String keys, but only considers any character in an item (for
equality and hashing purposes) if that character satisfies a predicate.
A custom variant on ObjectObjectOrderedMap that always uses String keys, but only considers any character in an item (for
equality and hashing purposes) if that character satisfies a predicate.
A customizable variant on ObjectOrderedSet that always uses String keys, but only considers any character in an item
(for equality and hashing purposes) if that character satisfies a predicate.
A customizable variant on ObjectSet that always uses String keys, but only considers any character in an item (for
equality and hashing purposes) if that character satisfies a predicate.
Wraps a BooleanIterator so that it skips any items for which
FilteringBooleanIterator.filter returns false.Wraps a ByteIterator so that it skips any items for which
FilteringByteIterator.filter returns false.Wraps a CharIterator so that it skips any items for which
FilteringCharIterator.filter returns false.Wraps a DoubleIterator so that it skips any items for which
FilteringDoubleIterator.filter returns false.Wraps a FloatIterator so that it skips any items for which
FilteringFloatIterator.filter returns false.Wraps a IntIterator so that it skips any items for which
FilteringIntIterator.filter returns false.Wraps an Iterator so that it skips any items for which
FilteringIterator.filter returns false.Wraps a LongIterator so that it skips any items for which
FilteringLongIterator.filter returns false.Wraps a ShortIterator so that it skips any items for which
FilteringShortIterator.filter returns false.A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
float item to it.An unordered List of float items.
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A resizable, insertion-ordered double-ended queue of primitive
float with efficient add and remove at the
beginning and end.A
FloatIterator over the elements of a FloatDeque.An Iterator specialized for
float values.A resizable, insertion-ordered float list.
A
FloatIterator, plus ListIterator methods, over the elements of a FloatList.A
HolderSet that also stores items in an ObjectList using the insertion order.An unordered set where the items are objects but access to items is done with a specific key component
held by each item, and the component is extracted from an item by a given Function.
A variant on
ObjectObjectMap that compares keys by identity (using ==) instead of equality (using equals()).A variant on
ObjectObjectOrderedMap that compares keys by identity (using ==) instead of equality (using equals()}).A variant on
ObjectOrderedSet that compares items by identity (using ==) instead of equality (using equals()).A variant on
ObjectSet that compares items by identity (using ==) instead of equality (using equals()).A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
an
int item to it.An unordered List of int items.
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A type-specific comparator that compares items in the natural order, but as if they are unsigned
(so, all negative items are greater than any non-negative items).
A type-specific comparator that compares items in the opposite of the natural order, but as if they
are unsigned.
A resizable, insertion-ordered double-ended queue of primitive
int with efficient add and remove at the
beginning and end.A
IntIterator over the elements of an IntDeque.An unordered map where the keys are unboxed ints and the values are unboxed floats.
An
IntFloatMap that also stores keys in an IntList using the insertion order.An unordered map where the keys are unboxed ints and the values are also unboxed ints.
An Iterator specialized for
int values.A resizable, insertion-ordered int list.
A
IntIterator, plus ListIterator methods, over the elements of a IntList.An unordered map where the keys are unboxed ints and the values are unboxed longs.
An
IntLongMap that also stores keys in an IntList using the insertion order.An unordered map where the keys are unboxed ints and the values are objects.
An
IntObjectMap that also stores keys in an IntList using the insertion order.An unordered set where the items are unboxed ints.
Takes one or more Terms and matches if all of those Terms match.
Takes one or more Terms and matches if any of those Terms match.
Simply matches a single
T value, with no additional Terms involved.Takes a Term and treats a case where it matches or doesn't match as the opposite.
Takes one or more Terms and matches if exactly one of those Terms matches.
Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingBooleanIterator.nextBoolean().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingByteIterator.nextByte().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingCharIterator.nextChar().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingDoubleIterator.nextDouble().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingFloatIterator.nextFloat().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingIntIterator.nextInt().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingIterator.next().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingLongIterator.nextLong().Wraps an Iterator so that it only returns at most a specific amount of items (defined by calls to
LimitingShortIterator.nextShort().A combination List/Deque with some expanded features based on Deque's mix of exceptional and non-exceptional methods.
A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
long item to it.An unordered List of long items.
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A type-specific comparator that compares items in the natural order, but as if they are unsigned
(so, all negative items are greater than any non-negative items).
A type-specific comparator that compares items in the opposite of the natural order, but as if they
are unsigned.
A resizable, insertion-ordered double-ended queue of primitive
long with efficient add and remove at the
beginning and end.A
LongIterator over the elements of a LongDeque.An unordered map where the keys are unboxed longs and the values are unboxed floats.
A
LongFloatMap that also stores keys in a LongList using the insertion order.An unordered map where the keys are unboxed longs and the values are unboxed ints.
A
LongIntMap that also stores keys in a LongList using the insertion order.An Iterator specialized for
long values.A resizable, insertion-ordered long list.
A
LongIterator, plus ListIterator methods, over the elements of a LongList.An unordered map where the keys are unboxed longs and the values are also unboxed longs.
A
LongLongMap that also stores keys in a LongList using the insertion order.An unordered map where the keys are unboxed longs and the values are objects.
A
LongObjectMap that also stores keys in an LongList using the insertion order.An unordered set where the items are unboxed longs.
A Comparator that can sort Strings, StringBuilders, and other CharSequences by "natural text order," also called
Alphanum sort order.
An Ordered Set of
T items where the NumberedSet.indexOf(Object) operation runs in constant time, but
any removal from the middle of the order runs in linear time.An unordered List of T items.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A resizable, insertion-ordered double-ended queue of objects with efficient add and remove at the beginning and end.
An unordered map where the keys are objects and the values are unboxed floats.
An
ObjectFloatMap that also stores keys in an ObjectList using the insertion order.An unordered map where the keys are objects and the values are unboxed ints.
An
ObjectIntMap that also stores keys in an ObjectList using the insertion order.A resizable, insertion-ordered list of
T items, typically objects (they can also be arrays).An unordered map where the keys are objects and the values are unboxed longs.
An
ObjectLongMap that also stores keys in an ObjectList using the insertion order.An unordered map where the keys and values are objects.
An
ObjectObjectMap that also stores keys in an ObjectList using the insertion order.A
ObjectSet that also stores keys in an ObjectList using the insertion order.An unordered set where the keys are objects.
A bit set, which can be seen as a set of integer positions greater than some starting number,
that has changeable offset, or starting position.
Ensures that implementors allow access to the order of
T items as an ObjectList.A primitive specialization of
Ordered for collections of double values instead of objects.A primitive specialization of
Ordered for collections of float values instead of objects.A primitive specialization of
Ordered for collections of int values instead of objects.A primitive specialization of
Ordered for collections of long values instead of objects.Used to determine what class Ordered objects will use for their
Ordered.order() implementation.A functional interface to parse part of a String and obtain a
R instance as a result.Analogous to
Collection but for a primitive type, this is technically built around
Iterator, but should almost always use a primitive-specialized iterator such as
FloatIterator instead of the generic Iterator.A PrimitiveCollection with unboxed
boolean items.A PrimitiveCollection with unboxed
byte items.A PrimitiveCollection with unboxed
char items.A PrimitiveCollection with unboxed
double items.A PrimitiveCollection with unboxed
float items.A PrimitiveCollection with unboxed
int items.A PrimitiveCollection with unboxed
long items.A PrimitiveCollection with unboxed
short items.Analogous to
Set but for a primitive type, this extends PrimitiveCollection and the
nested classes here extend the nested classes in PrimitiveCollection.Implementation of Tony Hoare's quickselect algorithm.
This class is for selecting a ranked element (kth ordered statistic) from an unordered list in faster time than sorting the
whole array.
A functional interface that takes and returns an object that is a CharSequence and is Appendable, appending
a
short item to it.An unordered List of short items.
A type-specific
Comparator; provides methods to compare two primitive
types both as objects and as primitive types.A class providing static methods and objects that do useful things with
comparators.
A type-specific comparator mimicking the natural order.
A type-specific comparator mimicking the opposite of the natural order.
A type-specific comparator that compares items in the natural order, but as if they are unsigned
(so, all negative items are greater than any non-negative items).
A type-specific comparator that compares items in the opposite of the natural order, but as if they
are unsigned.
A resizable, insertion-ordered double-ended queue of primitive
short with efficient add and remove at the
beginning and end.A
ShortIterator over the elements of a ShortDeque.An Iterator specialized for
short values.A resizable, insertion-ordered short list.
A
ShortIterator, plus ListIterator methods, over the elements of a ShortList.Wraps a BooleanIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps a ByteIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps a CharIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps a DoubleIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps a FloatIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps an IntIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps an Iterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps a LongIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Wraps a ShortIterator so that it starts at an offset, skipping that many items, then returning items that match a given
stride, such as every other item, or every tenth item.
Mostly internal; describes part of a
Junction.Utility code shared by various data structures in this package.