• Transparent object recycling - No memory allocation, defragmentation or garbage collection ever.
• Configurable/Inheritable XML serialization/deserialization integrated with NIO framework.
• Runs on ALL Java platforms from the J2ME CLDC 1.0 to the latest J2EE 1.5
• Text manipulation several order of magnitude faster than using java.lang.String .
• Guaranteed response time. No internal table resize/copy ever performed and for threads running in PoolContext no garbage collection either.
• Low-level concurrency support.
• The fastest implementations of the most common interfaces (e.g. FastMap for java.util.Map interface).
• Free...

1. Objects can be allocated on the "stack" and transparently recycled. With Javolution, your application is busy doing the real work not memory management (e.g. Javolution RealtimeParser is 3-5x faster than conventional XML parsers only because it does not waste 2/3 of the CPU doing memory allocation/garbage collection).
   
2. Javolution classes are simple to use, even simpler than most JDK classes. For example, you don't need to guess the capacity of a TextBuilder or a FastList, their size expand gently without ever incurring expensive resize/copy operations (unlike standard classes such as StringBuffer or ArrayList ).
   
3. Javolution classes are fast, very fast... Text concatenations are several order of magnitude faster than concatenation using String and several times faster than concatenations using StringBuffer/StringBuilder (See benchmark).
   
4. Javolution runs on any platform from the simplest J2ME CLDC 1.0 with no garbage collector to the latest J2EE 1.5 Furthermore, Javolution provides an easy way for your application to implement the latest interfaces such as Serializable , Comparable , Appendable and still run on the J2ME CLDC 1.0 platform where these interfaces do not exist.
   
5. All Javolution classes are hard real-time compliant and have highly deterministic behavior (in the microsecond range). For applications based upon the Real-Time Specification for Java (RTSJ) all threads (including NoHeapRealtimeThread ) can run in ImmortalMemory and avoid memory clashes!
   
6. With Javolution, concurrent algorithms can take advantage of multi-processors systems in a transparent manner (ref. ConcurrentContext).
   
7. Any Java class can be serialized/deserialized in XML format in any form you may want (no need to implement Serializable or for the platform to support serialization)!
   
8. Using the Javolution Struct and Union base classes, your code can directly share information with C/C++ native applications.
   
9. Javolution provides the fastest implementation of the latest interfaces and gets better and faster every day.
   
10. Javolution is a pure Java Solution (no native code), small (less than 200 KBytes jar file) and free; permission to use, copy, modify, and distribute this software is freely granted, provided that copyright notices are preserved.

• Real-time framework:
  • Objects can be allocated on the "stack" to avoid garbage collection.
  • Faster code executions by reusing stack/pool objects instead of creating new objects.
  • Easier concurrent programming in low level methods with no thread creation overhead.
• Supports for the encoding of objects into XML; and the complementary reconstruction of the object graph from XML (xml package).
• XML parsing with no String allocation! It allows our RealtimeParser to run several times faster than conventional SAX2 parsers.
• Provides all the latest (JDK1.5) interfaces and exceptions for:
  • java.lang (e.g CharSequence, Appendable, Cloneable, Comparable ...)
  • java.io (e.g Serializable, Flushable ...)
  • java.util (e.g List, Map, Set, Formattable ...)
  This classes are in the j2me package (to avoid bootclasspath). It allows j2me applications to implement the latest j2se interfaces and integrate with a j2se framework through a simple rename (j2me. to java.)
• Real-time implementations of Map, List and Set.
• Struct and Union classes for direct interoperability with C/C++ applications.
• Reflection utility class. Any method or constructor can be dynamically invoked using its signature represented as a String .
• Text class, an improved version of java.lang.String with amazingly fast concatenation speed (faster than using StringBuffer ). Also, unlike java.lang.String , the Text class in not plagued by the substring memory leak bug!
• Appendable character sequence TextBuilder same operations as StringBuffer / StringBuilder , but no capacity to specify and no resize/copy operations ever.
• Utility class TypeFormat to parse any CharSequence into primitive types, and format any primitive type into an Appendable (up to 15x faster than the standard parsing/formatting utilities).
• Miscellaneous UTF-8 readers/writers, math functions, locks, etc...

java -jar javolution.jar version (shows version information)
java -jar javolution.jar test (performs self-tests)
java -jar javolution.jar perf (runs benchmark)

• Performance comparison of XML-Java bindings
  (January 2005, Javolution ranked #1 overall)
• Turbo-Charging Java for Real-Time Applications
  (July 2004 issue of Java Developer Journal)
• J.A.D.E. XML support, published in the 2001 February issue of Dr Dobb's Journal.

• JScience
• JMulTi - Time Series Analysis with Java.
• JStatCom - A Software Framework for Data Based Analysis.

• January 25, 2005: Javolution 2.2.4
  TextFormat enhancements [2.2.4]
  All collection classes implement Serializable [2.2.3]
  Automatic detection of poorly distributed system hash code (see FastMap) [2.2.2]
  Documentation update [2.2.1]
  Modified xml serialization to generate SAX events for cocoon (see ObjectWriter) [2.2.0]
  Added XmlElement.getContent() to be used in place of XmlElement (previously a list) when working on nested elements (unfortunately this breaks backward compatibility) [2.2.0]
  Removed calls to System.getProprety() (security issues with Java WebStart) [2.2.0]
  Corrected error in Struct for multi-dimensional arrays [2.2.0]
  
• December 19, 2004: Javolution 2.1
  CLDC 1.0 support [2.1.0]
  Removed bootclasspath limitation [2.1.0]
  
• December 12, 2004: Javolution 2.0
  Obfuscation support for Xml Serialization ( XmlFormat.setAlias) [2.0.4]
  XmlOutputStreamfor communication over persistent connections [2.0.3]
  Added XmlInputStream XmlOutputStream for communication over persistent connections [2.0.3]
  Facilitated the use of FastMap as identity map (ref. javadoc example) [2.0.3]
  Removed limitation on the number of Context [2.0.3]
  Added Utf8ByteBufferReader and Utf8ByteBufferWriter classes for high-performance I/O [2.0.1]
  Less restrictive licensing (dropped LGPL) [2.0.0]
  
• November 8, 2004: Javolution 1.1
  Cleared dangling reference in FastMap (thanks Nicolas) [1.1.2]
  Enhanced xml serialization/deserialization framework (e.g. circular references support) [1.1.1]
  
• October 4, 2004: Javolution 1.0
  Optimized FastMap (10% faster) [1.0.8]
  Added gcj support [1.0.5]
  Added default XML formats for Object, String, Collection and Map [1.0.4]
  Migration completed and tested [1.0.3]
  Spin-off of Java Addition to Default Environment [1.0.0]