Each collection in the Java Collections Framework is designed with specific guarantees and limitations. A LinkedHashSet is often selected when we need unique elements and a predictable insertion order. However, we might frequently encounter a challenge when we want to know the position of a specific element inside a LinkedHashSet.
Unlike lists, a LinkedHashSet does not support index-based access. This article explains why that is the case and demonstrates approaches to obtain the index of an element without explicitly iterating in your application code.
1. Understanding the Problem
Before exploring solutions, let’s understand what the problem really means. A LinkedHashSet maintains insertion order internally, but it does not expose that order through an index-based API. This is intentional, as sets are designed for membership checks, not positional access.
When developers say “without iteration,” they usually mean without writing a manual loop, such as for or while. Internally, however, some form of traversal is unavoidable. The goal is to achieve index-like access cleanly and safely, without breaking the design principles of Java collections.
2. Convert the LinkedHashSet to a List
This approach is suitable when we only need the index occasionally. Since LinkedHashSet preserves insertion order, converting it to a list allows us to take advantage of list-based indexing methods. The conversion handles iteration internally, keeping our code simple and readable.
public class LinkedHashSetIndexExample {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
List<String> list = new ArrayList<>(set);
int index = list.indexOf("Banana");
System.out.println("Index of Banana: " + index);
}
}
In this example, the LinkedHashSet stores elements in insertion order. By creating an ArrayList from the set, the order is preserved. The indexOf method then returns the zero-based index of the requested element. This solution is easy to implement and understand, but it has a time complexity of O(n) and creates an additional list in memory.
Output
Index of Banana: 1
3. Maintain an Index Map Alongside the LinkedHashSet
If you need to look up indexes frequently, converting the set to a list each time is inefficient. In such cases, maintaining an auxiliary map that tracks element positions provides constant-time index access.
public class IndexedLinkedHashSet {
private final LinkedHashSet<String> set = new LinkedHashSet<>();
private final Map<String, Integer> indexMap = new HashMap<>();
public void add(String value) {
if (set.add(value)) {
indexMap.put(value, set.size() - 1);
}
}
public Integer getIndex(String value) {
return indexMap.get(value);
}
public static void main(String[] args) {
IndexedLinkedHashSet indexedSet = new IndexedLinkedHashSet();
indexedSet.add("Apple");
indexedSet.add("Banana");
indexedSet.add("Orange");
System.out.println("Index of Orange: " + indexedSet.getIndex("Orange"));
}
}
Here, the LinkedHashSet ensures uniqueness and order, while the HashMap stores each element’s index at insertion time. Index retrieval is O(1) and does not require iteration. The main drawback is additional memory usage and the need to carefully handle removals, as indexes would need to be recalculated.
4. Use a LinkedHashMap Instead of a LinkedHashSet
If positional access is a core requirement, using a LinkedHashMap can be a better design choice. Instead of deriving the index later, we store it explicitly as the value. This makes index access straightforward and avoids hidden iteration.
public class LinkedHashMapIndexExample {
public static void main(String[] args) {
Map<String, Integer> map = new LinkedHashMap<>();
map.put("Apple", 0);
map.put("Banana", 1);
map.put("Orange", 2);
int index = map.get("Apple");
System.out.println("Index of Apple: " + index);
}
}
In this approach, the index is part of the data model itself. The LinkedHashMap preserves insertion order, and the index is stored as the value. This solution is simple and efficient, but it slightly changes the semantics of your data structure from a pure set to a key-value mapping.
5. Conclusion
In this article, we explained how to determine the index of an element in a LinkedHashSet without using explicit iteration. We discussed approaches such as converting the set to a list, maintaining a separate index map, and using a LinkedHashMap when positional access is essential. Although a LinkedHashSet preserves insertion order, it deliberately does not support index-based access. While some form of traversal is unavoidable, Java offers flexible and clean ways to achieve index-like behavior without writing manual iteration code.
6. Download the Source Code
This article explored how to obtain the index of a LinkedHashSet element in Java without using explicit iteration.
You can download the full source code of this example here: Java index linkedhashset element without iteration
