Collection

public class CollectionDemo {

public static void main(String[] args) {

Collection<String> collection = new ArrayList<>();

collection.add("Apple");
collection.add("Banana");
collection.add("Cherry");
System.out.println("Collection after adding elements: " +
collection);

Collection<String> moreFruits = Arrays.asList("Date",

"Elderberry", "Fig");
collection.addAll(moreFruits);
System.out.println("Collection after addAll(): " +
collection);
System.out.println("Collection after equal(): " + c

ollection.equals(morefruits));

collection.remove("Banana");
System.out.println("Collection after remove('Banana'): "
+ collection);

Collection<String> toRemove = Arrays.asList("Apple",

"Cherry");
collection.removeAll(toRemove);
System.out.println("Collection after removeAll(): " +
collection);

System.out.println("Contains 'Date'?: " +

collection.contains("Date"));

Collection<String> checkFruits = Arrays.asList("Date",

"Elderberry");
System.out.println("Contains all checkFruits?: " +
collection.containsAll(checkFruits));
 System.out.println("Is collection empty?: " +
collection.isEmpty());

System.out.println("Collection size: " +

collection.size());

Collection<String> retainFruits =
Arrays.asList("Elderberry", "Fig");
collection.retainAll(retainFruits);
System.out.println("Collection after retainAll(): " +
collection);

collection.clear();
System.out.println("Collection after clear(): " +
collection);
System.out.println("Is collection empty after clear()?: "
+ collection.isEmpty());
}
}

Arraylist
import java.util.*;
class ArrayListDemo {
public static void main(String args[])
{ // Create an array list.
ArrayList <String>al = new ArrayList<String>();
System.out.println("Initial size of al: " + al.size());
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");

System.out.println("Size of al after additions: " + al.size());

// Display the array list.
System.out.println("Contents of al: " + al);
// Remove elements from the array list.
al.remove("F");
al.remove(2);
System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);
}
}

Generic
class Test<T> {
// An object of type T is declared
T obj;
Test(T obj) { this.obj = obj; } // constructor
public T getObject() { return this.obj; }
}

// Driver class to test above

class Main {
public static void main(String[] args)
{
// instance of Integer type
Test<Integer> iObj = new Test<Integer>(15);
System.out.println(iObj.getObject());

// instance of String type

Test<String> sObj
= new Test<String>("GeeksForGeeks");
System.out.println(sObj.getObject());
}
}

List example
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class ListExample {
public static void main(String[] args) {
List<Integer> numbers = new
ArrayList<>(Arrays.asList(10, 20, 30, 40, 50));

numbers.add(2, 25);
System.out.println("After add(2, 25): " +
numbers);

List<Integer> extraNumbers = Arrays.asList(60, 70);

numbers.addAll(3, extraNumbers);
 System.out.println("After addAll(3, [60, 70]): " +
numbers);
int valueAt4 = numbers.get(4);
System.out.println("Element at index 4: " +
valueAt4);

numbers.set(1, 15);
System.out.println("After set(1, 15): " + numbers);

int index = numbers.indexOf(30);

System.out.println("Index of 30: " + index);

numbers.add(30);
System.out.println("new list " + numbers);

int lastIndex = numbers.lastIndexOf(30);

System.out.println("Last index of 30: " + lastIndex);

List<Integer> subList = numbers.subList(2, 6);

System.out.println("SubList (2 to 5): " +

subList);
}
}

Linked List

import java.util.*;
class LinkedListDemo {
public static void main(String args[])
{
// Create a linked list.
LinkedList<String> ll = new LinkedList<String>();
// Add elements to the linked list.
ll.add("F");
ll.add("B");
ll.add("D");
ll.add("E");
ll.add("C");
ll.addLast("Z");
ll.addFirst("A");
ll.add(1, "A2");
ll.size();
System.out.println("Original contents of ll: " + ll);
ll.remove("F");
System.out.println("Contents of ll after deletion: " + ll);
ll.remove(2);
System.out.println("Contents of ll after deletion: " + ll);

// Remove first and last elements.

ll.removeFirst();
ll.removeLast();
System.out.println("ll after deleting first and last: "+ ll);

String val = ll.get(2);

System.out.println("val: " + val);
ll.set(2, val + " Changed");
System.out.println("ll after change: " + ll);
}
}

Navigable set

import java.util.*;

public class NavigableSetExample {

public static void main(String[] args) {
// NavigableSet<Integer> navSet = new
TreeSet<>(Arrays.asList(10, 20, 30, 40, 50));
NavigableSet<Integer> navSet = new TreeSet<>();
navSet.add(10);
navSet.add(30);
navSet.add(20);
navSet.add(20);
navSet.add(40);
navSet.add(50);
navSet.add(60);
System.out.println("elements are:"+navSet);
System.out.println("ceiling(25): " + navSet.ceiling(25));
System.out.println("floor(25): " + navSet.floor(25));

System.out.println("higher(30): " + navSet.higher(30));

System.out.println("lower(30): " + navSet.lower(30));

System.out.print("Descending order: ");

 Iterator<Integer> descIt = navSet.descendingIterator();
while (descIt.hasNext()) {
System.out.print(descIt.next() + " ");
}
System.out.println();

System.out.println("Descending Set: " +

navSet.descendingSet());

System.out.println("headSet(40, true): " +

navSet.headSet(40));

System.out.println("tailSet(30, true): " +

navSet.tailSet(30));

System.out.println("subSet(20,40): " +
navSet.subSet(20,40));

System.out.println("pollFirst(): " +
navSet.pollFirst());
System.out.println("After pollFirst: " + navSet);

System.out.println("pollLast(): " + navSet.pollLast());

System.out.println("After pollLast: " + navSet);
}
}

SortedSet

import java.util.TreeSet;
import java.util.SortedSet;

public class SortedSetExample {

public static void main(String[] args) {

SortedSet<Integer> numbers = new TreeSet<>();

numbers.add(10);
numbers.add(30);
numbers.add(20);
numbers.add(50);
 numbers.add(40);

System.out.println("SortedSet: " + numbers);

System.out.println("First Element: " + numbers.first());

System.out.println("Last Element: " + numbers.last());

SortedSet<Integer> subset = numbers.subSet(20, 40);

System.out.println("Subset (20 to 40): " + subset);

SortedSet<Integer> headset = numbers.headSet(30);

System.out.println("HeadSet (less than 30): " + headset);

SortedSet<Integer> tailset = numbers.tailSet(30);

System.out.println("TailSet (greater than or equal to
30): " + tailset);
}
}

Queue
import java.util.*;

public class QueueExample {

public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();

queue.offer(10);
queue.offer(20);
queue.offer(30);
System.out.println("Queue after offer(): " + queue);

System.out.println("element(): " + queue.element());

System.out.println("peek(): " + queue.peek());

System.out.println("poll(): " + queue.poll());

System.out.println("Queue after poll(): " + queue);

 System.out.println("remove(): " + queue.remove());

System.out.println("Queue after remove(): " + queue);

queue.poll();

try {
System.out.println("element(): " + queue.element());
}
catch (NoSuchElementException e) {
System.out.println("element() failed: Queue is
empty!");
}

try {
System.out.println("remove(): " + queue.remove());
}
catch (NoSuchElementException e) {
System.out.println("remove() failed: Queue is
empty!");
}

System.out.println("peek() on empty queue: " +

queue.peek()); // Output: null
System.out.println("poll() on empty queue: " +
queue.poll()); // Output: null*/
}
}

QueueDeque
import java.util.*;

public class QueueDequeExample {

public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();

queue.offer(10);
queue.offer(20);
queue.offer(30);
 System.out.println("Element(): " + queue.element()); //
Throws exception if empty
System.out.println("Peek(): " + queue.peek()); // Returns
null if empty

System.out.println("Poll(): " + queue.poll()); //

Returns null if empty
System.out.println("Remove(): " + queue.remove()); //
Throws exception if empty

Deque<Integer> deque = new LinkedList<>();

// Adding elements at first and last

deque.addFirst(100);
deque.addLast(200);
deque.offerFirst(50);
deque.offerLast(300);

// Accessing elements
System.out.println("GetFirst(): " + deque.getFirst()); //
Throws exception if empty
System.out.println("GetLast(): " + deque.getLast()); //
Throws exception if empty
System.out.println("PeekFirst(): " + deque.peekFirst());
// Returns null if empty
System.out.println("PeekLast(): " + deque.peekLast()); //
Returns null if empty

// Removing elements
System.out.println("PollFirst(): " + deque.pollFirst());
// Returns null if empty
System.out.println("PollLast(): " + deque.pollLast()); //
Returns null if empty
System.out.println("Pop(): " + deque.pop()); // Throws
exception if empty
deque.push(500); // Adds to front

// Removing first and last occurrence

deque.add(400);
deque.add(400);
System.out.println("RemoveFirstOccurrence(400): " +
deque.removeFirstOccurrence(400));
System.out.println("RemoveLastOccurrence(400): " +
deque.removeLastOccurrence(400));
 // Iterating in reverse
System.out.println("Descending Iterator:");
Iterator<Integer> iterator = deque.descendingIterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}

Foreach
import java.util.*;
class ForEachDemo {
public static void main(String args[]) {
// Create an array list for integers.
ArrayList<Integer> vals = new ArrayList<Integer>();
// Add values to the array list.
vals.add(1);
vals.add(2);
vals.add(3);
vals.add(4);
vals.add(5);
// Use for loop to display the values.
System.out.print("Contents of vals: ");
for(int v : vals)
System.out.print(v + " ");
System.out.println();

// Now, sum the values by using a for loop.

int sum = 0;
for(int v : vals)
sum += v;
System.out.println("Sum of values: " + sum);
}
}

Enumset
import java.util.EnumSet;
import java.util.List;

enum Day {
 MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY,
SUNDAY;
}

public class EnumSetDemo {

public static void main(String[] args) {

EnumSet<Day> allDays = EnumSet.allOf(Day.class);

System.out.println("All Days: " + allDays);

EnumSet<Day> weekdays = EnumSet.range(Day.MONDAY,

Day.FRIDAY);
EnumSet<Day> weekends = EnumSet.complementOf(weekdays);
System.out.println("Weekdays: " + weekdays);
System.out.println("Weekends: " + weekends);

EnumSet<Day> copyWeekdays = EnumSet.copyOf(weekdays);

System.out.println("Copy of Weekdays: " + copyWeekdays);

List<Day> someDaysList = List.of(Day.WEDNESDAY,

Day.FRIDAY);
EnumSet<Day> fromList = EnumSet.copyOf(someDaysList);
System.out.println("EnumSet from List: " + fromList);

EnumSet<Day> emptySet = EnumSet.noneOf(Day.class);

System.out.println("Empty EnumSet: " + emptySet);

EnumSet<Day> selectedDays = EnumSet.of(Day.MONDAY,

Day.WEDNESDAY, Day.FRIDAY);
System.out.println("Selected Days: " + selectedDays);

EnumSet<Day> singleDay = EnumSet.of(Day.TUESDAY);

System.out.println("Single Day: " + singleDay);

EnumSet<Day> twoDays = EnumSet.of(Day.THURSDAY,

Day.SATURDAY);
System.out.println("Two Days: " + twoDays);
 EnumSet<Day> threeDays = EnumSet.of(Day.MONDAY,
Day.WEDNESDAY, Day.FRIDAY);
System.out.println("Three Days: " + threeDays);

EnumSet<Day> midWeek = EnumSet.range(Day.TUESDAY,

Day.THURSDAY);
System.out.println("Mid Week Days: " + midWeek);
}
}

Comparator
import java.util.*;
class students
{
String name;
int marks;
students(String s,int m)
{
name=s;
marks=m;
}
//public String toString()
// {
// return name+" "+marks;
//}
}

class studentnamecomp implements Comparator

{
public int compare(Object a,Object b)
{
students s1=(students)a;
students s2=(students)b;
return s1.name.compareTo(s2.name);
}

}
class studentsnamedescomp implements Comparator
{
public int compare(Object a,Object b)
 {
students s1=(students)a;
students s2=(students)b;
return s2.name.compareTo(s1.name);
}

public class hash_obj_comp

{
public static void main(String args[])
{
students std1=new students("aa",89);
students std2=new students("ha",90);
students std3=new students("dk",76);
TreeSet<students> ts=new TreeSet<students>(new
studentnamecomp());
ts.add(std1);
ts.add(std2);
ts.add(std3);
System.out.println("ojects of the treeset based on name");
System.out.println(ts);
TreeSet<students> ts1=new TreeSet<students>(new
studentsnamedescomp());
ts1.add(std1);
ts1.add(std2);
ts1.add(std3);

System.out.println("ojects of the treeset based on name");

System.out.println(ts1);
}
}
Hashiterator
import java.util.HashSet;
import java.util.Iterator;

public class Hashiterator

{
public static void main(String[] args)
{

// Create a HashSet of Strings

 HashSet<String> hs = new HashSet<>();

// Add elements to the HashSet

hs.add("A");
hs.add("B");
hs.add("Geeks");
hs.add("For");
hs.add("Geeks");
hs.add("Z");

// Using iterator() method to iterate

// Over the HashSet
System.out.print("Using iterator : ");
Iterator<String> iterator = hs.iterator();

// Traversing HashSet
while (iterator.hasNext())
System.out.print(iterator.next() + ", ");

System.out.println();

// Using enhanced for loop to iterate

// Over the HashSet
System.out.print("Using enhanced for loop : ");
for (String element : hs)
System.out.print(element + " , ");

}
}

Hashset
import java.util.*;

public class HashSetExample {

public static void main(String[] args) {
HashSet<String> defaultSet = new HashSet<>();
defaultSet.add("Apple");
defaultSet.add("Banana");
defaultSet.add("Cherry");
System.out.println("Default HashSet: " + defaultSet);

List<String> fruits = Arrays.asList("Mango", "Orange",

"Grapes");
 HashSet<String> collectionSet = new HashSet<>(fruits);
System.out.println("HashSet from Collection: " +
collectionSet);

HashSet<Integer> capacitySet = new HashSet<>(10);

capacitySet.add(1);
capacitySet.add(2);
capacitySet.add(3);
System.out.println("HashSet with Capacity 10: " +
capacitySet);

HashSet<Double> customSet = new HashSet<>(5, 0.5f);

customSet.add(2.5);
customSet.add(3.5);
customSet.add(4.5);
System.out.println("HashSet with Custom Load Factor: " +
customSet);
}
}

Iterator
import java.util.*;
class IteratorDemo {
public static void main(String args[]) {

ArrayList<String> al = new ArrayList<String>();

al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");

System.out.print("Original contents of al: ");

Iterator<String> itr = al.iterator();
while(itr.hasNext()) {
String element = itr.next();
System.out.print(element + " ");
}
System.out.println();
 ListIterator<String> litr = al.listIterator();
while(litr.hasNext()) {
String element = litr.next();
litr.set(element + "+");
}
System.out.print("Modified contents of al: ");
itr = al.iterator();
while(itr.hasNext()) {
String element = itr.next();
System.out.print(element + " ");
}
System.out.println();

System.out.print("Modified list backwards: ");

while(litr.hasPrevious()) {
String element = litr.previous();
System.out.print(element + " ");
}
System.out.println();
}
}

Task(String name, int timestamp) {

this.name = name;
this.timestamp = timestamp;
}

@Override
public String toString() {
return name + " (" + timestamp + ")";
}
}

public class CustomPriorityQueue {

public static void main(String[] args) {
PriorityQueue<Task> pq = new PriorityQueue<>(Comparator.comparingInt(task -> task.timestamp));

pq.add(new Task("Task1", 10));

pq.add(new Task("Task2", 5));
pq.add(new Task("Task3", 20));

while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
 }
}

nullsFirst(Comparator<? super T> comp)

import java.util.*;

public class NullsFirstExample {

public static void main(String[] args) {
List<String> words = Arrays.asList("Banana", null, "Apple", "Mango", null);

// Sorting with nulls first

words.sort(Comparator.nullsFirst(Comparator.naturalOrder()));

System.out.println("Sorted with nulls first: " + words);

}
}

nullsLast(Comparator<? super T> comp)

import java.util.*;

public class NullsLastExample {

public static void main(String[] args) {
List<String> words = Arrays.asList("Banana", null, "Apple", "Mango", null);

// Sorting with nulls last

words.sort(Comparator.nullsLast(Comparator.naturalOrder()));

System.out.println("Sorted with nulls last: " + words);

}
}

thenComparing(Comparator<? super T> thenByComp)

import java.util.*;

class Student {
String name;
int age;

Student(String name, int age) {

this.name = name;
 this.age = age;
}

public String toString() {

return name + " (" + age + ")";
}
}

public class ThenComparingExample {

public static void main(String[] args) {
List<Student> students = Arrays.asList(
new Student("John", 22),
new Student("Alice", 25),
new Student("Bob", 22),
new Student("Charlie", 20)
);

// Sort by age, then by name

students.sort(Comparator.comparingInt(s -> s.age)
.thenComparing(s -> s.name));

System.out.println("Sorted by age, then name: " + students);

}
}/// output: Sorted by age, then name: [Charlie (20), Bob (22), John (22), Alice (25)]

thenComparing(Function<? super T, ? extends U> getKey)

students.sort(Comparator.comparingInt(s -> s.age).thenComparing(Student::getName));

thenComparingDouble(ToDoubleFunction<? super T> getKey)

students.sort(Comparator.comparingDouble(Student::getGPA)
.thenComparing(Student::getName));

thenComparingInt(ToIntFunction<? super T> getKey)

students.sort(Comparator.comparingInt(Student::getAge)
.thenComparing(Student::getName));