| Home >> All >> org >> apache >> commons >> [ collections Javadoc ] |
Page 1 2
• org.apache.commons.collections: Javadoc index of package org.apache.commons.collections.
Package Samples:
• org.apache.commons.collections.keyvalue: This package contains the interfaces and utilities shared across all the subpackages of this component.
• org.apache.commons.collections.iterators: Java Collections Framework extensions.
• org.apache.commons.collections.list
• org.apache.commons.collections.buffer
• org.apache.commons.collections.map
• org.apache.commons.collections.functors
• org.apache.commons.collections.collection
• org.apache.commons.collections.bag
• org.apache.commons.collections.bidimap
• org.apache.commons.collections.comparators
Classes:
• AbstractTestMap: Abstract test class for java.util.Map methods and contracts. The forces at work here are similar to those in org.apache.commons.collections.collection.AbstractTestCollection . If your class implements the full Map interface, including optional operations, simply extend this class, and implement the makeEmptyMap() 55 method. On the other hand, if your map implementation is weird, you may have to override one or more of the other protected methods. They're described below. Entry Population Methods Override these methods if your map requires special entries: getSampleKeys() 55 getSampleValues() 55 ...
• AbstractTestCollection: Abstract test class for java.util.Collection methods and contracts. You should create a concrete subclass of this class to test any custom java.util.Collection implementation. At minimum, you'll have to implement the makeCollection() 55 method. You might want to override some of the additional public methods as well: Element Population Methods Override these if your collection restricts what kind of elements are allowed (for instance, if null is not permitted): getFullElements() 55 getOtherElements() 55 Supported Operation Methods Override these if your collection doesn't support certain operations: ...
• TestCollection: Tests base java.util.Collection methods and contracts. You should create a concrete subclass of this class to test any custom java.util.Collection implementation. At minimum, you'll have to implement the makeCollection() 55 method. You might want to override some of the additional protected methods as well: Element Population Methods Override these if your collection restricts what kind of elements are allowed (for instance, if null is not permitted): getFullElements() 55 getOtherElements() 55 Supported Operation Methods Override these if your collection doesn't support certain operations: #isAddSuppoted() ...
• TestMap: Tests base java.util.Map methods and contracts. The forces at work here are similar to those in TestCollection . If your class implements the full Map interface, including optional operations, simply extend this class, and implement the makeEmptyMap() 55 method. On the other hand, if your map implemenation is wierd, you may have to override one or more of the other protected methods. They're described below. Entry Population Methods Override these methods if your map requires special entries: getSampleKeys() 55 getSampleValues() 55 getNewSampleValues() 55 getOtherKeys() 55 getOtherValues() 55 Supported ...
• StaticBucketMap: A StaticBucketMap is an efficient, thread-safe implementation of java.util.Map that performs well in in a highly thread-contentious environment. The map supports very efficient get 55 , put 55 , remove 55 and containsKey 55 operations, assuming (approximate) uniform hashing and that the number of entries does not exceed the number of buckets. If the number of entries exceeds the number of buckets or if the hash codes of the objects are not uniformly distributed, these operations have a worst case scenario that is proportional to the number of elements in the map ( O(n) ). Each bucket in the hash ...
• StaticBucketMap: A StaticBucketMap is an efficient, thread-safe implementation of java.util.Map that performs well in in a highly thread-contentious environment. The map supports very efficient get 55 , put 55 , remove 55 and containsKey 55 operations, assuming (approximate) uniform hashing and that the number of entries does not exceed the number of buckets. If the number of entries exceeds the number of buckets or if the hashcodes of the objects are not uniformly distributed, these operations have a worst case scenario that is proportional to the number of elements in the map ( O(n) ). Each bucket in the hash ...
• BulkTest: A junit.framework.TestCase that can define both simple and bulk test methods. A simple test method is the type of test traditionally supplied by by junit.framework.TestCase . To define a simple test, create a public no-argument method whose name starts with "test". You can specify the the name of simple test in the constructor of BulkTest ; a subsequent call to TestCase.run() > TestCase.run() 55 will run that simple test. A bulk test method , on the other hand, returns a new instance of BulkTest , which can itself define new simple and bulk test methods. By using the makeSuite(java.lang.Class) ...
• DoubleOrderedMap: Red-Black tree-based implementation of Map. This class guarantees that the map will be in both ascending key order and ascending value order, sorted according to the natural order for the key's and value's classes. This Map is intended for applications that need to be able to look up a key-value pairing by either key or value, and need to do so with equal efficiency. While that goal could be accomplished by taking a pair of TreeMaps and redirecting requests to the appropriate TreeMap (e.g., containsKey would be directed to the TreeMap that maps values to keys, containsValue would be directed to ...
• ExtendedProperties: This class extends normal Java properties by adding the possibility to use the same key many times concatenating the value strings instead of overwriting them. The Extended Properties syntax is explained here: Each property has the syntax key = value The key may use any character but the equal sign '='. value may be separated on different lines if a backslash is placed at the end of the line that continues below. If value is a list of strings, each token is separated by a comma ','. Commas in each token are escaped placing a backslash right before the comma. If a key is used more than once, the ...
• AbstractReferenceMap: An abstract implementation of a hash-based map that allows the entries to be removed by the garbage collector. This class implements all the features necessary for a subclass reference hash-based map. Key-value entries are stored in instances of the ReferenceEntry class which can be overridden and replaced. The iterators can similarly be replaced, without the need to replace the KeySet, EntrySet and Values view classes. Overridable methods are provided to change the default hashing behaviour, and to change how entries are added to and removed from the map. Hopefully, all you need for unusual subclasses ...
• ReferenceMap: A Map implementation that allows mappings to be removed by the garbage collector. When you construct a ReferenceMap , you can specify what kind of references are used to store the map's keys and values. If non-hard references are used, then the garbage collector can remove mappings if a key or value becomes unreachable, or if the JVM's memory is running low. For information on how the different reference types behave, see Reference . Different types of references can be specified for keys and values. The keys can be configured to be weak but the values hard, in which case this class will behave ...
• MultiKeyMap: A Map implementation that uses multiple keys to map the value. This class is the most efficient way to uses multiple keys to map to a value. The best way to use this class is via the additional map-style methods. These provide get , containsKey , put and remove for individual keys which operate without extra object creation. The additional methods are the main interface of this map. As such, you will not normally hold this map in a variable of type Map . The normal map methods take in and return a org.apache.commons.collections.keyvalue.MultiKey . If you try to use put() with any other object type ...
• PriorityBuffer: Binary heap implementation of Buffer that provides for removal based on Comparator ordering. The removal order of a binary heap is based on either the natural sort order of its elements or a specified java.util.Comparator . The remove() 55 method always returns the first element as determined by the sort order. (The ascendingOrder flag in the constructors can be used to reverse the sort order, in which case remove() 55 will always remove the last element.) The removal order is not the same as the order of iteration; elements are returned by the iterator in no particular order. The add(Object) 55 ...
• TreeBidiMap: Red-Black tree-based implementation of BidiMap where all objects added implement the Comparable interface. This class guarantees that the map will be in both ascending key order and ascending value order, sorted according to the natural order for the key's and value's classes. This Map is intended for applications that need to be able to look up a key-value pairing by either key or value, and need to do so with equal efficiency. While that goal could be accomplished by taking a pair of TreeMaps and redirecting requests to the appropriate TreeMap (e.g., containsKey would be directed to the TreeMap ...
• ReferenceMap: Hashtable-based java.util.Map implementation that allows mappings to be removed by the garbage collector. When you construct a ReferenceMap , you can specify what kind of references are used to store the map's keys and values. If non-hard references are used, then the garbage collector can remove mappings if a key or value becomes unreachable, or if the JVM's memory is running low. For information on how the different reference types behave, see java.lang.ref.Reference . Different types of references can be specified for keys and values. The keys can be configured to be weak but the values hard, ...
• BinaryHeap: Binary heap implementation of PriorityQueue and Buffer . The removal order of a binary heap is based on either the natural sort order of its elements or a specified java.util.Comparator . The remove() 55 method always returns the first element as determined by the sort order. (The isMinHeap flag in the constructors can be used to reverse the sort order, in which case remove() 55 will always remove the last element.) The removal order is not the same as the order of iteration; elements are returned by the iterator in no particular order. The add(Object) 55 and remove() 55 operations perform in logarithmic ...
• ReferenceIdentityMap: A Map implementation that allows mappings to be removed by the garbage collector and matches keys and values based on == not equals() . When you construct a ReferenceIdentityMap , you can specify what kind of references are used to store the map's keys and values. If non-hard references are used, then the garbage collector can remove mappings if a key or value becomes unreachable, or if the JVM's memory is running low. For information on how the different reference types behave, see java.lang.ref.Reference . Different types of references can be specified for keys and values. The default constructor ...
• FastArrayList: A customized implementation of java.util.ArrayList designed to operate in a multithreaded environment where the large majority of method calls are read-only, instead of structural changes. When operating in "fast" mode, read calls are non-synchronized and write calls perform the following steps: Clone the existing collection Perform the modification on the clone Replace the existing collection with the (modified) clone When first created, objects of this class default to "slow" mode, where all accesses of any type are synchronized but no cloning takes place. This is appropriate for initially populating ...
• ObjectGraphIterator: An Iterator that can traverse multiple iterators down an object graph. This iterator can extract multiple objects from a complex tree-like object graph. The iteration starts from a single root object. It uses a Transformer to extract the iterators and elements. Its main benefit is that no intermediate List is created. For example, consider an object graph: |- Branch -- Leaf | \- Leaf |- Tree | /- Leaf | |- Branch -- Leaf Forest | \- Leaf | |- Branch -- Leaf | | \- Leaf |- Tree | /- Leaf |- Branch -- Leaf |- Branch -- Leaf The following Transformer , used in this class, will extract all the Leaf ...
• FastHashMap: A customized implementation of java.util.HashMap designed to operate in a multithreaded environment where the large majority of method calls are read-only, instead of structural changes. When operating in "fast" mode, read calls are non-synchronized and write calls perform the following steps: Clone the existing collection Perform the modification on the clone Replace the existing collection with the (modified) clone When first created, objects of this class default to "slow" mode, where all accesses of any type are synchronized but no cloning takes place. This is appropriate for initially populating ...
• FastTreeMap: A customized implementation of java.util.TreeMap designed to operate in a multithreaded environment where the large majority of method calls are read-only, instead of structural changes. When operating in "fast" mode, read calls are non-synchronized and write calls perform the following steps: Clone the existing collection Perform the modification on the clone Replace the existing collection with the (modified) clone When first created, objects of this class default to "slow" mode, where all accesses of any type are synchronized but no cloning takes place. This is appropriate for initially populating ...
• CursorableLinkedList: A List implementation with a ListIterator that allows concurrent modifications to the underlying list. This implementation supports all of the optional java.util.List operations. It extends AbstractLinkedList and thus provides the stack/queue/dequeue operations available in java.util.LinkedList . The main feature of this class is the ability to modify the list and the iterator at the same time. Both the listIterator() 55 and cursor() 55 methods provides access to a Cursor instance which extends ListIterator . The cursor allows changes to the list concurrent with changes to the iterator. Note that ...
• MapUtils: A helper class for using Map instances. It contains various typesafe methods as well as other useful features like deep copying. It also provides the following decorators: fixedSizeMap(Map) 55 fixedSizeSortedMap(SortedMap) 55 lazyMap(Map,Factory) 55 lazySortedMap(SortedMap,Factory) 55 predicatedMap(Map,Predicate,Predicate) 55 predicatedSortedMap(SortedMap,Predicate,Predicate) 55
• AbstractLinkedMap: An abstract implementation of a hash-based map that links entries to create an ordered map and which provides numerous points for subclasses to override. This class implements all the features necessary for a subclass linked hash-based map. Key-value entries are stored in instances of the LinkEntry class which can be overridden and replaced. The iterators can similarly be replaced, without the need to replace the KeySet, EntrySet and Values view classes. Overridable methods are provided to change the default hashing behaviour, and to change how entries are added to and removed from the map. Hopefully, ...
• UnboundedFifoBuffer: UnboundedFifoBuffer is a very efficient buffer implementation. According to performance testing, it exhibits a constant access time, but it also outperforms ArrayList when used for the same purpose. The removal order of an UnboundedFifoBuffer is based on the insertion order; elements are removed in the same order in which they were added. The iteration order is the same as the removal order. The remove() 55 and get() 55 operations perform in constant time. The add(Object) 55 operation performs in amortized constant time. All other operations perform in linear time or worse. Note that this implementation ...
| Home | Contact Us | Privacy Policy | Terms of Service |