Java offers a variety of data structures to meet different use cases. One powerful hybrid data structure is an “array of linked lists.” This combination leverages the indexed structure of arrays with the dynamic nature of linked lists. Let us delve into understanding how a Java array containing linked lists can be created and utilized effectively in real-world applications.<\/p>\n
An array<\/a> of linked lists<\/a> is essentially a hybrid data structure that combines the features of arrays and linked lists. In this structure, each element of the array acts as a reference (or pointer) to a separate LinkedList<\/a> object. This means that instead of holding a single value, each array element can hold a dynamic collection of elements via the linked list. This is particularly useful when you want fixed-size indexing (like arrays offer) but need dynamic storage at each index (which linked lists provide). In Java, an array of linked lists can be declared and initialized using the following syntax:<\/p>\n Below is a single Java class that demonstrates four different ways to create and initialize an array or list of LinkedLists: The Java program demonstrates four different ways to create and initialize an array of linked lists (or a list of linked lists) using various Java techniques. In Method 1, a traditional raw array of type The table below summarizes the performance and design trade-offs between different ways to create an array or list of linked lists in Java:<\/p>\n\nLinkedList<Type>[] array = new LinkedList[size];\nfor (int i = 0; i < size; i++) {\n array[i] = new LinkedList<>();\n}\n<\/pre>\n1.1 Where Can We Use an Array of Linked Lists?<\/h3>\n
\n
<\/a>2. Creating an Array of Linked Lists in Multiple Ways<\/h2>\n
\n
List<\/code> of LinkedList<\/code> objects via ArrayList<\/code><\/li>\nStreams<\/code> for a functional-style initialization, and<\/li>\nArrays.setAll()<\/code> for a concise and declarative setup.<\/li>\n<\/ul>\n\n\/\/ LinkedListArrayExamples.java\n\nimport java.util.*;\nimport java.util.stream.*;\n\npublic class LinkedListArrayExamples {\n public static void main(String[] args) {\n int size = 4;\n\n \/\/ Method 1: Traditional Raw Array with Initialization Loop\n LinkedList<String>[] array1 = new LinkedList[size];\n for (int i = 0; i < size; i++) {\n array1[i] = new LinkedList<>();\n }\n array1[0].add(\"Apple\");\n\n \/\/ Method 2: List of LinkedLists\n List<LinkedList<String>> listOfLists = new ArrayList<>();\n for (int i = 0; i < size; i++) {\n listOfLists.add(new LinkedList<>());\n }\n listOfLists.get(1).add(\"Banana\");\n\n \/\/ Method 3: Java 8 Streams\n LinkedList<String>[] array2 = IntStream.range(0, size)\n .mapToObj(i -> new LinkedList<String>())\n .toArray(LinkedList[]::new);\n array2[2].add(\"Cherry\");\n\n \/\/ Method 4: Arrays.setAll (Java 8+)\n LinkedList<String>[] array3 = new LinkedList[size];\n Arrays.setAll(array3, i -> new LinkedList<>());\n array3[3].add(\"Date\");\n\n \/\/ Display all the initialized collections\n System.out.println(\"Method 1 (Raw Array):\");\n for (int i = 0; i < size; i++) {\n System.out.println(\"Index \" + i + \": \" + array1[i]);\n }\n\n System.out.println(\"\\nMethod 2 (List of LinkedLists):\");\n for (int i = 0; i < size; i++) {\n System.out.println(\"Index \" + i + \": \" + listOfLists.get(i));\n }\n\n System.out.println(\"\\nMethod 3 (Streams):\");\n for (int i = 0; i < size; i++) {\n System.out.println(\"Index \" + i + \": \" + array2[i]);\n }\n\n System.out.println(\"\\nMethod 4 (Arrays.setAll):\");\n for (int i = 0; i < size; i++) {\n System.out.println(\"Index \" + i + \": \" + array3[i]);\n }\n }\n}\n<\/pre>\n2.1 Code Explanation and Output<\/h3>\n
LinkedList<String><\/code> is created and initialized using a loop, where each index is manually assigned a new LinkedList<\/code> object, and the string “Apple” is added to the first list. Method 2 uses a List<\/code> of LinkedList<\/code> objects instead of an array, offering a more flexible alternative through the ArrayList<\/code> class, and adds “Banana” to the second list. Method 3 demonstrates a concise and functional approach using Java 8’s IntStream<\/code> to generate and initialize an array of linked lists, with “Cherry” added to the third index. Method 4 uses the Arrays.setAll()<\/code> method (introduced in Java 8) to initialize a new array of linked lists more declaratively, adding “Date” to the fourth index. Finally, the program prints out the contents of each structure, showing how each index in the array or list contains its own dynamically created and populated linked list.<\/p>\n\nMethod 1 (Raw Array):\nIndex 0: [Apple]\nIndex 1: []\nIndex 2: []\nIndex 3: []\n\nMethod 2 (List of LinkedLists):\nIndex 0: []\nIndex 1: [Banana]\nIndex 2: []\nIndex 3: []\n\nMethod 3 (Streams):\nIndex 0: []\nIndex 1: []\nIndex 2: [Cherry]\nIndex 3: []\n\nMethod 4 (Arrays.setAll):\nIndex 0: []\nIndex 1: []\nIndex 2: []\nIndex 3: [Date]\n<\/pre>\n
2.2 Performance Considerations<\/h3>\n
\n\n
\n \nMethod<\/th>\n Access Time<\/th>\n Initialization Overhead<\/th>\n Flexibility<\/th>\n Memory Usage<\/th>\n Java Version Support<\/th>\n<\/tr>\n<\/thead>\n \n Raw Array with Loop<\/td>\n O(1) array access, O(n) list traversal<\/td>\n Manual loop required<\/td>\n Low (fixed size)<\/td>\n Low to Moderate<\/td>\n Java 1.5+<\/td>\n<\/tr>\n \n List of LinkedLists (ArrayList)<\/td>\n O(1) list access, O(n) list traversal<\/td>\n Manual loop or Collections.nCopies()<\/td>\n High (dynamic size)<\/td>\n Moderate<\/td>\n Java 1.5+<\/td>\n<\/tr>\n \n Java 8 Streams<\/td>\n O(1) array access, O(n) list traversal<\/td>\n Concise, functional style<\/td>\n Medium<\/td>\n Moderate<\/td>\n Java 8+<\/td>\n<\/tr>\n \n Arrays.setAll()<\/td>\n O(1) array access, O(n) list traversal<\/td>\n Concise, declarative<\/td>\n Medium<\/td>\n Moderate<\/td>\n Java 8+<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n