Uses of Interface
it.unimi.dsi.fastutil.BigList

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.
 



Copyright © 2011. All Rights Reserved.