|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use BigList | |
---|---|
it.unimi.dsi.fastutil | |
it.unimi.dsi.fastutil.booleans | Provides type-specific classes for boolean elements or keys. |
it.unimi.dsi.fastutil.bytes | Provides type-specific classes for byte elements or keys. |
it.unimi.dsi.fastutil.chars | Provides type-specific classes for character elements or keys. |
it.unimi.dsi.fastutil.doubles | Provides type-specific classes for double elements or keys. |
it.unimi.dsi.fastutil.floats | Provides type-specific classes for float elements or keys. |
it.unimi.dsi.fastutil.ints | Provides type-specific classes for integer elements or keys. |
it.unimi.dsi.fastutil.longs | Provides type-specific classes for long elements or keys. |
it.unimi.dsi.fastutil.objects | Provides type-specific classes for object elements or keys. |
it.unimi.dsi.fastutil.shorts | Provides type-specific classes for short elements or keys. |
Uses of BigList in it.unimi.dsi.fastutil |
---|
Methods in it.unimi.dsi.fastutil that return BigList | |
---|---|
BigList<K> |
BigList.subList(long from,
long to)
Returns a big sublist view of this big list. |
Uses of BigList in it.unimi.dsi.fastutil.booleans |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.booleans | |
---|---|
interface |
BooleanBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.booleans that implement BigList | |
---|---|
class |
AbstractBooleanBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractBooleanBigList.BooleanSubList
|
class |
BooleanBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
BooleanBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
BooleanBigLists.ListBigList
A class exposing a list as a big list. |
static class |
BooleanBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
BooleanBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
BooleanBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.booleans with parameters of type BigList | |
---|---|
int |
AbstractBooleanBigList.compareTo(BigList<? extends Boolean> l)
Compares this big list to another object. |
int |
BooleanBigLists.EmptyBigList.compareTo(BigList<? extends Boolean> o)
|
int |
BooleanBigLists.SynchronizedBigList.compareTo(BigList<? extends Boolean> o)
|
int |
BooleanBigLists.UnmodifiableBigList.compareTo(BigList<? extends Boolean> o)
|
Uses of BigList in it.unimi.dsi.fastutil.bytes |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.bytes | |
---|---|
interface |
ByteBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.bytes that implement BigList | |
---|---|
class |
AbstractByteBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractByteBigList.ByteSubList
|
class |
ByteBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
ByteBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
ByteBigLists.ListBigList
A class exposing a list as a big list. |
static class |
ByteBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
ByteBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
ByteBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.bytes with parameters of type BigList | |
---|---|
int |
ByteBigLists.EmptyBigList.compareTo(BigList<? extends Byte> o)
|
int |
ByteBigLists.SynchronizedBigList.compareTo(BigList<? extends Byte> o)
|
int |
ByteBigLists.UnmodifiableBigList.compareTo(BigList<? extends Byte> o)
|
int |
AbstractByteBigList.compareTo(BigList<? extends Byte> l)
Compares this big list to another object. |
Uses of BigList in it.unimi.dsi.fastutil.chars |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.chars | |
---|---|
interface |
CharBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.chars that implement BigList | |
---|---|
class |
AbstractCharBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractCharBigList.CharSubList
|
class |
CharBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
CharBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
CharBigLists.ListBigList
A class exposing a list as a big list. |
static class |
CharBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
CharBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
CharBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.chars with parameters of type BigList | |
---|---|
int |
AbstractCharBigList.compareTo(BigList<? extends Character> l)
Compares this big list to another object. |
int |
CharBigLists.EmptyBigList.compareTo(BigList<? extends Character> o)
|
int |
CharBigLists.SynchronizedBigList.compareTo(BigList<? extends Character> o)
|
int |
CharBigLists.UnmodifiableBigList.compareTo(BigList<? extends Character> o)
|
Uses of BigList in it.unimi.dsi.fastutil.doubles |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.doubles | |
---|---|
interface |
DoubleBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.doubles that implement BigList | |
---|---|
class |
AbstractDoubleBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractDoubleBigList.DoubleSubList
|
class |
DoubleBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
DoubleBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
DoubleBigLists.ListBigList
A class exposing a list as a big list. |
static class |
DoubleBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
DoubleBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
DoubleBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.doubles with parameters of type BigList | |
---|---|
int |
AbstractDoubleBigList.compareTo(BigList<? extends Double> l)
Compares this big list to another object. |
int |
DoubleBigLists.EmptyBigList.compareTo(BigList<? extends Double> o)
|
int |
DoubleBigLists.SynchronizedBigList.compareTo(BigList<? extends Double> o)
|
int |
DoubleBigLists.UnmodifiableBigList.compareTo(BigList<? extends Double> o)
|
Uses of BigList in it.unimi.dsi.fastutil.floats |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.floats | |
---|---|
interface |
FloatBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.floats that implement BigList | |
---|---|
class |
AbstractFloatBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractFloatBigList.FloatSubList
|
class |
FloatBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
FloatBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
FloatBigLists.ListBigList
A class exposing a list as a big list. |
static class |
FloatBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
FloatBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
FloatBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.floats with parameters of type BigList | |
---|---|
int |
FloatBigLists.EmptyBigList.compareTo(BigList<? extends Float> o)
|
int |
FloatBigLists.SynchronizedBigList.compareTo(BigList<? extends Float> o)
|
int |
FloatBigLists.UnmodifiableBigList.compareTo(BigList<? extends Float> o)
|
int |
AbstractFloatBigList.compareTo(BigList<? extends Float> l)
Compares this big list to another object. |
Uses of BigList in it.unimi.dsi.fastutil.ints |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.ints | |
---|---|
interface |
IntBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.ints that implement BigList | |
---|---|
class |
AbstractIntBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractIntBigList.IntSubList
|
class |
IntBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
IntBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
IntBigLists.ListBigList
A class exposing a list as a big list. |
static class |
IntBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
IntBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
IntBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.ints with parameters of type BigList | |
---|---|
int |
IntBigLists.EmptyBigList.compareTo(BigList<? extends Integer> o)
|
int |
IntBigLists.SynchronizedBigList.compareTo(BigList<? extends Integer> o)
|
int |
IntBigLists.UnmodifiableBigList.compareTo(BigList<? extends Integer> o)
|
int |
AbstractIntBigList.compareTo(BigList<? extends Integer> l)
Compares this big list to another object. |
Uses of BigList in it.unimi.dsi.fastutil.longs |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.longs | |
---|---|
interface |
LongBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.longs that implement BigList | |
---|---|
class |
AbstractLongBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractLongBigList.LongSubList
|
class |
LongBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
LongBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
LongBigLists.ListBigList
A class exposing a list as a big list. |
static class |
LongBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
LongBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
LongBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.longs with parameters of type BigList | |
---|---|
int |
AbstractLongBigList.compareTo(BigList<? extends Long> l)
Compares this big list to another object. |
int |
LongBigLists.EmptyBigList.compareTo(BigList<? extends Long> o)
|
int |
LongBigLists.SynchronizedBigList.compareTo(BigList<? extends Long> o)
|
int |
LongBigLists.UnmodifiableBigList.compareTo(BigList<? extends Long> o)
|
Uses of BigList in it.unimi.dsi.fastutil.objects |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.objects | |
---|---|
interface |
ObjectBigList<K>
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
interface |
ReferenceBigList<K>
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.objects that implement BigList | |
---|---|
class |
AbstractObjectBigList<K>
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractObjectBigList.ObjectSubList<K>
|
class |
AbstractReferenceBigList<K>
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractReferenceBigList.ReferenceSubList<K>
|
class |
ObjectBigArrayBigList<K>
A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
ObjectBigLists.EmptyBigList<K>
An immutable class representing an empty type-specific big list. |
static class |
ObjectBigLists.ListBigList<K>
A class exposing a list as a big list. |
static class |
ObjectBigLists.Singleton<K>
An immutable class representing a type-specific singleton big list. |
static class |
ObjectBigLists.SynchronizedBigList<K>
A synchronized wrapper class for big lists. |
static class |
ObjectBigLists.UnmodifiableBigList<K>
An unmodifiable wrapper class for big lists. |
class |
ReferenceBigArrayBigList<K>
A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
ReferenceBigLists.EmptyBigList<K>
An immutable class representing an empty type-specific big list. |
static class |
ReferenceBigLists.ListBigList<K>
A class exposing a list as a big list. |
static class |
ReferenceBigLists.Singleton<K>
An immutable class representing a type-specific singleton big list. |
static class |
ReferenceBigLists.SynchronizedBigList<K>
A synchronized wrapper class for big lists. |
static class |
ReferenceBigLists.UnmodifiableBigList<K>
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.objects with parameters of type BigList | |
---|---|
int |
ReferenceBigLists.EmptyBigList.compareTo(BigList<? extends K> o)
|
int |
ObjectBigLists.EmptyBigList.compareTo(BigList<? extends K> o)
|
int |
ObjectBigLists.SynchronizedBigList.compareTo(BigList<? extends K> o)
|
int |
ObjectBigLists.UnmodifiableBigList.compareTo(BigList<? extends K> o)
|
int |
AbstractObjectBigList.compareTo(BigList<? extends K> l)
Compares this big list to another object. |
Uses of BigList in it.unimi.dsi.fastutil.shorts |
---|
Subinterfaces of BigList in it.unimi.dsi.fastutil.shorts | |
---|---|
interface |
ShortBigList
A type-specific BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.shorts that implement BigList | |
---|---|
class |
AbstractShortBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractShortBigList.ShortSubList
|
class |
ShortBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing. |
static class |
ShortBigLists.EmptyBigList
An immutable class representing an empty type-specific big list. |
static class |
ShortBigLists.ListBigList
A class exposing a list as a big list. |
static class |
ShortBigLists.Singleton
An immutable class representing a type-specific singleton big list. |
static class |
ShortBigLists.SynchronizedBigList
A synchronized wrapper class for big lists. |
static class |
ShortBigLists.UnmodifiableBigList
An unmodifiable wrapper class for big lists. |
Methods in it.unimi.dsi.fastutil.shorts with parameters of type BigList | |
---|---|
int |
ShortBigLists.EmptyBigList.compareTo(BigList<? extends Short> o)
|
int |
ShortBigLists.SynchronizedBigList.compareTo(BigList<? extends Short> o)
|
int |
ShortBigLists.UnmodifiableBigList.compareTo(BigList<? extends Short> o)
|
int |
AbstractShortBigList.compareTo(BigList<? extends Short> l)
Compares this big list to another object. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |