I've never seen a good list of free Java libraries.
What are some of your can't-live-without Java libraries?
Note: to keep this poll as useful as possible, please remember:
SWT, though I haven't used it for a while. It yeilds pretty great user interfaces.
JTS Topology Suite: If you work with geographic data it's very useful. It's so useful, also C++-programmerswant it, so it was ported to C++, a library named GEOS (Geometry Engine Open Source).
Actually not just the commons, but all of Apache Jakarta project has great Java libraries. From MS Office file access to collection utilities to byte code manipulation. The page also lists projects that have moved out of Jakarta (eg: maven).
Another place is http://delicious.com/tag/java+library - several of my colleagues use that combination of tags (language + library) to organize the things they run across (mortis, robdimarco).
Joda Time is an absolute must if you're doing anything beyond the most trivial of date computations.
Note: JSR 310 aims to fix a lot of the problems with the standard Java Date and Time API.
PCJ, Primitive Collections for Java.
This is a the fastest implementation of a Collections framework around primitive datatypes, providing for example Maps with ints as keys or Lists for floats. Much faster and more memory efficient than Sun's classes (where you have to use Integer and Float as wrappers with substantial cost), and also faster than its "competitors" fastutil and trove. Unfortunately no generics and not being maintained anymore - is stable though.
JDOM, for java XML parsing
http://www.servlets.com/cos/ -- servlet utils including download/upload, etc
bindings to curl for http download/upload
code from the squirrel SQL client for accessing DBs
the original JDBC driver for accessing MySQL.
it takes a while to think about all the stuff that's been useful to you over the years.
JAI - Java Advanced Imaging API it's very useful to do powerful image manipulation. Here comes Sun's description of it:
The Java Advanced Imaging API (JAI) provides a set of object-oriented interfaces that supports a simple, high-level programming model which allows images to be manipulated easily in Java applications and applets. JAI goes beyond the functionality of traditional imaging APIs to provide a high-performance, platform-independent, extensible image processing framework.
I would also recommend JAI-Image-IO Tools.
Dozer mapping library, very usefule going from JPA generated classes to domain classes
It is exceedingly useful to dynamically generate files from templates:
Name: Guice
Website: http://code.google.com/p/google-guice/
Purpose: Dependency Injection, ease of testing
Name: XStream
Website: http://xstream.codehaus.org/
Purpose: Out of the box POJO serialization to XML and back again
Name: Glazed list
Website: http://publicobject.com/glazedlists/
Purpose: Data flow, instead of logic flow. Data centric. Works well with Swing
Name: Lipermi
Website: http://lipermi.sourceforge.net/ WARNING: Use the CVS version for now, it fixes two major bugs.
Purpose: RMI alternative that uses only TCP. No more codebase urls!
Name: Miglayout
Website: http://www.miglayout.com/
Purpose: A powerful layout manager that just works
It is a bit subjective, something you can't live without might be useless for me... :-)
Anyway, here are some I bookmarked (I haven't used all of them!):
There is lot more, that's one of the strong points of Java...
OpenSymphony has a really nice set of various open source java projects. The ones I used and enjoyed:
Both Quartz and OSCache are well integrated with Spring.
These two are excellent:
Apache MINA - Well-designed, high-performance, network application framework using Java NIO
Jetty - Easy-to-use, full-featured, embeddable web server and webapp container
Name: JFugue
Website: http://www.jfugue.org
Purpose: Playing music in one line of Java code
(Not the most business-minded library, but definitely great for being creative and programming for fun!)
Let's not forget the excellent Google Collections library. (Edit: Google Collections was expanded and renamed to Guava. You should not use the library titled "Google Collections" anymore.)
Javalobby's interview with its main developers is a good introduction: What is the Google Collections Library?
Comments by Steve McLeod:
It's gradually altering my whole coding style. Preconditions, Functions, Transformers are stupendous once you get the hang of them.
Some of the stuff we used:
MessAdmin, a fantastic HttpSession administration tool, and giving detailed statistics and informations on any Web application. It installs as a plug-in to any Java EE WebApp, and requires zero-code modification.
The JGoodies Forms framework, featuring the excellent (and most importantly, sane) FormLayout layout manager for Swing.
Mockito for easy testing. Allows mocking concrete classes (besides interfaces, of course) as well.
I've written unit tests for years, but Mockito and Easymock impressed me immediately.
These are all libraries I use or have used and can definitely recommend.
JfreeChart is the best freely available charting thing available on any platform.
TestNG: http://testng.org/
It was mightily useful in creating a database driven web testing framework some years ago. JUnit was too rigid at the time to do what I needed.
Name: Uncommons Maths
Website: https://uncommons-maths.dev.java.net/
Purpose: Generics enabled CombinationGenerator! A Random seed generator
Name: The Legion of the Bouncy Castle
Website: http://www.bouncycastle.org/java.html
Purpose: Security/Cryptography
What are some of your can't-live-without Java libraries?
**java.util**
It is java, it is free, it is good, and I can't live without it.
Don't make it less for live in the core :)
Apache-commons if you need a lot of utilities that the Java standard library left out (e.g., collections, XML, etc.)
JMS (can also get as part of J2EE) if you need to reliable send messages from one machine to another and don't want to deal with the hassle of maintaining your own queues.
I'm also a fan of SWT for GUIs (mostly used as part of the Eclipse project)
Most of my faves have been mentioned (like Apache Commons, Hibernate, and Spring), but I'd like to add:
Rhino -- http://www.mozilla.org/rhino/
a javascript compiler/interpreter, allowing the execution of javascript within your java app.
A port of apache collections with parameterization: http://larvalabs.com/collections/
I feel like there is another one of these too, but I can't think of it.
Note: This is a duplicate of another answer to this question (and that other answer has more votes as I write this, so vote up the other answer!). Notes from this answer have been merged there.
Google Collections
It's gradually altering my whole coding style. Preconditions, Functions, Transformers are stupendous once you get the hang of them.
Another vote for SWT. GridLayout is so much better than Swing's GridBagLayout (of which I have nightmares about). Although, SWT has some glitches, If I have the choice, I'd always prefer SWT to Swing.
Log5j is a wrapper around Log4j that uses Java 5's var-args for an automatic String.format in log messages:
log.debug("IOException while reading %s", exception, file.getName());
AspectJ - a seamless aspect-oriented extension to the Javatm programming language.
Very useful for logging, debugging, testing and more.
Apache Wicket, POJO-based web application framework. That description is short but it's beyond powerful, check the examples from the site and you should understand why.
It's a lightweight annotation-driven presentation framework.
A superb templating engine.
XOM™ is a new XML object model. It is an open source (LGPL), tree-based API for processing XML with Java that strives for correctness, simplicity, and performance, in that order.
Piccolo2D (formerly Piccolo)
Toolkit for development of 2D structured graphics programs, in general, and Zoomable User Interfaces (ZUIs), in particular. Good for highly interactive user interfaces.
The Apache JXPath is a great little library, yet remarkably unknown. It allows you to access Java object methods using XPath-like syntax. For example, rather than writing:
for (Person p : getCompany().getDepartment().getPeople()) {
if(p.getName().equals("Brian") {
...
You can write:
JXPath.newContext(getCompany()).getValue("/Department/People[@name='Brian']");
(A trivial example. XPath can do so much more)
It doesn't make so much sense hardcoding this, but it's very useful for configs etc.
Selenium - automated UI testing (or acceptance testing) framework for web applications. Getting up to speed and making your tests stable enough for fully automated continuous integration probably won't be easy, but once you do, it's quite cool what you can do with Selenium.
In case you're totally new to this, here's a summary: You can write test cases in pure Java, JUnit-style, and when you run them, Selenium launches e.g. Firefox and does all kinds of stuff (clicks on links, types into forms, does assertions about page content, etc.) against your webapp. (This is just one way of using Selenium - you can also record tests with Selenium IDE, or use other languages such as Python or C# to write them.)
I find this to be a good list of free Java libraries http://java-sources.org/
Here are my choices.
GWT - If your Javascript skills are not adequate enough for stunning AJAX applications
With it you can, for example, make a server-side application support clustering without having to litter your code with clustering infrastructure. You basically define "shared roots", globally distributed methods, instrumented classes (whose instances will be passed between JVMs), etc, in a configuration file, and in Java code just make sure access to those is correctly synchronized.
(Terracotta can be used in other scenarios too, but clustering is what I'm most familiar with.)
It's open source and free (for most uses at least), but commercial licensing options and support are also available.
XMLBeans - XMLBeans is a technology for accessing XML by binding it to Java types. Why work with XML when you can work with classes/objects?
RichFaces is an open source framework that adds Ajax capability into existing JSF applications without resorting to JavaScript, with a huge library of rich components and skinnability support.
Surprisingly, this good facade lib for logging (better than commons logging) was still missing.
JUNG - Java Universal Network/Graph Framework
Comes with many standard graphing algorithms. Provides some sane algorithms to lay out vertices in visualizations.
Suggested Uses: ANY time you're storing a lot of ints, chars, or longs in memory and running out of memory. Doubly useful if collections are having items added/removed/modified a lot, because these operations are much faster on primitive objects.
Also useful in cases where very predictable performance is needed and garbage collection pauses cause problems.
ANYTHING that does work with graph-style relationships between RAM-expensive objects will benefit, because you don't need to store the objects in memory, just an int or long unique identifier for each. Persist the objects to disk, and let TIntIntHashMaps store relationships. You can store 8x as many relationships in memory for the same RAM use as a vanilla HashMap.
StringTemplate as a general purpose templating engine. It's simple yet ingenious...
Name: Functional Java
Website: http://code.google.com/p/functionaljava
Purpose: Provides first-class functions, generic compound types, immutable (persistent) data structures, lazy (infinite) lists, parser combinators, actor concurrency, specification-based testing, flexible replacements for toString(), equals(), and hashCode(), and more.
I've found AjaxTags very useful for DisplayTag updates without page refreshes and building servlet based autocompletes. It's one of several libraries for ajax development with minimal javascript coding. The site also has some great demo to try out.
I recommend the Simple XML library for XML serialization. It can do virtually anything you need. Add a few annotations and you're done or you can customize everything to make it deserialize a 3rd party XML format into your classes. And, as the name suggests, it is really simple. Great documentation, under active development, top notch stuff.
I'm surprised no one has mentioned iBatis (ORM/Persistence for people who like to use actual SQL code) or JMock (mock objects).
JGAP - It's a package for doing genetic programming quickly and easily. I was able to use it the first time and had an answer to a question in four hours that humans had previously spent days on and not gotten nearly as good an answer.
If you need to answer questions about efficiency (fastest, cheapest, least distance, etc.) or even if there is any solution at all with a given set of constraints within a complicated system involving lots of variables then JGAP is your best friend in the world. Don't automatically assume it's just for academic wonks, it's every bit as applicable in real world circumstances.
Apache Xalan.
It's buggy and shabby, but we absolutely can't live without it.
ASM, the Java bytecode manipulation framework and CGLIB, the code generation library. A lot of the frameworks (viz. Hibernate) here rely on ASM and CGLIB (which itself relies on ASM) to do their magic.
A great substitute for ReadLine, written in pure Java, portable between platforms (specifically Linux and Windows).
While not Java specific, Axis and preferably Axis 2: http://ws.apache.org/axis2/
Makes creating web services very easy and it works with a few different serialization libraries to allow objects to be sent from clients to servers without having to do any serialization on your side.
Axis 2 has a completely different set up than the original axis, but the changes are worth it.
That is if you are creating web services
JavaBuilders -- lets you specify creation/parameters/bindings of a GUI layout in a succinct format; flavors exist for Swing, SWT, and GTK+.
Surprised to see not much of JBoss stuff here apart from Hibernate.
Anyways, one of my favorite tools is Drools/JboosRules engine.
Not sure how many use Antlr, but I require it lot of time.
I think JNA (Java Native Access) should be on the list for easy access to native shared libraries (DLLs on Windows) without writing anything but Java code—no JNI or native code is required (from the website)
We're using it for direct calls to Windows software and DLLs; it works really well and can be a huge time saver.
Greetz, GHad
Name: ACM Java Task Force Library
Website: ACM Java Task Force Library
Purpose: To review the Java language, APIs, and tools from the perspective of introductory computing education and to develop a stable collection of pedagogical resources that will make it easier to teach Java to first-year computing students without having those students overwhelmed by its complexity.
Strengths:
A simple object-oriented model for programs.
The Program class defined in the acm.program package offers an easy-to-use model for writing simple programs. In addition to hiding the static main method, the Program class and its standard subclasses provide a highly intuitive example of object-oriented class hierarchies.
A model for input and output that treats traditional console I/O and dialog I/O symmetrically.
The acm.io package defines the classes IOConsole and IODialog that share a common interface for all input-output operations. This design addresses the lack of a simple input mechanism in a way that emphasizes the value of interface-based design.
An extensive library of graphical objects.
The acm.graphics package implements a simple but extremely powerful model for creating graphical pictures based on the metaphor of a felt board in which students construct graphical objects of various types and place them on a canvas. This design emphasizes the use of objects and frees the student from having to respond explicitly to repaint requests.
A minimal set of new classes to support development of graphical user interfaces.
The acm.gui package includes a small set of classes to bring Java’s extensive GUI-development resources within reach of novice programmers.
Backward compatibility for applets.
Unlike most Java code today, programs developed using the JTF packages can typically be executed as applets even on older web browsers. This flexibility makes them ideal for web-based teaching tools and lecture demonstrations.
Jython. Yes it's still alive people, and they've just released 2.5 recently. It's quite useful to call Java libraries using less verbose Python syntax in a day-to-day administrative tasks.
H2Database. Really useful during unit testing. Slightly faster than HSQL.
For parsing command line options, similar style to Unix commands. The API is simple, while offering an immense feature set.
Markdown-Doclet for including Markdown syntax in Javadocs rather than HTML.
Processing is a pure, java based graphics and multimedia library, that has been used by even artists. I myself use it for it's simplicity and power of 3D drawing. There are many plugin libraries for it too. The speed of it's drawing and graphics manipulating capabilities are georgeous! There is a Javascript and Ruby port of it.
Library: FlyingSaucer / XHTMLRenderer
Purpose: Render XHTML / CSS to PDF or a Swing component (and do so wonderfully well!)
It's the only way I write reports anymore.
Name: JXTA
Website: https://jxta.dev.java.net/
Purpose: Allows developing highly scalable P2P communication networks among applications without coding everything from scratch.
http://www.unitils.org/summary.html
I had a need to perform deep equality checks within my test cases. The commons EqualsBuilder.reflectionEquals didn't go deep. The "assertReflectionEquals" feature provided by unitils was a life saver. I didn't have to write equals methods for all my classes and the generated error message when objects don't equal precisely identifies the attributes. This is the best deep equals utility I was able to find.
HtmlUnit
http://htmlunit.sourceforge.net/ for unit tests and scraping of websites
Legion of the Bouncy Castle cryptography API for anything crypto related.
If you use JSF alot, then you cannot avoid JBoss Seam. It is awsome! Of course it is not only required when running JSF.
It is a very nice library for Java EE. It was Seam that led to Context and Dependency injection and alot of the features in Java EE 6.
Jpcap - Using Jpcap, you can develop applications to capture packets from a network interface and visualize/analyze them in Java
JAXB - JAXB allows Java developers to access and process XML data without having to know XML or XML processing, validate source data against an associated schema, JAXB allows access to data in non-sequential order, but it doesn't force an application to navigate through a tree to access the data etc. etc
Castor - Castor is an Open Source data binding framework for Java[tm]. It's the shortest path between Java objects, XML documents and relational tables. Castor provides Java-to-XML binding, Java-to-SQL persistence, and more
Ehcache is an open source, standards-based cache used to boost performance, offload the database and simplify scalability.
Jep is a very good Java library for parsing and evaluating mathematical expressions.
Nekohtml - tidy up html into xml document for data processing (xpath/xslt)
http://nekohtml.sourceforge.net/
TagSoup - a SAX-compliant parser written in Java that, instead of parsing well-formed or valid XML, parses HTML as it is found in the wild
Nobody mentioned Java image utilities??
A Java library for loading, editing, analyzing and saving pixel image files.
It supports various file formats.
Provides demo applications for the command line. It has AWT GUI toolkit too.