Home / Collections / Legacy synchronized collections to modern alternatives
Collections Intermediate

Legacy synchronized collections to modern alternatives

Replace Vector and Hashtable with collections selected for actual mutability and concurrency needs.

Collections Concurrency
Code Comparison
✕ Legacy synchronized collection 
Hashtable<String, Session> sessions = new Hashtable<>();
sessions.put(id, session);
✓ Concurrent Collections API 
ConcurrentMap<String, Session> sessions = new ConcurrentHashMap<>();
sessions.put(id, session);
See a problem with this code? Let us know.
Why the modern way wins
🎯

Intentional concurrency

The chosen type documents whether sharing is expected.

⚡

Better scalability

ConcurrentHashMap avoids a single table-wide lock for normal access.

🧩

Modern APIs

Works naturally with current collection and concurrent-map operations.

Old Approach
Hashtable
Modern Approach
ConcurrentHashMap
Since JDK
5
Difficulty
Intermediate
JDK Support
Legacy synchronized collections to modern alternatives
Available

Widely available since JDK 5 (September 2004)

How it works

Vector and Hashtable synchronize every operation through legacy APIs. Modern code should normally use ArrayList or HashMap for thread-confined data, and purpose-built concurrent collections when shared mutation is required.

Related Documentation
ConcurrentHashMap ↗ ConcurrentMap ↗
Proof
View proof source ↗
Related patterns
Collections Beginner

Immutable map creation

Java 8
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
map = Collections.unmodifiableMap(map);
Java 9+
Map<String, Integer> map =
    Map.of("a", 1, "b", 2, "c", 3);
Hover to see modern ➜
JDK 9+ →
Collections Beginner

Copying collections immutably

Java 8
List<String> copy =
    Collections.unmodifiableList(
        new ArrayList<>(original)
    );
Java 10+
List<String> copy =
    List.copyOf(original);
Hover to see modern ➜
JDK 10+ →
Concurrency Advanced

Lock-free lazy initialization

Java 8
class Config {
    private static volatile Config inst;
    static Config get() {
        if (inst == null) {
            synchronized (Config.class) {
                if (inst == null)
                    inst = load();
            }
        }
        return inst;
    }
}
Java 25 (Preview)
class Config {
    private static final
        StableValue<Config> INST =
            StableValue.of(Config::load);

    static Config get() {
        return INST.get();
    }
}
Hover to see modern ➜
JDK 25+ →