LinkedHashSet
is a part of the Java Collections Framework and provides a hash table and linked list implementation of the Set interface. It maintains a doubly-linked list running through all its entries, thus maintaining the insertion order. This tutorial will cover all methods of LinkedHashSet
with examples and outputs, highlighting key points, use cases, best practices, performance considerations, and a real-time example with CRUD operations.Table of Contents
- Introduction
- Key Points
- LinkedHashSet Methods
- add()
- addAll()
- remove()
- clear()
- size()
- isEmpty()
- contains()
- iterator()
- removeIf()
- toArray()
- Use Cases
- Best Practices
- Performance Considerations
- Real-time Example with CRUD Operations
- Conclusion
1. Introduction
A LinkedHashSet
in Java is a part of the Java Collections Framework and provides a way to store unique elements while maintaining the order of insertion. It is found in the java.util
package and is backed by a hash table and a linked list, which allows for fast access to elements and maintains the order in which elements are inserted.
2. Key Points
LinkedHashSet
does not allow duplicate elements.- It maintains the insertion order.
- It allows null values.
- It is not synchronized.
- It provides constant-time performance for basic operations like add, remove, and contains.
3. LinkedHashSet Methods
3.1. add()
The add()
method is used to insert elements into the LinkedHashSet
.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
System.out.println(fruits);
}
}
Output:
[Apple, Banana, Mango]
3.2. addAll()
The addAll()
method adds all elements of a collection to the LinkedHashSet
.
Example:
import java.util.LinkedHashSet;
import java.util.Arrays;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.addAll(Arrays.asList("Banana", "Mango"));
System.out.println(fruits);
}
}
Output:
[Apple, Banana, Mango]
3.3. remove()
The remove()
method removes the specified element from the LinkedHashSet
.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
fruits.remove("Banana");
System.out.println(fruits); // [Apple, Mango]
}
}
Output:
[Apple, Mango]
3.4. clear()
The clear()
method removes all elements from the LinkedHashSet
.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
fruits.clear();
System.out.println(fruits); // []
}
}
Output:
[]
3.5. size()
The size()
method returns the number of elements in the LinkedHashSet
.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
System.out.println(fruits.size()); // 3
}
}
Output:
3
3.6. isEmpty()
The isEmpty()
method checks if the LinkedHashSet
is empty.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
System.out.println(fruits.isEmpty()); // true
fruits.add("Apple");
System.out.println(fruits.isEmpty()); // false
}
}
Output:
true
false
3.7. contains()
The contains()
method checks if the LinkedHashSet
contains a specified element.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
System.out.println(fruits.contains("Banana")); // true
System.out.println(fruits.contains("Mango")); // false
}
}
Output:
true
false
3.8. iterator()
The iterator()
method returns an iterator for the elements in the LinkedHashSet
.
Example:
import java.util.LinkedHashSet;
import java.util.Iterator;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
Output:
Apple
Banana
Mango
3.9. removeIf()
The removeIf()
method removes all elements of the LinkedHashSet
that satisfy the given predicate.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
fruits.removeIf(fruit -> fruit.startsWith("A"));
System.out.println(fruits); // [Banana, Mango]
}
}
Output:
[Banana, Mango]
3.10. toArray()
The toArray()
method converts the LinkedHashSet
into an array.
Example:
import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String[] args) {
LinkedHashSet<String> fruits = new LinkedHashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
String[] fruitsArray = fruits.toArray(new String[0]);
for (String fruit : fruitsArray) {
System.out.println(fruit);
}
}
}
Output:
Apple
Banana
Mango
4. Use Cases
- Unique collections with order:
LinkedHashSet
is used when you need a collection of unique elements that maintains insertion order. - Cache implementation: It can be used in scenarios where the order of elements is important, such as maintaining a cache.
- Removing duplicates while maintaining order: It is useful for removing duplicates from a collection while maintaining the order of elements.
5. Best Practices
- Use appropriate initial capacity: If the size of the set is known in advance, setting an initial capacity can improve performance.
- Avoid frequent traversals: Iterating over a
LinkedHashSet
is not as fast as iterating over anArrayList
due to its linked list structure. - Use
HashSet
if order is not important: If insertion order is not important, consider usingHashSet
for slightly better performance.
6. Performance Considerations
- Constant-time performance:
LinkedHashSet
provides constant-time performance for basic operations like add, remove, and contains. - Memory usage: Each element in a
LinkedHashSet
requires additional memory for storing hash codes and pointers. - Thread safety:
LinkedHashSet
is not synchronized. UseCollections.synchronizedSet()
if thread safety is needed.
7. Real-time Example with CRUD Operations
Managing a Product Set:
Product.java:
public class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
@Override
public String toString() {
return "Product{name='" + name + "', price=" + price + "}";
}
@Override
public int hashCode() {
return name.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Product product = (
Product) obj;
return Double.compare(product.price, price) == 0 && name.equals(product.name);
}
}
Main.java:
import java.util.LinkedHashSet;
public class Main {
public static void main(String[] args) {
LinkedHashSet<Product> productSet = new LinkedHashSet<>();
// Create
productSet.add(new Product("Laptop", 1200.00));
productSet.add(new Product("Smartphone", 800.00));
productSet.add(new Product("Tablet", 300.00));
// Read
for (Product product : productSet) {
System.out.println(product);
}
// Update
productSet.remove(new Product("Smartphone", 800.00));
productSet.add(new Product("Smartphone", 850.00));
System.out.println("After Update:");
for (Product product : productSet) {
System.out.println(product);
}
// Delete
productSet.remove(new Product("Laptop", 1200.00));
System.out.println("After Deletion:");
for (Product product : productSet) {
System.out.println(product);
}
}
}
Output:
Product{name='Laptop', price=1200.0}
Product{name='Smartphone', price=800.0}
Product{name='Tablet', price=300.0}
After Update:
Product{name='Laptop', price=1200.0}
Product{name='Smartphone', price=850.0}
Product{name='Tablet', price=300.0}
After Deletion:
Product{name='Smartphone', price=850.0}
Product{name='Tablet', price=300.0}
8. Conclusion
The LinkedHashSet
class in Java for managing unique collections of elements while maintaining insertion order. By understanding its methods, use cases, and best practices, you can effectively utilize LinkedHashSet
in your Java applications. This tutorial covers the essential methods with examples and demonstrates a real-time example with CRUD operations.
Comments
Post a Comment
Leave Comment