Home » Tutorials » Misc » Page 2
Category:

Misc

Misc

Java LinkedList Tutorial

written by 75ypsaw71

LinkedList is part of the Java Collections Framework and implements both the List and Deque interfaces. Unlike an ArrayList, which uses a dynamic array, LinkedList is a doubly linked list structure where each element (node) stores a reference to both the next and previous elements.

This makes it efficient for insertion and deletion operations at both ends.

In this tutorial, we'll explore how to use LinkedList in Java, including common operations with various code examples.

1. Creating a LinkedList

To create a LinkedList, you can declare it with any data type. You can create a list to store String, Integer, or any other object type.

Example:

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // Creating a LinkedList of String type
        LinkedList fruits = new LinkedList<>();

        // Adding elements to the LinkedList
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Displaying the LinkedList
        System.out.println("LinkedList: " + fruits);
    }
}

Explanation:

A LinkedList of type String is created.
The add() method adds elements to the list.

Output:

LinkedList: [Apple, Banana, Cherry].

2. Adding Elements to a LinkedList

Elements can be added at the beginning, end, or at a specific position in the LinkedList.

Example:

import java.util.LinkedList;

public class AddElements {
    public static void main(String[] args) {
        LinkedList numbers = new LinkedList<>();

        // Adding elements to the LinkedList
        numbers.add(10);  // Add to the end
        numbers.add(20);  // Add to the end

        // Adding element at the first position
        numbers.addFirst(5);

        // Adding element at the last position
        numbers.addLast(30);

        // Adding element at a specific index
        numbers.add(2, 15);  // Adds 15 at index 2

        // Displaying the LinkedList
        System.out.println("LinkedList: " + numbers);
    }
}

Explanation:

addFirst() inserts an element at the beginning.
addLast() inserts an element at the end.
add(index, element) inserts an element at a specific index.

Output:
LinkedList: [5, 10, 15, 20, 30].

3. Accessing Elements in a LinkedList

Elements can be accessed using methods like get(), getFirst(), and getLast().

Example:

import java.util.LinkedList;

public class AccessElements {
    public static void main(String[] args) {
        LinkedList fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Accessing elements
        String firstFruit = fruits.getFirst();
        String lastFruit = fruits.getLast();
        String secondFruit = fruits.get(1);  // Accessing the element at index 1

        System.out.println("First Fruit: " + firstFruit);
        System.out.println("Second Fruit: " + secondFruit);
        System.out.println("Last Fruit: " + lastFruit);
    }
}

Explanation:

getFirst() retrieves the first element.
getLast() retrieves the last element.
get(index) retrieves the element at the specified index.

Output:

First Fruit: Apple
Second Fruit: Banana
Last Fruit: Cherry

4. Removing Elements from a LinkedList

You can remove elements from the beginning, end, or any specific index using removeFirst(), removeLast(), or remove(index).

Example:

import java.util.LinkedList;

public class RemoveElements {
    public static void main(String[] args) {
        LinkedList fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Removing the first and last elements
        String removedFirst = fruits.removeFirst();
        String removedLast = fruits.removeLast();

        // Removing an element at a specific index
        String removedAtIndex = fruits.remove(0);  // Removes the element at index 0

        System.out.println("Removed First: " + removedFirst);
        System.out.println("Removed Last: " + removedLast);
        System.out.println("Removed at Index 0: " + removedAtIndex);
        System.out.println("LinkedList after removals: " + fruits);
    }
}

Explanation:

removeFirst() removes and returns the first element.
removeLast() removes and returns the last element.
remove(index) removes the element at the specified index.

Output:

Removed First: Apple
Removed Last: Cherry
Removed at Index 0: Banana
LinkedList after removals: []

5. Iterating Over a LinkedList

You can iterate over a LinkedList using a for-each loop, iterator, or the forEach() method with lambda expressions.

Example Using For-Each Loop:

import java.util.LinkedList;

public class IterateLinkedList {
    public static void main(String[] args) {
        LinkedList fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Iterating using for-each loop
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Example Using Lambda Expression:

import java.util.LinkedList;

public class IterateWithLambda {
    public static void main(String[] args) {
        LinkedList fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Iterating using forEach and lambda expression
        fruits.forEach(fruit -> System.out.println(fruit));
    }
}

Explanation:

Both examples iterate over the elements of the LinkedList and print them. The output will be:

Apple
Banana
Cherry

6. Checking if LinkedList is Empty

You can check whether the LinkedList is empty or not using the isEmpty() method.

Example:

import java.util.LinkedList;

public class CheckEmpty {
    public static void main(String[] args) {
        LinkedList fruits = new LinkedList<>();

        // Checking if the LinkedList is empty
        boolean isEmpty = fruits.isEmpty();
        System.out.println("Is LinkedList empty? " + isEmpty);

        // Adding an element
        fruits.add("Apple");

        // Checking again after adding an element
        isEmpty = fruits.isEmpty();
        System.out.println("Is LinkedList empty? " + isEmpty);
    }
}

Explanation:

isEmpty() returns true if the LinkedList contains no elements, false otherwise.

Output:

Is LinkedList empty? true
Is LinkedList empty? false

7. LinkedList Size

To get the number of elements in a LinkedList, you can use the size() method.

Example:

import java.util.LinkedList;

public class LinkedListSize {
    public static void main(String[] args) {
        LinkedList fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Getting the size of the LinkedList
        int size = fruits.size();
        System.out.println("Size of LinkedList: " + size);
    }
}

Explanation:

size() returns the number of elements in the LinkedList.

Output:
Size of LinkedList: 3.

8. Using LinkedList as a Queue

Since LinkedList implements the Deque interface, it can be used as both a queue (FIFO) and a stack (LIFO). Below is an example of using it as a queue.

Example:

import java.util.LinkedList;

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

        // Enqueue elements
        queue.addLast("John");
        queue.addLast("Alice");
        queue.addLast("Bob");

        // Dequeue elements
        System.out.println("Dequeued: " + queue.removeFirst());  // Dequeue first element (John)
        System.out.println("Dequeued: " + queue.removeFirst());  // Dequeue second element (Alice)

        // Display the remaining elements
        System.out.println("Remaining in queue: " + queue);
    }
}

Explanation:

addLast() enqueues elements at the end of the list.
removeFirst() dequeues elements from the front.

Output:

Dequeued: John
Dequeued: Alice
Remaining in queue: [Bob]

9. Using LinkedList as a Stack

You can also use a LinkedList as a stack (LIFO).

Example:

import java.util.LinkedList;

public class LinkedListAsStack {
    public static void main(String[] args) {
        LinkedList stack = new LinkedList<>();

        // Push elements onto the stack
        stack.addFirst("John");
        stack.addFirst("Alice");
        stack.addFirst("Bob");

        // Pop elements from the stack
        System.out.println("Popped: " + stack.removeFirst());  // Pop top element (Bob)
        System.out.println("Popped: " + stack.removeFirst());  // Pop second element (Alice)

        // Display the remaining elements
        System.out.println("Remaining in stack: " + stack);
    }
}

Explanation:

addFirst() pushes elements onto the stack.
removeFirst() pops elements from the stack (LIFO behavior).

Output:

Popped: Bob
Popped: Alice
Remaining in stack: [John]

10. Clearing All Elements in a LinkedList

To remove all elements from a LinkedList, you can use the clear() method.

Example:

import java.util.LinkedList;

public class ClearLinkedList {
    public static void main(String[] args) {
        LinkedList fruits = new LinkedList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // Clearing the LinkedList
        fruits.clear();

        // Checking if the LinkedList is empty
        System.out.println("Is LinkedList empty? " + fruits.isEmpty());
    }
}

Explanation:

The clear() method removes all elements from the LinkedList.

Output:

Is LinkedList empty? true.

Conclusion

LinkedList is an essential part of the Java Collections Framework that allows for efficient insertion and deletion at both ends of the list.

It can be used as a list, queue, or stack, and is particularly useful when you need fast insertions and deletions from the middle or ends of the list.

This tutorial has covered the most common operations you'll need to perform with a LinkedList, including adding, removing, accessing, and iterating over elements. Each example is designed to showcase a different feature of the LinkedList in Java.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java HashSet Tutorial

written by 75ypsaw71

A HashSet is a part of the Java Collections Framework and implements the Set interface. It is used to store unique elements (no duplicates) and allows null values.

It does not maintain any particular order of the elements. HashSet is backed by a HashMap, and it uses hashing to store elements, offering constant time performance (on average) for the basic operations: add, remove, contains, and size.

In this tutorial, we'll cover the most common operations with HashSet along with several code examples to help you understand how it works.

1. Creating a HashSet

To create a HashSet, you simply declare it with the type of elements it will hold, and you can optionally initialize it with some capacity.

Example:

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        // Creating a HashSet of String type
        HashSet fruits = new HashSet<>();

        // Adding elements to the HashSet
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Displaying the HashSet
        System.out.println("HashSet: " + fruits);
    }
}

Explanation:

We declare a HashSet to store String objects.
add() method is used to insert elements into the set.

Output:
HashSet: [Apple, Banana, Orange].

2. Adding Elements to a HashSet

You can add elements to the HashSet using the add() method. If you try to add a duplicate element, the set will ignore it since HashSet does not allow duplicates.

Example:

import java.util.HashSet;

public class AddElements {
    public static void main(String[] args) {
        HashSet numbers = new HashSet<>();

        // Adding elements to the HashSet
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Trying to add a duplicate element
        boolean added = numbers.add(20); // Will return false

        System.out.println("HashSet: " + numbers);
        System.out.println("Was 20 added again? " + added);
    }
}

Explanation:

The add() method inserts elements into the set.
Trying to add a duplicate element (20) returns false, as sets do not allow duplicates.

Output:

HashSet: [10, 20, 30]
Was 20 added again? false

3. Checking if an Element Exists

You can check if an element is present in the HashSet using the contains() method. It returns true if the element exists and false otherwise.

Example:

import java.util.HashSet;

public class ContainsElement {
    public static void main(String[] args) {
        HashSet fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Check if "Banana" exists
        boolean hasBanana = fruits.contains("Banana");
        System.out.println("Does HashSet contain Banana? " + hasBanana);
    }
}

Explanation:

The contains() method checks if the element “Banana” is present in the HashSet.

Output:

Does HashSet contain Banana? true.

4. Removing Elements from a HashSet

You can remove elements from a HashSet using the remove() method. If the element exists, it will be removed and the method will return true; otherwise, it will return false.

Example:

import java.util.HashSet;

public class RemoveElement {
    public static void main(String[] args) {
        HashSet fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Removing "Banana" from the HashSet
        boolean removed = fruits.remove("Banana");
        System.out.println("Was Banana removed? " + removed);

        // Trying to remove an element that doesn't exist
        boolean removedMango = fruits.remove("Mango");
        System.out.println("Was Mango removed? " + removedMango);

        // Displaying the HashSet after removal
        System.out.println("HashSet: " + fruits);
    }
}

Explanation:

remove(“Banana”) removes the “Banana” element and returns true.
remove(“Mango”) attempts to remove an element that doesn't exist, and returns false.

Output:

Was Banana removed? true
Was Mango removed? false
HashSet: [Apple, Orange]

5. Iterating over a HashSet

You can iterate over a HashSet using enhanced for loops or the forEach() method with lambda expressions.

Using Enhanced For Loop:

import java.util.HashSet;

public class IterateHashSet {
    public static void main(String[] args) {
        HashSet fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Iterating over HashSet using enhanced for loop
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Using forEach() Method with Lambda Expression:

import java.util.HashSet;

public class IterateWithLambda {
    public static void main(String[] args) {
        HashSet fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Iterating over HashSet using forEach and lambda expression
        fruits.forEach(fruit -> System.out.println(fruit));
    }
}

Explanation:

Both examples iterate over each element in the HashSet and print them.
Since HashSet does not guarantee any particular order, the output may vary.

6. Checking the Size of a HashSet

You can check how many elements are present in a HashSet using the size() method.

Example:

import java.util.HashSet;

public class HashSetSize {
    public static void main(String[] args) {
        HashSet fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Checking the size of the HashSet
        int size = fruits.size();
        System.out.println("Size of HashSet: " + size);
    }
}

Explanation:

size() returns the number of elements in the HashSet.

Output:

Size of HashSet: 3.

7. Clearing All Elements in a HashSet

You can remove all elements from a HashSet using the clear() method.

Example:

import java.util.HashSet;

public class ClearHashSet {
    public static void main(String[] args) {
        HashSet fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Clearing all elements from the HashSet
        fruits.clear();

        // Checking if the HashSet is empty
        boolean isEmpty = fruits.isEmpty();
        System.out.println("Is HashSet empty? " + isEmpty);
    }
}

Explanation:

clear() removes all elements from the HashSet.
isEmpty() checks if the set is empty after clearing it.

Output:

Is HashSet empty? true.

8. Combining Two HashSets (Union)

You can combine two HashSet objects by using the addAll() method, which adds all elements from one set to another.

Example:

import java.util.HashSet;

public class CombineHashSets {
    public static void main(String[] args) {
        HashSet set1 = new HashSet<>();
        set1.add("Apple");
        set1.add("Banana");

        HashSet set2 = new HashSet<>();
        set2.add("Orange");
        set2.add("Apple"); // Duplicate element

        // Union of set1 and set2
        set1.addAll(set2);

        // Displaying the combined HashSet
        System.out.println("Combined HashSet: " + set1);
    }
}

Explanation:

addAll() combines two sets by adding all elements from set2 to set1. Duplicate elements (like “Apple”) are ignored.

Output:

Combined HashSet: [Apple, Banana, Orange].

9. Finding Common Elements (Intersection)

You can find the common elements between two HashSet objects by using the retainAll() method.

Example:

import java.util.HashSet;

public class IntersectionHashSets {
    public static void main(String[] args) {
        HashSet set1 = new HashSet<>();
        set1.add("Apple");
        set1.add("Banana");
        set1.add("Cherry");

        HashSet set2 = new HashSet<>();
        set2.add("Banana");
        set2.add("Cherry");
        set2.add("Orange");

        // Intersection of set1 and set2
        set1.retainAll(set2);

        // Displaying the common elements
        System.out.println("Common elements: " + set1);
    }
}

Explanation:

retainAll() keeps only the elements that are common between set1 and set2.

Output:

Common elements: [Banana, Cherry].

10. Removing Common Elements (Difference)

You can remove the common elements between two HashSet objects using the removeAll() method.

Example:

import java.util.HashSet;

public class DifferenceHashSets {
    public static void main(String[] args) {
        HashSet set1 = new HashSet<>();
        set1.add("Apple");
        set1.add("Banana");
        set1.add("Cherry");

        HashSet set2 = new HashSet<>();
        set2.add("Banana");
        set2.add("Cherry");
        set2.add("Orange");

        // Difference between set1 and set2
        set1.removeAll(set2);

        // Displaying the result
        System.out.println("Elements in set1 after removing common elements: " + set1);
    }
}

Explanation:

removeAll() removes all elements that are common between set1 and set2.

Output:

Elements in set1 after removing common elements: [Apple].

11. HashSet with Custom Objects

You can use custom objects in a HashSet, but you need to override the equals() and hashCode() methods to ensure correct behavior.

Example:

import java.util.HashSet;
import java.util.Objects;

class Employee {
    String name;
    int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id == employee.id && Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

public class HashSetCustomObject {
    public static void main(String[] args) {
        HashSet employees = new HashSet<>();

        employees.add(new Employee("John", 101));
        employees.add(new Employee("Alice", 102));
        employees.add(new Employee("John", 101)); // Duplicate based on equals() and hashCode()

        // Displaying the HashSet
        employees.forEach(emp -> System.out.println(emp.name + " - " + emp.id));
    }
}

Explanation:

We override equals() and hashCode() to ensure that objects are compared correctly in the HashSet.

Output:

John - 101
Alice - 102

Conclusion

The HashSet class is a powerful tool when you need to store unique elements in an unordered collection.

It is very efficient in terms of performance due to its constant-time complexity for common operations like add, remove, and contains.

Using HashSet is especially useful when you need to avoid duplicate entries in your collection.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java HashMap Tutorial

written by 75ypsaw71

HashMap is a part of the Java Collections Framework and is used to store key-value pairs. It implements the Map interface and uses a technique called hashing to store the elements.

HashMap provides fast access, insertion, and deletion (on average, O(1) time complexity).

In this tutorial, we will explore the most common operations that you can perform with a HashMap, along with code examples to help you understand how it works.

1. Creating a HashMap

You can create a HashMap to store elements of any data type for both key and value.

Example:

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        // Creating a HashMap of Integer keys and String values
        HashMap<Integer, String> map = new HashMap<>();

        // Adding key-value pairs
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        // Displaying the HashMap
        System.out.println("HashMap: " + map);
    }
}

Explanation:

HashMap<Integer, String>: Integer is the key type, and String is the value type.
The put() method is used to insert key-value pairs.

Output: HashMap: {1=Apple, 2=Banana, 3=Cherry}.

2. Adding Elements to HashMap

To add elements to a HashMap, use the put() method. If the key already exists, the new value will replace the existing value.

Example:

public class AddElements {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();

        // Adding key-value pairs
        map.put("John", 25);
        map.put("Alice", 30);
        map.put("Bob", 22);

        // Printing the map
        System.out.println("HashMap: " + map);
    }
}

Explanation:

Here, keys are String (names), and values are Integer (ages).

put() adds each key-value pair to the map.

Output: HashMap: {John=25, Alice=30, Bob=22}.

3. Accessing Elements in HashMap

To access elements, use the get() method, passing the key as an argument. If the key does not exist, it returns null.

Example:

public class AccessElements {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        // Accessing value associated with key 2
        String value = map.get(2);
        System.out.println("Value for key 2: " + value);
    }
}

Explanation:

The get() method fetches the value associated with key 2.

Output: Value for key 2: Banana.

4. Removing Elements from HashMap

To remove an element from the HashMap, use the remove() method, passing the key of the element to be removed.

Example:

public class RemoveElements {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("John", 25);
        map.put("Alice", 30);
        map.put("Bob", 22);

        // Removing the entry with key "Alice"
        map.remove("Alice");

        // Displaying the HashMap after removal
        System.out.println("HashMap after removal: " + map);
    }
}

Explanation:

The remove() method deletes the entry with the key “Alice”.
Output: HashMap after removal: {John=25, Bob=22}.

5. Checking if a Key or Value Exists

You can use the containsKey() and containsValue() methods to check whether a key or value exists in the HashMap.

Example:

public class KeyValueCheck {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        // Check if key 2 exists
        boolean keyExists = map.containsKey(2);
        System.out.println("Key 2 exists: " + keyExists);

        // Check if value "Banana" exists
        boolean valueExists = map.containsValue("Banana");
        System.out.println("Value 'Banana' exists: " + valueExists);
    }
}

Explanation:

containsKey(2) checks if the key 2 exists in the HashMap.
containsValue(“Banana”) checks if the value “Banana” exists.

Output:

Key 2 exists: true
Value 'Banana' exists: true

6. Iterating over a HashMap

There are several ways to iterate over a HashMap, using forEach(), entrySet(), or key and value sets.

Using forEach() Method:

import java.util.HashMap;

public class IterateHashMap {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("John", 25);
        map.put("Alice", 30);
        map.put("Bob", 22);

        // Iterate using forEach
        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

Explanation:

forEach() method is a convenient way to iterate over each key-value pair.

Output:

John: 25
Alice: 30
Bob: 22

Using entrySet():

import java.util.HashMap;
import java.util.Map;

public class IterateEntrySet {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        // Iterate using entrySet
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

Explanation:

entrySet() returns a set of key-value pairs (Map.Entry objects), which allows iteration.

Output:

Key: 1, Value: Apple
Key: 2, Value: Banana
Key: 3, Value: Cherry

7. Replacing a Value in HashMap

You can use the replace() method to update the value associated with a specific key.

Example:

public class ReplaceValue {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        // Replacing value of key 2
        map.replace(2, "Blueberry");

        // Displaying the updated HashMap
        System.out.println("Updated HashMap: " + map);
    }
}

Explanation:

The replace() method updates the value associated with key 2 from “Banana” to “Blueberry”.

Output: Updated HashMap: {1=Apple, 2=Blueberry, 3=Cherry}.

8. Checking the Size of the HashMap

You can use the size() method to find out how many key-value pairs are stored in the HashMap.

Example:

public class HashMapSize {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("John", 25);
        map.put("Alice", 30);
        map.put("Bob", 22);

        // Checking the size of the HashMap
        int size = map.size();
        System.out.println("Size of HashMap: " + size);
    }
}

Explanation:

size() returns the number of key-value pairs in the HashMap.

Output: Size of HashMap: 3.

9. Clearing a HashMap

You can clear all entries from a HashMap using the clear() method.

Example:

public class ClearHashMap {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("John", 25);
        map.put("Alice", 30);
        map.put("Bob", 22);

        // Clearing the HashMap
        map.clear();

        // Checking if HashMap is empty
        System.out.println("Is HashMap empty? " + map.isEmpty());
    }
}

Explanation:

The clear() method removes all entries from the HashMap.
Output: Is HashMap empty? true.

10. HashMap with Custom Objects

You can use custom objects as keys or values in a HashMap, but it’s important to override the equals() and hashCode() methods when using objects as keys.

Example:

import java.util.HashMap;
import java.util.Objects;

class Employee {
    String name;
    int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id == employee.id && Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

public class HashMapCustomObjects {
    public static void main(String[] args) {
        HashMap<Employee, String> map = new HashMap<>();

        Employee e1 = new Employee("John", 1);
        Employee e2 = new Employee("Alice", 2);

        map.put(e1, "Manager");
        map.put(e2, "Developer");

        // Displaying the HashMap
        map.forEach((key, value) -> System.out.println(key.name + ": " + value));
    }
}

Explanation:

Custom Employee objects are used as keys in the HashMap.
It is essential to override equals() and hashCode() so that HashMap can correctly identify and compare keys.

Output:

John: Manager
Alice: Developer

Conclusion

HashMap is a powerful and flexible data structure in Java for storing key-value pairs. It provides efficient methods for accessing, inserting, and removing elements.

By using the operations above, you can handle data effectively with minimal code.

0 comment
0 FacebookTwitterPinterestEmail
Misc

Java Lambda Expressions Tutorial

written by 75ypsaw71

Lambda expressions were introduced in Java 8 as a way to implement functional programming in Java. They allow you to write more concise, readable, and flexible code, particularly when working with functional interfaces.

In this tutorial, we’ll explore what lambda expressions are, how they work, and look at several code examples.

What is a Lambda Expression?

A lambda expression is essentially a short block of code that takes in parameters and returns a value. It is used to provide the implementation of a method defined by a functional interface.

Syntax of Lambda Expression:

(parameters) -> expression
// OR
(parameters) -> { statements }

Parameters: The input values for the lambda expression.
Arrow (->): Separates the parameters from the body of the lambda expression.
Expression or Statements: The block of code that is executed when the lambda is invoked.

Functional Interface

A functional interface is an interface with a single abstract method. Lambda expressions can only be used to implement functional interfaces.

Example of a functional interface:

@FunctionalInterface
interface MyFunctionalInterface {
    void sayMessage(String message);
}

Example 1: Basic Lambda Expression

Without lambda expressions, you would typically use an anonymous class to provide the implementation of an interface.

Before Lambda:

MyFunctionalInterface message = new MyFunctionalInterface() {
    @Override
    public void sayMessage(String msg) {
        System.out.println("Message: " + msg);
    }
};

message.sayMessage("Hello, Java Lambda!");

Using Lambda:

MyFunctionalInterface message = (msg) -> System.out.println("Message: " + msg);
message.sayMessage("Hello, Java Lambda!");

Explanation:

Here, (msg) is the parameter.
System.out.println(“Message: ” + msg); is the body of the lambda expression.
No need for the boilerplate of creating an anonymous class.

Example 2: Lambda Expression with Multiple Parameters

Suppose we have a functional interface for mathematical operations:

@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

We can implement this interface using lambda expressions for different operations:

Addition:

MathOperation add = (a, b) -> a + b;
System.out.println("Addition: " + add.operation(5, 3));  // Output: 8

Subtraction:

MathOperation subtract = (a, b) -> a - b;
System.out.println("Subtraction: " + subtract.operation(5, 3));  // Output: 2

Multiplication:

MathOperation multiply = (a, b) -> a * b;
System.out.println("Multiplication: " + multiply.operation(5, 3));  // Output: 15

Division:

MathOperation divide = (a, b) -> a / b;
System.out.println("Division: " + divide.operation(6, 3));  // Output: 2

Explanation:

(a, b) are the input parameters.
The return value is the result of performing the mathematical operation.

Example 3: Using Lambda with Collections

One of the most common use cases for lambda expressions is with Java collections, especially when sorting or filtering elements.

Sorting a List using Lambda Expression:

import java.util.*;

public class LambdaWithList {
    public static void main(String[] args) {
        List names = Arrays.asList("John", "Alice", "Bob", "Eve");

        // Sort using lambda expression
        Collections.sort(names, (a, b) -> a.compareTo(b));

        System.out.println(names);  // Output: [Alice, Bob, Eve, John]
    }
}

Explanation:

We use Collections.sort() and provide a lambda expression (a, b) -> a.compareTo(b) as a comparator.

Example 4: Filtering a List using Lambda Expression and Streams

Lambda expressions are frequently used in combination with Streams for performing operations on collections.

Filtering and Printing Even Numbers from a List:

import java.util.*;
import java.util.stream.Collectors;

public class LambdaWithStreams {
    public static void main(String[] args) {
        List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Filter even numbers and print them
        List evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());

        System.out.println(evenNumbers);  // Output: [2, 4, 6, 8, 10]
    }
}

Explanation:

filter(n -> n % 2 == 0) is the lambda expression that checks if a number is even.
stream() is used to create a stream from the list.
The filtered numbers are collected back into a list using collect().

Example 5: Runnable Interface with Lambda

The Runnable interface in Java has a single method, so it is a functional interface, and we can use a lambda expression to provide its implementation.

Using Lambda with Runnable:

public class LambdaRunnable {
    public static void main(String[] args) {
        // Traditional Runnable implementation
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable using anonymous class");
            }
        };

        // Lambda implementation of Runnable
        Runnable r2 = () -> System.out.println("Runnable using lambda");

        // Run both
        r1.run();
        r2.run();
    }
}

Explanation:

In the lambda version, we avoid the need for an anonymous inner class and directly implement the run() method with the lambda expression () -> System.out.println(“Runnable using lambda”).

Example 6: Using Custom Functional Interface with Lambda

We can define our custom functional interface and use a lambda expression to provide its implementation.

Custom Functional Interface:

@FunctionalInterface
interface Greet {
    void sayHello(String name);
}

Implementing the Interface with Lambda:

public class LambdaCustomInterface {
    public static void main(String[] args) {
        Greet greet = (name) -> System.out.println("Hello, " + name);
        greet.sayHello("Java Developer");
    }
}

Explanation:

The Greet interface has one abstract method, so it can be implemented using a lambda expression (name) -> System.out.println(“Hello, ” + name).

Example 7: Lambda Expressions with Consumer, Supplier, and Predicate

Java has built-in functional interfaces in the java.util.function package. Three commonly used ones are Consumer, Supplier, and Predicate.

Consumer Example (Takes an input and performs an action):

import java.util.function.Consumer;

public class LambdaConsumer {
    public static void main(String[] args) {
        Consumer consumer = (s) -> System.out.println("Consumed: " + s);
        consumer.accept("Java Lambda");
    }
}

Supplier Example (Returns a value):

import java.util.function.Supplier;

public class LambdaSupplier {
    public static void main(String[] args) {
        Supplier supplier = () -> Math.random();
        System.out.println("Random number: " + supplier.get());
    }
}

Predicate Example (Returns a boolean result):

import java.util.function.Predicate;

public class LambdaPredicate {
    public static void main(String[] args) {
        Predicate isEven = (n) -> n % 2 == 0;
        System.out.println("Is 4 even? " + isEven.test(4));  // Output: true
    }
}

Explanation:

Consumer takes an input and performs an action without returning a result.
Supplier provides an output without taking any input.
Predicate tests a condition and returns a boolean.

Example 8: Using Lambda in a ForEach Loop

We can use lambda expressions in combination with the forEach() method to iterate over collections.

import java.util.Arrays;
import java.util.List;

public class LambdaForEach {
    public static void main(String[] args) {
        List names = Arrays.asList("John", "Alice", "Bob", "Eve");

        // Using lambda with forEach
        names.forEach(name -> System.out.println("Hello, " + name));
    }
}

Explanation:

The forEach() method takes a lambda expression as an argument, which will be applied to each element of the list.

Conclusion

Lambda expressions in Java offer a powerful, compact way to implement functional programming. They remove the verbosity of anonymous inner classes and make your code more concise and readable.

With the examples above, you can see how lambda expressions are used in various real-world scenarios such as sorting, filtering, and using built-in functional interfaces.

By practicing with lambda expressions, you'll become more comfortable using them, making your Java code more modern and efficient.

0 comment
0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts