Java Collections Framework
### Java Collections Framework
The Java Collections Framework (JCF) is a unified architecture for representing and manipulating collections of objects. It consists of various interfaces, implementations (classes), and algorithms that provide ready-to-use data structures and algorithms for handling collections.
#### Key Interfaces
1. **Collection**: The root interface of the Java Collections Framework.
2. **List**: Ordered collection (also known as a sequence).
3. **Set**: A collection that does not allow duplicate elements.
4. **Queue**: A collection used to hold multiple elements prior to processing.
5. **Deque**: A double-ended queue.
6. **Map**: An object that maps keys to values, with no duplicate keys allowed.
#### Key Implementations
1. **ArrayList**: Resizable-array implementation of the List interface.
2. **LinkedList**: Doubly-linked list implementation of the List and Deque interfaces.
3. **HashSet**: Hash table-based implementation of the Set interface.
4. **LinkedHashSet**: Hash table and linked list implementation of the Set interface, with predictable iteration order.
5. **TreeSet**: A NavigableSet implementation based on a TreeMap.
6. **PriorityQueue**: A priority heap-based implementation of the Queue interface.
7. **HashMap**: Hash table-based implementation of the Map interface.
8. **LinkedHashMap**: Hash table and linked list implementation of the Map interface, with predictable iteration order.
9. **TreeMap**: A Red-Black tree-based implementation of the NavigableMap interface.
#### Example Usage
Here are some examples demonstrating how to use various collections:
##### 1. List
```java
import java.util.*;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
System.out.println("List: " + list);
list.remove("Banana");
System.out.println("After removal: " + list);
for (String fruit : list) {
System.out.println(fruit);
}
}
}
```
##### 2. Set
```java
import java.util.*;
public class SetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");
set.add("Apple"); // Duplicate element
System.out.println("Set: " + set);
set.remove("Banana");
System.out.println("After removal: " + set);
for (String fruit : set) {
System.out.println(fruit);
}
}
}
```
##### 3. Map
```java
import java.util.*;
public class MapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Cherry", 3);
System.out.println("Map: " + map);
map.remove("Banana");
System.out.println("After removal: " + map);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
```
##### 4. Queue
```java
import java.util.*;
public class QueueExample {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
queue.add("Apple");
queue.add("Banana");
queue.add("Cherry");
System.out.println("Queue: " + queue);
queue.remove();
System.out.println("After removal: " + queue);
for (String fruit : queue) {
System.out.println(fruit);
}
}
}
```
##### 5. Deque
```java
import java.util.*;
public class DequeExample {
public static void main(String[] args) {
Deque<String> deque = new LinkedList<>();
deque.addFirst("Apple");
deque.addLast("Banana");
deque.addFirst("Cherry");
System.out.println("Deque: " + deque);
deque.removeLast();
System.out.println("After removal: " + deque);
for (String fruit : deque) {
System.out.println(fruit);
}
}
}
```
#### Algorithms
The Collections class provides static methods for sorting, searching, and modifying collections. Some commonly used methods include:
- **sort(List<T> list)**: Sorts the specified list into ascending order.
- **reverse(List<T> list)**: Reverses the order of the elements in the specified list.
- **shuffle(List<T> list)**: Randomly permutes the elements in the specified list.
- **binarySearch(List<? extends Comparable<? super T>> list, T key)**: Searches the specified list for the specified object using the binary search algorithm.
- **copy(List<? super T> dest, List<? extends T> src)**: Copies all elements from the source list into the destination list.
Example:
```java
import java.util.*;
public class AlgorithmsExample {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(3, 5, 1, 4, 2));
System.out.println("Original list: " + list);
Collections.sort(list);
System.out.println("Sorted list: " + list);
Collections.reverse(list);
System.out.println("Reversed list: " + list);
Collections.shuffle(list);
System.out.println("Shuffled list: " + list);
int index = Collections.binarySearch(list, 3);
System.out.println("Index of element 3: " + index);
}
}
```
#### Conclusion
The Java Collections Framework provides a comprehensive set of interfaces and classes for managing collections of objects. Understanding and effectively utilizing these collections is essential for writing efficient and maintainable Java programs.
Comments