How are data structures implemented in Java and Kotlin?

In Java, data structures are mainly represented by the Collections framework:

• Interfaces: List, Set, Map, Queue, Deque. They define the behavior of collections.
• Implementations: Concrete classes that implement the interfaces. For example, ArrayList, LinkedList, HashSet, TreeSet, HashMap, LinkedHashMap, TreeMap, PriorityQueue.

Examples:

// Creating a list.
List<String> list = new ArrayList<>();

// Creating a set.
Set<Integer> set = new HashSet<>();

// Creating a map.
Map<String, Integer> map = new HashMap<>();

In Kotlin, data structures are also based on the Collections framework but with some features:

• Read-only and Mutable collections: Separation into immutable (e.g., List<T>, Set<T>, Map<K, V>) and mutable (e.g., MutableList<T>, MutableSet<T>, MutableMap<K, V>) collections. This improves type safety.
• Top-level functions: Functions for convenient collection creation, such as listOf(), mutableListOf(), setOf(), mutableSetOf(), mapOf(), mutableMapOf().
• Extension functions: Many extension functions for working with collections (filtering, transforming, aggregating, etc.).

Examples:

// Creating an immutable list.
val list: List<String> = listOf("a", "b", "c")

// Creating a mutable set.
val set: MutableSet<Int> = mutableSetOf(1, 2, 3)

// Creating an immutable map.
val map: Map<String, Int> = mapOf("one" to 1, "two" to 2)

The main implementations of data structures in Kotlin are often wrappers over the corresponding Java implementations, providing a more convenient API and separation into mutable/immutable types.

Comparison:

Feature	Java	Kotlin
Mutability	Single interface, mutability by default	Separate interfaces for read-only and mutable
Collection creation	Via class constructors	Via top-level functions
Working with collections	Class methods	Many extension functions
Null safety	Requires explicit NRT annotations/checks	Built-in at the type level