# Java: Java Data Structures

Three different names would have been better. The overall term for Java's data structure facilities is Collections. This is confusing because, in addition to describing the general data structure facilities, java.util.Collection is the name of an interface and java.util.Collections is the name of a class containing many data structure utility methods.

## Don't write your own

Most data structure textbooks give students the impression that professional programmers implement basic data structures, such as linked lists, or write their own sort methods.

This is completely false! Many standard data structures and algorithms have already been written and are available in Java. Professional programmers use these library classes as building blocks for their application specific structures.

Textbooks give this distorted view because their emphasis is on understanding how data structures are build using only pointers/references and arrays. This is an excellent exercise; it is necessary to becoming a good programmer. But these textbooks often fail to emphaisze the predefined data structure libraries that programmers actually use.

You will, of course, often write data structures that reflect the nature of your problem, but use the library versions for the basic elements.

### Productivity is much higher

To be a productive programmer, your first choice must be to use standard library data structures. In Java this means using the Collections classes and interfaces. If you can't find what you need built into Java, try one of the Alternative Data Structures.

You will always have to write some of your own data structures, but you can program faster, and produce more robust and readable programs by building on the work of others.

## The Collections data structures are good, but ...

No primitive types. Collections data structures work only with objects, not primitive values. You can use the wrapper classes (automated in Java 5) or write your own class equivalents. The creation and garbage collection of these extra objects may add substantial overhead. There are a number of non-Sun implementations of data structures using primitives.

Pre-Java 5 Downcasting from `Object` A related problem is that the Object that is returned from a data structure must be downcast to whichever type you want. This is a constant annoyance, and is a form of weak-typing, which allows run-time type mismatches that should be caught at compile time. Generic types, as in C++ templates, are in Java 5 to enforce typing and remove the need for explicit casting.

Missing facilities Many obvious additions can be found in Alternative Data Structures.

## History

Java support for data structures comes in three generations.

1. The first version of Java came with a few important data structures in the `java.util.*` package (eg, `Vector`).
2. Collections is the Java term for the data stucture classes, interfaces, and algorithms that were added to Java 1.2.
3. Java 5 supports generics (templates), allowing data structures to be restricted to specific types, as well as a number of other structures (eg, `Queue`).