Open Source Open Source Java Collections API written in Java

What is Collection API?

The Collection API is a set of classes and interfaces that support operation on collections of objects. These classes and interfaces are more flexible, more powerful, and more regular than the vectors, arrays, and hashtables if effectively replaces. 

Example of classes: HashSet, HashMap, ArrayList,
LinkedList, TreeSet and TreeMap.

Example of interfaces: Collection, Set, List
and Map.

• Commons Collections - The Java Collections Framework was a major addition in JDK 1.2. It added many powerful data structures that accelerate development of most significant Java applications. Since that time it has become the recognised standard for collection handling in Java.
  
  Commons-Collections seek to build upon the JDK classes by providing new interfaces, implementations and utilities. There are many features, including:
  
  Bag interface for collections that have a number of copies of each object
  Buffer interface for collections that have a well defined removal order, like FIFOs
  BidiMap interface for maps that can be looked up from value to key as well and key to value
  MapIterator interface to provide simple and quick iteration over maps
  Type checking decorators to ensure that only instances of a certain type can be added
  Transforming decorators that alter each object as it is added to the collection
  Composite collections that make multiple collections look like one
  Ordered maps and sets that retain the order elements are added in, including an LRU based map
  Identity map that compares objects based on their identity (==) instead of the equals method
  Reference map that allows keys and/or values to be garbage collected under close control
  Many comparator implementations
  Many iterator implementations
  Adapter classes from array and enumerations to collections
  Utilities to test or create typical set-theory properties of collections such as union, intersection, and closure
  
      
• Commons Primitives - Apache Jakarta Commons Primitives provides a collection of types and utilities optimized for working with Java primitives (boolean, byte, char, double, float, int, long, short). Generally, the Commons-Primitives classes are smaller, faster and easier to work with than their purely Object based alternatives.
  
  
      
• FastUtil - Fastutil extends the Java™ Collections Framework by providing type-specific maps, sets, lists and queues with a small memory footprint and fast access and insertion; it also includes a fast I/O API for binary and text files. It is free software distributed under the GNU Lesser General Public License.
  
  fastutil classes provide support for references, that is, objects that are compared using the equality operator rather than the equals() method.
  
      
• innig utilities - I am gradually factoring useful classes out of work I have done in the past, and am currently doing (such as Eidola and Macker). The result is this small collection of miscellaneous Java utilities, including a standard enumerated type base class, a TCP tunnel, a stream splitter, threading utilities, graph utilities, and several other generalizations / augmentations of the Java Collections API.
      
• Java utitities - This package contains Java utility classes designed to help you write Java programs. The classes cover diverse programming areas, including: specialized collections, networking, stream-based I/O, class and resource loading, JAR files and resources, concurrent processing, distributed processing, security, XML parsing, handling configuration files, Swing GUI, and memory management. Some of these classes are relatively simple, whereas some are substantial; some introduce new APIs and functionality while others workaround problems found in standard Java APIs.
  
  We used to develop these classes as needed for our specialized projects, such as rmix and h2o. Over time, we realized that these classes often have much more general applicability. Thus, we decided to organize them, document them, and make them available to the general public. Importantly, because of their origin, each one of the classes you find here solves some actual, real problem that we have encountered along the way in one of our projects.
  
  This package is an open-source research project of Distributed Computing Laboratory, Dept. of Math and Computer Science, Emory University. The research is supported in part by U.S. DoE grant DE-FG02-02ER25537 and NSF grant ACI-0220183.
  
  
      
• jga - jga is a functors library: the intent is to explore and exploit functors as a design and implementation tool to reduce boilerplate coding. A functor is an object that encapsulates a function or expression: it can take arguments and produce results, as can any method, expression, or function (in other languages that support functions). Unlike an expression, as an object it can be passed as an argument without being executed; it can be persisted to a database or file; it can be serialized and passed from client to server (and back); and it can be instantiated at runtime based on information unavailable at compile-time.
  
      
• Joda Primitives -

  Joda Primitives provides collections and utilities to bridge the gap between
  objects and primitive types in Java.

  
  

  Current interfaces and implementations include:

  
  
  
  
  • Collection
    
  • List
    
  • Iterator
    
  • ListIterator
  
  
  
  

  Each collection implementation stores the data as a primitive object. The
  interfaces provide dedicated methods to access those primitives. If you need a
  list of numbers or booleans, then these classes are ideal. A primitive
  collection uses less memory, performs more quickly and saves on garbage
  collection. All this is due to the fact that no Object wrapper class has to be
  created.

  
  

  This project is an offshoot of Commons
  Primitives. The two projects have very different designs. Commons Primitives
  defines interfaces independent of the JDK collection interfaces. Joda Primitives
  defines interfaces that extend the JDK collection interfaces. This project
  offers deeper direct integration, however this results in certain method names
  being different from JDK collections.

  
  

  Joda Primitives is licenced under the Joda
  licence, which is an Apache/BSD cloned licence.

  
  
      
• Mango - Mango is a Java library consisting of a number of iterators, algorithms and functions, loosely inspired by the C++ Standard Template Library.
  It is available under the terms of the Lesser GPL and is available for download in source and binary distributions
  
  Commons Collections and Mango have similar iterators and unary predicates, so perhaps the algorithms part would fit with them.
  
  
      
• MultiTreeMap - MultiTreeMap: A TreeMap that allows duplicate keys to be entered. Supports the java.util.Collections interface and an enhanced Iterator. Implemented by using a Red-Black Tree.
      
• PCJ - Primitive Collections for Java (PCJ) is a set of collection classes for primitive data types in Java. The goal is to provide an efficient alternative to the Java Collections Framework (JCF) when using primitive data types, such as int, boolean, or double. Some of its main features are:
  
  PCJ provides symmetrical interface hierarchy for each of the primitive Java data types: boolean, char, byte, short, int, long, float, and double. Each hierarchy includes interfaces for general collections, sets, lists, and maps. To increase the learning rate and make adaptions easier to implement, each hierarchy resembles the interfaces of JCF as close as possible.
  
      
• SecureCollection - SecureCollection is a Java class library tailored for big projects. SecureCollection provides a thin wrapper around the standard collection API to protect your app code from bugs and missing functionality. It features unit tests for all classes.
      
• tclib - The Java libraries included basic Hashtable, Stack and Vector collections classes from the beginning. With Java 2, the addition of the Collections Library increased the variety of collections dramatically, as well as offering improved performance in some areas. Even with the improved support in Java 2, though, there is still reason to use alternatives to the standard library classes for high-performance applications.
  
  
      
• Trove - The GNU Trove library has two objectives:
  
  Provide free (as in free speech and free beer), fast, lightweight implementations of the java.util Collections API. These implementations are designed to be pluggable replacements for their JDK equivalents.
  Whenever possible, provide the same collections support for primitive types. This gap in the JDK is often addressed by using the wrapper classes (java.lang.Integer, java.lang.Float, etc.) with Object-based collections. For most applications, however, collections which store primitives directly will require less space and yield significant performance gains.