Legacy Classes in Java: Vector, Stack, Hashtable and Enumeration - Quiz

Legacy classes in Java are the classes and the interface of the java.util package from Java 1.0 that predate the Collections Framework (Java 1.2): Vector, Stack, Dictionary, Hashtable, Properties and the Enumeration interface. They had no common base: each one has its own method names (addElement(), elementAt(), keys()), and iteration went through Enumeration.

They are kept for backward compatibility. Java 1.2 retrofitted them into the new hierarchy (Vector implements List, Hashtable implements Map), and Java 5 made most of them generic (except Properties, which extends Hashtable<Object, Object>).

None of them is marked @Deprecated: the compiler gives no warnings, and there are no plans to remove them from the JDK. Only the documentation says they are outdated: the Stack Javadoc recommends Deque, and the Dictionary Javadoc calls the class obsolete. New code uses ArrayList, ArrayDeque, HashMap, ConcurrentHashMap and Iterator instead; Properties is still used for configuration.

The two terms describe different things. “Legacy” is about a class's age: it appeared in Java 1.0, before the Collections Framework, and is kept for compatibility (Vector, Hashtable, Enumeration). “Utility” is about its design: the class contains only static methods and is never instantiated (Collections, Arrays, Objects, Math).

Collections is a utility class, but not a legacy one: it appeared in Java 1.2 together with the new framework and is not considered outdated. Do not mix them up: legacy classes such as Vector are ordinary classes whose objects are created with new.

Vector is a dynamic array from Java 1.0; since Java 1.2 it extends AbstractList and implements List. Differences from ArrayList:

• every method is synchronized, so single-threaded code pays for locks it does not need;
• old methods are still there: addElement(), elementAt(), setElementAt(obj, index) and insertElementAt(obj, index) (element first, then index — the reverse of set() and add(index, e)), and elements(), which returns an Enumeration;
• the default capacity is 10 and the array doubles when full; the Vector(initialCapacity, capacityIncrement) constructor sets a fixed growth step, and capacity() shows the length of the internal array. ArrayList grows by 1.5 times and has neither that parameter nor that method.

Synchronized does not mean thread-safe: each method is synchronized on its own, but not a combination of them. if (!v.contains(x)) v.add(x); run from two threads can add x twice, and iteration has to be wrapped in synchronized (v) { ... } by hand. Multithreaded code uses classes from java.util.concurrent, for example CopyOnWriteArrayList.

Dictionary<K, V> is an abstract class from Java 1.0 for key-value pairs with only abstract methods (put(), get(), remove(), size(), isEmpty(), keys(), elements()). It is a class, not an interface, so a subclass cannot extend anything else — one of the reasons the Map interface appeared in Java 1.2. The Javadoc calls Dictionary obsolete, but there is no @Deprecated annotation.

Hashtable<K, V> extends Dictionary and has implemented Map since Java 1.2. Unlike HashMap, all its methods are synchronized, and neither keys nor values may be null — put() throws NullPointerException (HashMap allows one null key and any number of null values).

Gotcha: the old contains(value) method searches the values, so it equals containsValue(), not containsKey(). Old-style iteration uses keys() and elements(), which return a non-fail-fast Enumeration.

Properties is declared as public class Properties extends Hashtable<Object, Object> and did not become generic in Java 5. The inherited put() and putAll() accept any object, while the methods of Properties itself work with strings only: getProperty() returns null for a value that is not a String (here it is an Integer), and store() throws ClassCastException on such a value. So write settings with setProperty(String, String) and read them with getProperty().

• getProperty(key, defaultValue) returns the default instead of null, but does not store it.
• The new Properties(defaults) constructor attaches a defaults set: missing keys are looked up there, but they are not copied into the object, and size() does not count them.
• load(InputStream) reads the file as ISO-8859-1, so non-Latin-1 characters without escaping get garbled; read it through a UTF-8 Reader: Files.newBufferedReader(Path.of("app.properties")).

It is the only legacy class still used in new code; since Java 9 its data is stored internally in a ConcurrentHashMap.

Enumeration<E> is the Java 1.0 iteration interface with hasMoreElements() and nextElement() (which throws NoSuchElementException when there are no more elements). It was superseded by Iterator (Java 1.2) with hasNext() and next(). Differences:

• Enumeration cannot remove elements, while Iterator has remove();
• the enumerations returned by Vector.elements() and Hashtable.keys()/elements() are not fail-fast: if you remove an element during enumeration, the next element may be silently skipped, whereas an iterator throws ConcurrentModificationException.

Enumeration is still returned by legacy classes, StringTokenizer, ClassLoader.getResources() and NetworkInterface.getNetworkInterfaces(). To bridge the APIs: en.asIterator() (Java 9) turns it into an Iterator (whose remove() throws UnsupportedOperationException), Collections.list(en) copies it into an ArrayList, and Collections.enumeration(collection) goes the other way for an old API.

• Vector → ArrayList (in multithreaded code — CopyOnWriteArrayList or Collections.synchronizedList()). Check calls to addElement(), elementAt(), setElementAt(): the argument order of set() is reversed.
• Stack → ArrayDeque with a Deque variable type (for threads — ConcurrentLinkedDeque, LinkedBlockingDeque). peek() on an empty stack returns null instead of throwing EmptyStackException, pop() throws NoSuchElementException, null elements are not allowed, and there is no search().
• Hashtable → HashMap or ConcurrentHashMap. HashMap accepts null: code that used to catch NullPointerException will silently store null; contains() → containsValue().
• Dictionary → the Map interface (ConcurrentMap): your own subclasses are rewritten as implements Map or extends AbstractMap.
• Enumeration → Iterator and for-each; third-party APIs are wrapped with asIterator().
• Properties stays: the JDK has no direct replacement for configuration files, but put()/get() are changed to setProperty()/getProperty().

Declare the variable with the interface type — List<String> names = new ArrayList<>();, Deque<Integer> stack = new ArrayDeque<>(); — so the implementation can be changed in one line.