DEV Community: Code Craft Club

COMPARATOR vs COMPARABLE - A Java Surprise You did in School!

Code Craft Club — Sat, 16 Mar 2024 17:19:38 +0000

Ever felt like Comparable and Comparator were taunting you in Java? You're not wrong! These two interfaces can be a bit mysterious at first, even after conquering mountains of tutorials. (Don't worry, I wrestled with them too!) After enough head-scratching and questionable Google searches (Documentation is great, but sometimes you just need a friendly explanation to break things down, FWIW), I finally cracked the code on these confusing critters.

So forget complex explanations and cryptic code! In this blog, we'll break down Comparable and Comparator with a down-to-earth analogy that'll surely seep into your logical minds. Trust Me!

Plus, we'll walk you through a simple 3-step process for implementing each one!

So Let's Begin!

Let's head back to Schooling Days

Ever wonder why students seem to magically line up by HEIGHT during school assemblies? It's like they have a built-in sorting algorithm! I am sure you must've also done this!

Well, that's kind of what Comparable does in Java. It lets objects define their own natural ordering, just like those height-conscious students. No external instructions needed - they just know their place!

Sound's as simple as that… But let's take a closer look at this to understand better!

Comparable: A Natural Order of Students

Comparable is like a default instruction given to the students on how to line up naturally without any additional directions.

So Let's take a Student class just like a real time student in a school.

class Student {
    String name;
    int height;
    int weight;

    public Student(String name, int height, int weight) {
        this.name = name;
        this.height = height;
        this.weight = weight;
    }
}

Just like how a student knows naturally to compare as per height with his companions, the same capability can be given to our Student Class in java using the Comparable interface.

So let's implement the Comparable interface and let's make it happen in just 3 steps as below.

Implementation of Comparable Interface in 3 Steps:

1. Implement the Comparable Interface:

To make a class sortable using the natural order, you implement the Comparable interface directly in the class.

"Keep in mind! Comparable interface grants the class the natural ability to compare itself whenever necessary."

public class Student implements Comparable<Student> {
 ....
}

2. Override the compareTo() Method:

Just override the compareTo() method inside your class. This method compares the current object (this) with another object of the same type (other).

Think of it as the class's superpower, allowing it to compare naturally whenever the need arises.

public class Student implements Comparable<Student> {
    String name;
    int height;
    int weight;

    public Student(String name, int height, int weight) {
        this.name = name;
        this.height = height;
        this.weight = weight;
    }

    @Override
    public int compareTo(Student other) {
        // Compare students based on their height
        return this.height - other.height;
    }
}

If the current object should come before the other object, return a negative integer.
If they are equal, return 0.
If the current object should come after the other object, return a positive integer.

3. Using Comparable:

Once Comparable is implemented, Java's built-in sorting methods will use the natural order defined by the compareTo() method.

Yipee! The magic now happens naturally. The objects get sorted naturally now!

Arrays.sort(students);

Now let's see a twist in our example..

Imagine if the students were suddenly tasked with lining up by their WEIGHT instead of their height! This is something not natural to the students and is a custom defined instruction given to them.

Just like the teacher guiding the students to line up by weight, the Comparator interface in java too provides an external logic to sort objects based on specific criteria.

So let's implement the Comparator interface and let's make it happen in just 3 steps again.

Implementation of Comparator Interface in 3 Steps:

1. Create a Comparator Class:

To implement a Comparator, you need to create a separate class that implements the Comparator interface. This interface requires you to define the compare() method.

Keep in mind simple that - Comparator is just a external Instructor! As simple as a teacher at school in our case!

import java.util.Comparator;

public class WeightComparator implements Comparator<Student> {
    ....
}

2. Override the compare() Method:

Inside the Comparator class, you override the compare() method. This method takes two objects of the type you're comparing (in this case, Student objects) and returns an integer value based on their comparison.

Just as a teacher compares one student's weight after another to sort, think of this method as the Java equivalent. It's like having your own personal sorting instructor built right into your code!

import java.util.Comparator;

public class WeightComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        // Compare students based on their weight
        return s1.weight - s2.weight;
    }
}

If the current object should come before the other object, return a negative integer.
If they are equal, return 0.
If the current object should come after the other object, return a positive integer.

3. Use the Comparator:

Once your Comparator is defined, you can use it to sort objects in various ways. For example, you can use it with the Arrays.sort() method or with collections like ArrayList.

Now, you're putting the teacher to work in your Java program by calling the sort method along with the comparator.

Arrays.sort(students, new WeightComparator());

Get your coding hands on your keyboards and give this a try! I'm confident it will streamline your programming experience. Remember, don't hesitate to reach out for additional help and suggestions.

Closing Thoughts:

Thank you for reading our blog. We appreciate your time and interest in our content. If you have any questions, feedback, or topics you'd like us to break open and cook it simpler in our future articles, please feel free to leave a comment below. Your input is valuable, and it helps us create content that matters to you.

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

Happy coding!

Streams in Java made super simple with examples! — An Easy Beginner’s Guide!

Code Craft Club — Sun, 01 Oct 2023 19:17:16 +0000

Data structures such as arrays, sets, etc. are commonly used to store and manipulate data in Java. However, iterating over these data structures and performing operations on them can be cumbersome. Java 8 introduced a new feature called Streams, which allows us to process data in a declarative and functional way making it more safer and concise.

In this blog, we will discuss about the concept and working of Streams in Java with a delightful analogy that makes it super easy!

Stream

A stream is a way of processing a sequence of elements in a functional and declarative manner. A stream does not store the data itself, but only provides a view of the data source. This means that the data source is not modified by the stream operations.

Imagine Java Streams like a stream of vehicles passing through a toll gate. Each vehicle represents an element in the stream. Just as vehicles pass through a toll gate one by one, elements in a stream are processed sequentially or in parallel.

Java provides a Stream interface in the java.util.stream package that defines the methods for creating and manipulating streams.

However, the Stream interface does not support primitive types such as int, long, and double. To use streams with these types, we need to use their corresponding wrapper classes Integer, Long, and Double.

Creating an Empty Stream

The Stream interface consists of a static and default method empty() that can be used to create an empty stream.

Creating an empty stream in Java is similar to having an empty toll lane at a toll gate. Just as an empty lane at a toll gate waits for vehicles to pass through, an empty stream in Java is ready to receive elements for processing. It serves as a placeholder, waiting to be filled with data before any operations can be performed on it.

In the above code, we have created an empty stream using the default method empty().

Creating a Stream with Collections

In Java, we can create a Stream from a collection (such as a List, Set, or Map) using the stream() method. Here’s how we can create a Stream from various types of collections:

Syntax:

collection.stream()

Example Syntax -

In the above code, we have created a list of Strings and assigned it to myList variable. From the list of Strings we have created a stream and assigned it to the streamFromList. Here, the stream does not occupy any memory, instead it just provides a way to access the original elements.

Direct creation of Stream

In Java, the Stream.of() method is a convenient way to create a Stream from a sequence of elements. It allows us to create a Stream directly from individual elements or an array of elements without needing a collection.

Here’s how you can use the Stream.of() method:

Stream.of(list of elements);

Example Syntax -

How to work with Streams?

Working with Streams involves the usage of some operations. These operations are basically divided as Intermediate Operations and Terminal Operations. Let us understand these terms easily using the same analogy of a Toll Booth.

Intermediate Operations

Intermediate operations are like toll booth workers who filter, transform, or manipulate the vehicles before they leave the toll gate.

These intermediate operations always produces a new stream as output after performing the specified operations.

There are different types of intermediate operations:

filter()
map()
sorted()
distinct()

Filter()

Filtering allows us to select elements based on a certain condition.

Output -

Bike
Truck
Cycle

In the above code, we have created a stream of vehicles, filtered the names that have more than 3 letters and displayed the resultant names on the console.

Map()

Mapping helps to perform an operation on each element of the stream.

Output -

In the above code, the lambda expression eachNumber -> eachNumber + 5 is being used to map each element and increment each number by 5.

Sorted()

Sorting arranges elements in a specified order.

Output -

In the above code, the sorted() method has arranged the elements of the numbers stream in ascending order.

Distinct()

Distinct method removes the duplicate elements from the stream.

Output -

Apple
Mango

In the above code, the distinct() method has removed the duplicate strings from the stream.

Terminal Operations

Terminal operations are like the toll booth itself - once a vehicle passes the toll booth, it can't go back. Similarly, terminal operations are the final actions on a stream.

A terminal operation is a stream operation that consumes the elements of a stream and produces a result.

Types of terminal operations include:

forEach
reduce
count

ForEach()

This method is used for performing an action on each element.

Output -

Apple
Mango
Banana
Kiwi

In the above code, the forEach() method is used to display the elements of the resultant stream on the console.

reduce()

The reduce() is a terminal operation that combines all elements of the stream into a single result. It takes two parameters: an identity value and a Binary Operator (a function that takes two elements and produces a single result). The reduce() operation repeatedly applies the Binary Operator to the current result and each element of the stream until all elements have been processed, producing a final result.

Let’s take an example to find the sum of all numbers in a list.

Output -

In this example, the reduce operation starts with an initial value of 0 (identity). For each element in the stream, it adds the element to the current sum (a + b). The result is the sum of all elements in the stream, which is 15 in this case.

Use Case - reduce() is useful when you want to aggregate elements of the stream into a single value, such as finding the sum, maximum, minimum, or concatenating strings.

count()

The count() method returns a long integer that indicates the number of elements present in the stream.

Output -

In the above code, the vehicles that has greater than 3 letters were filtered and the count() method is used to get the number of vehicles in the resultant stream.

ForEach() vs Map()

Wondering what’s the difference between forEach() and map() methods? Though both these operations seem to be very similar, however they behave and operate differently.

The forEach() method works similar to the map(). It iterates over the elements in the stream and performs the specified operation on each element.

However, the only difference between forEach() and map() is -

The forEach() method does not return any stream while the map() method returns a stream.
forEach is used for performing actions on elements, whereas map transforms elements.

Use Case of map(): Use map when you want to transform the elements of the Stream from one form to another. For example, transforming strings to uppercase, converting objects to specific properties, or performing any other form of transformation.

Use Case of forEach(): Use forEach when you want to perform an action (such as printing, logging, or updating external states) for each element in the Stream.

Closing Thoughts:

Thank you for reading our blog. We appreciate your time and interest in our content. If you have any questions, feedback, or topics you’d like us to cover in our future articles, please feel free to leave a comment below. Your input is valuable, and it helps us create content that matters to you.

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

Happy coding!

Semaphores, is that so easy!! The Clothing Store Analogy as a Guide for Beginners

Code Craft Club — Fri, 22 Sep 2023 15:34:46 +0000

Introduction to Semaphores

Semaphores are a synchronization mechanism used in computer science to control access to a shared resource, such as a variable or a section of code usually known as the Critical Section, in a multithreaded or multi-process environment. They help ensure that multiple threads or processes can access the resource in a coordinated and safe manner.

Let's use the analogy of a clothing store to understand the concept of semaphores and why they are needed for parallel processing.

The Clothing Store Analogy

Imagine a clothing store that can only hold a maximum of 5 items inside. There are Tailors (producers) who are continuously creating new items, and customers (consumers) who are eagerly buying them. Here are the key conditions of this analogy:

Store Capacity: The store can store a maximum of 5 items at a time.
Continuous Production: Producers replenish items as soon as the count decreases to ensure the store doesn't run out of stock.
Continuous Consumption: Customers only buy products when items are available in the store.
No Out-of-Stock: At any point, a customer should not encounter an out-of-stock situation.

Now in this scenario, let’s understand the possibilities without the use of semaphores. Since there are multiple producers (tailors) and consumers (customers), everyone would try to access the store concurrently. This can lead to several issues:

Race Conditions: Without synchronization, there's no guarantee that one thread won't interrupt another while accessing shared resources like the item count in the store. This can lead to race conditions where the final outcome depends on the order of execution.
Inconsistent State: Due to race conditions, the item count in the store may become inconsistent. Producers might add items simultaneously, causing the count to go beyond the store's capacity or even drop below zero, leading to illogical scenarios.
Out-of-Stock Problems: Consumers may try to buy items even when none are available, resulting in out-of-stock situations. Conversely, producers may overstock the store, wasting resources.
Deadlocks: In complex scenarios, without proper synchronization, threads might end up in a deadlock, where they're stuck, unable to proceed because they're all waiting for a resource that won't be released.

Let’s implement the analogy in code and check the issues as discussed above.

Creating the Java Classes

To implement this analogy, we'll create three Java classes: Store, Producer, and Consumer.

The `Store` Class (Critical Section)

The Store class represents our shared resource, the clothing store. It contains the current item count.

The `Producer` Class

The Producer class represents tailors who continuously produce items and add them to the store. We are using the Runnable interface to let them run using separate threads.

The `Consumer` Class

The Consumer class represents customers who continuously buy items from the store. We are using the Runnable interface to let them run using separate threads.

The `Main` Method

In the Main method, we'll create 10 producers and 10 consumers as separate threads and start them to simulate the store scenario.

The above program when executed would give rise to Index out of bounds issues.

With Semaphores → Order is Restored

Now, let's introduce semaphores to our scenario, and watch as they bring order to the chaos. To implement the semaphores, we need to add the changes in the Main class, Producer class and Consumer class.

Adding Semaphores in the Main class

Adding Semaphores in the Producer class

Adding Semaphores in the Consumer class

With the above modifications by adding semaphores:

Mutex Semaphore: This ensures exclusive access to the critical section (the store) by allowing only one thread in at a time. This prevents race conditions and ensures that changes to the item count are made one at a time.

Controlled Access: Producers and consumers must acquire a permit before entering the store (critical section). If the store is full (5 items), producers will wait until a consumer buys something, freeing up space. Similarly, consumers will wait if the store is empty until a producer adds an item.

Consistent State: Semaphores ensure that the item count remains consistent and within the store's capacity. Producers and consumers work together harmoniously to maintain the correct item count.

No Deadlocks: Semaphores provide a straightforward mechanism for controlling access, reducing the likelihood of deadlocks. Threads can always access the critical section eventually, avoiding deadlock scenarios.

In short, Semaphores are just like the traffic cops!!

Conclusion

By using semaphores, we transform our chaotic scenario into a well-behaved system, ensuring a smooth shopping experience for both producers and consumers.

Closing Thoughts:

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

Happy coding!

Mutex & Race Conditions in Java Multi-Threading made so simple with real-life analogies

Code Craft Club — Fri, 15 Sep 2023 18:58:50 +0000

Multithreading is a powerful concept in Java, allowing you to run multiple threads of execution concurrently. However, with great power comes great responsibility, and when multiple threads access shared resources, it can lead to synchronization issues. Let's explore the need for synchronization, the issues that arise without it, and the solutions available in Java.

The Need for Synchronization

Imagine you have a bank account with a balance of $100, and two threads are running concurrently: one is trying to withdraw money, and the other is attempting to deposit money.

Thread A (Withdraw) reads the current balance, which is $100.
Thread B (Deposit) also reads the same current balance, which is still $100.
Thread A calculates the new balance after withdrawing $50, resulting in $50.
Thread B calculates the new balance after depositing $30, resulting in $130.
Thread A updates the balance to $50.
Thread B updates the balance to $130.

In this scenario, both threads are not synchronized, and they read and modify the balance concurrently. As a result, the final balance is $130, even though the expected behavior should be a balance of $80 ($100 - $50 + $30).

In multithreading, synchronization is essential to ensure that threads can safely access shared resources (like variables, data structures, or files) without causing conflicts or inconsistencies.

Three Reasons for Synchronization Issues

1. Critical Section

A critical section in multithreading refers to a section of code or a block of code where multiple threads may access shared resources or data concurrently. To ensure correct and consistent behavior, only one thread should be allowed to execute the critical section at a time while other threads wait their turn. This synchronization is achieved using techniques like locks, mutexes (mutual exclusion), or semaphores.

2. Race Conditions

A race condition can be described as a situation where more than one thread attempts to enter a critical section (a section of code where shared resources are accessed) at the same time, leading to unpredictable and incorrect behavior.

3. Preemptiveness

Preemptive multitasking as the name suggests “Pre-Emptying”, allows the operating system to interrupt a thread and give control to another.

Synchronization problem occurs only when all the above three conditions are met.
To resolve synchronization issues, we need to address any one condition amongst Critical Section, Race Conditions and Preemptiveness.

Ideal Properties of a Synchronization Solution

A good synchronization solution should possess the following properties:

Mutual Exclusion: Only one thread exclusively should have access to the critical section at a time, preventing interference. In other terms, there must not be any race conditions.

Progress of the Program: The synchronization should not lead to deadlock, where threads are blocked indefinitely and bring the entire program to a halt. It should allow other threads (at least one thread) to execute when a thread is waiting.

Bounded Waiting: A thread should not have to wait indefinitely to enter a critical section. There should be a limit on waiting time.

No Busy Waiting: Busy waiting consumes CPU cycles needlessly. An efficient synchronization solution should not force threads to continuously check for access.

MUTEX (Mutual Exclusion)

A mutex, short for "mutual exclusion," is a synchronization mechanism that serves as a lock to ensure mutual exclusion.

Properties of a Mutex Lock in Java

Mutual Exclusion: Only one thread can acquire the mutex lock at a time, preventing concurrent access to shared resources.
Ownership: The thread that acquires the mutex lock is the only one that can release it, ensuring proper resource management.
Blocking: If a thread attempts to acquire a locked mutex, it will be blocked until the mutex is released by the owning thread.
Non-busy Waiting: Threads waiting for the mutex are not actively spinning in a loop but are put in a waiting state until the mutex is available.

Synchronization in Adder & Subtractor

Let’s understand the need of synchronization with an example of Adder and Subtractor.

In this code, we will have two classes: Adder and Subtractor. These classes represent two concurrent operations that manipulate a shared resource.

Adder: The Adder class is responsible for adding numbers from 1 to 100 to a shared value.
Subtractor: The Subtractor class is responsible for subtracting numbers from 1 to 100 from the same shared value.

Let's create the classes as follows:

The `SharedResource` class:

The `Adder` class:

The `Subtractor` class:

The `Main` class:

In this code:

SharedResource is a class that contains the shared value.
Adder and Subtractor are two separate threads that add and subtract values from the shared resource, respectively.
The Main class creates instances of Adder and Subtractor, starts them concurrently, and then waits for them to finish using join().

When you run this code, you'll likely observe that the final shared value is not always 0, which indicates a synchronization issue because the add and subtract operations are not synchronized.

Behavior of the code Without Locks:

Without any synchronization mechanism (locks), both the Adder and Subtractor threads run concurrently and can access the shared resource simultaneously. This can lead to race conditions, where the order of execution and interleaving of operations between the threads are unpredictable. As a result, the final value of the shared resource can vary each time the program is run.

Implementation for Synchronization:

In Java, the ReentrantLock is a common implementation of a Mutex.

To make the code synchronous and prevent race conditions, we use ReentrantLock to protect the critical sections of code, specifically the add and subtract methods in the SharedResource class. Here's how it's done:

By acquiring and releasing the lock using lock.lock() and lock.unlock() respectively, we ensure that only one thread can execute the critical sections of the add and subtract methods at any given time, preventing concurrent interference and ensuring consistent and correct results.

With these modifications, the code becomes synchronized, and the final shared value will always be 0, as expected, regardless of how many times you run the program.

Conclusion

The ReentrantLock was used, ensuring that only one thread could access the critical sections at a time. This synchronization mechanism resolved race conditions and ensured that the final shared value was always 0, as expected.

While locks are a common and effective way to achieve synchronization, there are other methods and techniques as well such as Synchronized Methods, Synchronized Blocks and Semaphores.

Closing Thoughts:

Thank you for reading our blog. We appreciate your time and interest in our content. If you have any questions, feedback, or topics you'd like us to cover in our future articles, please feel free to leave a comment below. Your input is valuable, and it helps us create content that matters to you.

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

Happy coding!

Multi-Threading in JAVA using Callables

Code Craft Club — Thu, 14 Sep 2023 14:19:45 +0000

Introduction to Callables

In multi-threaded programming, we often encounter scenarios where tasks need to be executed concurrently, but they don't necessarily need to return any values. Think of these tasks as workers performing their jobs independently, like chefs work simultaneously to execute their tasks, and they don't need to return any specific information. In such cases, runnables can be used where there is nothing to return.

However, there are situations where not only do we need tasks to run concurrently, but we also need them to return some valuable data upon completion. This is where the concept of Callables comes into play.

Let’s understand with an example:

Online Shopping:

Imagine you are an online shopper placing multiple orders. You want to track the status of each order and get confirmation when each order is successfully processed. This is where the concept of Callable comes in.

Callable is like each online order you've placed. These are the tasks you care about because you want to track the status of your orders.
Future is like the shipping confirmation email you receive for each order. When an order is shipped (the task is completed), you get an email (Future) that tells you the order's status and provides tracking information.

Using Callables in Multi-Threaded Programs

To incorporate Callables into multi-threaded programs, you can follow these steps:

Step 1: Identify Tasks Needing Data Returns

Identify tasks within your program that require data to be returned upon completion. These tasks are analogous to online shopping orders where you want tracking information.

Step 2: Create Callable Classes

For tasks that need to return data, create classes and implement the Callable interface. This interface allows tasks to return results or throw exceptions, making it suitable for data-retrieval tasks.

import java.util.concurrent.Callable;

class OrderProcessingTask implements Callable<String> {
    private String item;

    public OrderProcessingTask(String item) {
        this.item = item;
    }
}

Step 3: Implement the `call()` Method

Inside your Callable class, implement the call() method, which contains the code for the task and defines the return type for the method. This method represents the work that needs to be done and returns the result upon completion.

@Override
public String call() throws Exception {
    // Simulate order processing
    Thread.sleep(2000); // Simulating processing time
    return "Order for " + item + " is processed.";
}

Step 4: Create a Main Class Using Executor Service

Create a main class that utilizes the ExecutorService to execute the Callable tasks:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class OnlineShoppingApp {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // Create order processing tasks
        Callable<String> order1 = new OrderProcessingTask("Product A");
        Callable<String> order2 = new OrderProcessingTask("Product B");
        Callable<String> order3 = new OrderProcessingTask("Product C");

        // Submit tasks to the executor
        Future<String> result1 = executor.submit(order1);
        Future<String> result2 = executor.submit(order2);
        Future<String> result3 = executor.submit(order3);

        // Wait for tasks to complete and retrieve results
        String status1 = result1.get();
        String status2 = result2.get();
        String status3 = result3.get();

        System.out.println(status1);
        System.out.println(status2);
        System.out.println(status3);

        // Shutdown the executor when done
        executor.shutdown();
    }
}

Understanding the use of `Future` with `Callable`

In the main class, we use Future objects to capture the results of the submitted Callable tasks. A Future represents the result of an asynchronous computation, in this case, the result of each order processing task.

Analogy:

In our example scenario of Online Shopping, each order represents a separate task, and we want to keep track of their status and delivery. So:

Callable is analogous to an online shopping order. Each order represents a task that we want to track.

Future is like the order confirmation or tracking number we receive after placing an online order. It’s a reference to our order’s status and allows us to retrieve details when the order is processed.

Just like you can check the status of our online orders using the order number without waiting at the store, we can use Future<> to check the status and retrieve results from Callable tasks without blocking the program.

Here's how this works:

executor.submit(callable) returns a Future representing the result of the callable task.
result.get() is called to retrieve the result of the task.

This allows to efficiently manage tasks that return data in a multi-threaded program. The Future provides a way to obtain the result of the task when it's ready, just like tracking online orders and receiving status updates when the orders are processed.

Closing Thoughts:

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

Happy coding!

Generics in Java was never this EASY! — A Complete Beginner’s Guide!

Code Craft Club — Mon, 11 Sep 2023 09:07:49 +0000

Imagine you have a collection of jars, all identical in shape and size, but each one with a unique label. Now, these jars can be used to store a variety of items, from candies to spices, without any confusion. The label on each jar is the key — it tells you exactly what should go inside. Just like these labeled jars simplify your storage needs, Generics in Java are like labels for your code, making it easy to work with multiple data types while keeping things organized.

What Are Generics?

Generics in Java are like those labels on your jars, but for your code. They allow you to create classes, methods, and interfaces that can work with different data types while ensuring type safety. These labels (or type parameters) specify what kind of data each container can hold, just like the labels on your jars specify what goes inside.

The Need for Generics

Imagine if your jars had no labels. You’d have to open each one to figure out what’s inside. It would be a chaotic mess! Without Generics, your code can end up in a similar mess, with lots of redundancy. You might need to create separate classes for each data type, which is inefficient and prone to errors. Generics come to the rescue, allowing you to create a single, versatile container that can hold various types of data, just like those labeled jars help keep your kitchen organized.

Type Parameters and Representation

In Java, generics use type parameters, which are placeholders for specific data types. These type parameters can be represented in two common ways:

Single Letter Convention: Typically, single uppercase letters are used to distinguish from regular class or interface names. The most commonly used parameters are
E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
They don't carry any special meaning; they're just placeholders.
For example, the class java.util.HashMap<K, V> has two type parameters, K and V, representing the type of the keys and values, respectively, stored in the map. The interface java.util.List<E> has a single type parameter E representing the type of the elements stored in the list.
Descriptive Names: Sometimes, more descriptive names like KeyType or ValueType are used for type parameters, especially when clarity is important, just as you might use labels with descriptive names for your jars.

Generic Classes

Now, let’s delve into generic classes with code and explanations.
Syntax of a Generic Class -

class ClassName<T1, T2, ..., Tn> {
    // block of code
}

Here, T1, T2, …, Tn are the comma-separated type variables.
Let’s understand with an example:

class Box<T> {
    private T contents;

    public Box(T contents) {
        this.contents = contents;
    }

    public void printDataType() {
        System.out.println("Type: " + this.contents.getClass().getSimpleName());
    }
}

class Main{
   public static void main(String[] args) {
    Box<Integer> integerBox = new Box<>(42);
  integerBox.printDataType();

    Box<String> stringBox = new Box<>("Hello, Generics!");
  stringBox.printDataType();
}
}

// Output:
// Type: Integer
// Type: String

In this code, we've defined a generic class Box<T> that can hold any type of object, where T is our type parameter. The printDataType method prints the type of the contents stored in the Box using getClass().getSimpleName().

In the main method, we create instances of Box for both Integer and String types and call the printDataType method on each of them. This should print the respective types of the contents stored in the Box.

Analogy -

Just like your labeled jars can hold different items, the Box class can hold different data types. The type parameter T acts like the label, ensuring that you only put compatible items inside.

Generic Methods

Now, let’s delve into generic methods within a generic class.
Syntax of a Generic Method:

<T1, T2, ..., Tn> returnType methodName(parameters) {
    // block of code
}

// Example Syntax -

  //Example 1
  public <T> void methodName(T obj) {
      // block of code
  }

  //Example 2
  public static <T, N> T methodName(T obj, N num) {
      // block of code
  }

Let’s understand with an example now:

class Box<T> {
    private T contents;

    public Box(T contents) {
        this.contents = contents;
    }

    public T getContents(){ //method returns T type
      return this.contents;
    }
}

class Main{
   public static void main(String[] args) {
    Box<Integer> integerBox = new Box<>(42);
  System.out.println("Method Returned:" + integerBox.getContents());

    Box<String> stringBox = new Box<>("Hello, Generics!");
  System.out.println("Method Returned:" + stringBox.getContents());
}
}

// Output -
// Method Returned:42
// Method Returned:Hello, Generics!

In this code, we have a generic class Box<T> with a constructor that accepts an object of type T and a getContents method that returns an object of type T.

The integerBox object is created with an Integer type parameter and the stringBox object is created with a String type parameter.

In the main() method, we are calling the getContents() method on both objects and displayed the returned values on the console.

Generic Interfaces

Similar to creating Generic Classes and Generic Methods, we can also create interfaces in Java that can be used with any type of data by using generics. This type of method is known as a Generic Interface.
Syntax of a Generic Interface:

interface InterfaceName<T1, T2, ..., Tn> {
    // block of code
}

class ClassName<T1, T2, ..., Tn> implements InterfaceName<T1, T2, ..., Tn> {
    // block of code
}



// Example Syntax -

interface Pair<K, V> {
    K getKey();
    V getValue();
}

Pair is a generic interface defining two type parameters, K and V.
Implementing classes specify the actual types:

interface Pair<K, V> {
    K getKey();
    V getValue();
}


class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}

class Main{
  public static void main(String[] args){
    OrderedPair<String, Integer> obj = new OrderedPair<>("Mobile No", 999999999);
    System.out.println("Key: " + obj.getKey());
    System.out.println("Value: " + obj.getValue());
  }
}

// Output -
// Key: Mobile No
// Value: 999999999

In this code, we have defined a generic interface Pair<K, V> with two type parameters, K and V, which define methods getKey and getValue. Then, we have implemented this interface with the OrderedPair<K, V> class, where K and V are specific types (in this case, String and Integer).

In the main method, we create an instance of OrderedPair<String, Integer> with values "Mobile No" and 999999999.

Bounded Types

Now, imagine if you wanted to limit the types that can be used with generics, just like specifying that a jar is for storing only chocolates. This is where bounded types come in.

As we saw above of how we can create generic classes, interfaces, and methods that can work with any data type, however, sometimes we may want to limit the data types that can be used with a generic to a specific set of types. In these cases, we can use bounded types by specifying the upper bound type parameter with the extends keyword.

Syntax of a Bounded Types:

<T extends A>

Here, the type parameter T can only accept data types that are of type A or any classes or interfaces that extends A.
Let’s understand with an example:

class NumberContainer<T extends Number> {
    private T value;

    public NumberContainer(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

class Main{
  public static void main(String[] args) {
    NumberContainer<Integer> intContainer = new NumberContainer<>(42);
    Integer intValue = intContainer.getValue(); // Works fine
    System.out.println(intValue);

    NumberContainer<Double> doubleContainer = new NumberContainer<>(3.14);
    Double doubleValue = doubleContainer.getValue(); // Works fine
    System.out.println(doubleValue);
    }
}

// Output -
// 42
// 3.14

In this example, NumberContainer is a generic class that can hold any type that extends the Number class, which includes numeric types such as Integer, Double, and Float.

We create NumberContainer instances for Integer and Double types and successfully store and retrieve numeric values from them.

Failing Scenario in Bounded Types

Now, let’s see a failing scenario for the above example:

public static void main(String[] args) {
    NumberContainer<String> stringContainer = new NumberContainer<>("Hello"); // Compilation error!
}

In this scenario, we attempt to create a NumberContainer for the String type, which is not a numeric type. This results in a compilation error because it violates the constraint that the type must extend Number.

So, in this example, bounded types ensure that the container only works with numeric types and prevents non-numeric types from being stored in it.

Conclusion

In summary, generics in Java are like labeled jars, making it easy to understand, organize, and work with multiple data types in your code. Whether you're working with classes, methods, or interfaces, generics allow you to create more versatile and reliable code. So, just like those labeled jars in your kitchen, generics help you keep your Java code neatly organized and easy to grasp.

Closing Thoughts:

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

Happy coding!

Understanding Executors and Thread Pools in Java

Code Craft Club — Sat, 09 Sep 2023 09:39:10 +0000

The Car Manufacturing Factory Analogy

Imagine a car manufacturing factory with multiple production lines, each line representing a thread. These production lines work in parallel to assemble cars. However, there's a queue of customer orders that need to be processed.

The Challenge

Overflow of Orders: The factory receives a constant stream of customer orders, all queued up. Each order needs to go through the assembly lines to be completed.
One Order, One Line: Initially, the factory's approach is to assign each order to a separate production line. This means if there are too many orders, the factory must have an enormous number of production lines, which is impractical.
Context Switching Chaos: With so many production lines, they keep switching back and forth between tasks, like changing tools on a workstation. This context switching is time-consuming and doesn't contribute directly to building cars.

Thread Pools to the Rescue

To address these issues, the factory introduces the concept of a thread pool:

1. Creating a Thread Pool

In Java, the factory installs a system that manages the production lines efficiently:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService threadPool = Executors.newFixedThreadPool(5);

Here, they establish a thread pool with, say, five production lines (threads).

2. Efficient Order Handling

Now, when new customer orders arrive, they're sent to the thread pool for processing:

threadPool.execute();

3. Efficient Use of Resources

The thread pool optimizes the production lines (threads) as follows:

It reuses the same production lines for different orders.
When one order (task) is complete, the production line (thread) becomes available for the next order.
This prevents the need to create and dismantle production lines for every order, reducing wasted time and effort.

In summary, just as a car manufacturing factory streamlined its production lines by using a thread pool, software applications benefit from thread pools and executors. Thread pools help manage resources efficiently, avoid excessive context switching, and ensure that tasks are processed in an organized and effective manner.

Implementation example of a Thread Pool

Here's an example of creating a task class (analogous to a car assembly task) and passing it to the thread pool using execute():

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class CarAssemblyTask implements Runnable {
    @Override
    public void run() {
        // Simulate car assembly process
        System.out.println("Car is being assembled on production line " + Thread.currentThread().getName());
    }
}

public class CarFactory {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            threadPool.execute(new CarAssemblyTask());
        }

        // Shutdown the thread pool when done
        threadPool.shutdown();
    }
}

In this example, we've created a CarAssemblyTask class that implements the Runnable interface. We then submit instances of this task class to the thread pool using execute(). Each task represents the assembly of a car on one of the production lines. The thread pool efficiently manages these tasks, and the production lines are reused for different orders.

To implement the Thread Pool, we have used newFixedThreadPool() in the above code that allows us to create a fixed number of threads inside a thread pool. Apart from using the above mentioned newFixedThreadPool(), Java also provides cached Thread Pool which is implemented as Executors.newCachedThreadPool().

What is a Cached Thread Pool?

This method creates a thread pool that dynamically adjusts the number of threads based on the workload. It's often used for tasks where the number of tasks is not known in advance, or tasks are short-lived.

Characteristics:

It starts with no threads and creates new threads as needed to accommodate incoming tasks.
If a thread becomes idle for a certain period (typically 60 seconds), it may be terminated to free up resources.
There is no fixed limit on the number of threads; it can grow as needed.

How to choose between Cached Thread Pool and Fixed Thread Pool?

Use newCachedThreadPool() when you have a highly variable workload, where the number of tasks can fluctuate widely, and you want the thread pool to adapt dynamically. This is common for short, bursty tasks.
Use newFixedThreadPool(n) when you want to restrict the concurrency to a specific number of threads, ensuring that you don't overload the system with too many threads. This is appropriate for tasks with a more predictable workload and when you want to control resource usage.

Closing Thoughts:

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

Simplifying Java Multithreading (Runnable interface) with a Construction Analogy

Code Craft Club — Fri, 08 Sep 2023 18:31:17 +0000

Multi-Threaded Program in Java -

Imagine you're in a kitchen, trying to prepare a meal. You have a single cutting board and knife, and you need to chop vegetables, boil pasta, and cook a sauce all at the same time. If you were to do each task one after the other, it would take a long time to finish the entire meal.

Now, let's relate this to programming in Java:

Single Threaded Programming::

This is like having only one chef in the kitchen doing all the cooking. The chef starts chopping vegetables, then waits for that to finish, then starts boiling pasta, and so on. It's slow and not very efficient.

Multi-Threaded Programming::

In this case, it's as if you have multiple chefs in the kitchen, each with their own cutting board and knife. They can work on different tasks simultaneously. One chef can chop vegetables, another can boil pasta, and another can work on the sauce, all at the same time. This makes the cooking process much faster and more efficient.

In Java, multi-threaded programming allows you to have multiple "threads" (similar to chefs) running concurrently within a program. Each thread can perform a specific task independently, and they can work together to complete a larger task more quickly, just like the chefs in the kitchen. This can lead to better performance and responsiveness in Java applications, especially when dealing with tasks that can be done simultaneous

How to create a Multi-Threaded Program -

When thinking of creating a Multi-Threaded Program, never think in terms of what Threads you need to create!
Rather think in terms of what TASKS that needs to be done in parallel.

Let’s understand the steps to create a multi-threaded program by taking an analogy of a construction site with different workers such as painters, carpenters, electricians etc.

Steps to create:

Let's explore the simple steps to create a multi-threaded program now.

1. Define Task Classes

Create a class for each task you want to perform. Think of these classes as workers, and name them as nouns to represent the tasks they'll handle.

Analogy: Imagine you're managing a construction site. You have different types of workers like "Carpenter," "Painter," and "Electrician" for specific jobs.

2. Implement the Runnable Interface

For every task class, implement the Runnable interface. This ensures that each class has a run method, which will contain the code for the task.

Analogy: Think of the Runnable interface as a set of instructions that every worker (task class) must follow

class CarpenterTask implements Runnable {
    public void run() {
        // Code for carpentry work
    }
}

class PainterTask implements Runnable {
    public void run() {
        // Code for painting work
    }
}

3. Code Task Logic

Inside each task's run method, write the code that the task needs to perform. This is where you specify what each worker should do.

Analogy: In our construction site, the run method of the CarpenterTask class would contain the actual carpentry work instructions.

class CarpenterTask implements Runnable {
    public void run() {
        System.out.println("The carpenter is drilling and fixing screws");
    }
}

class PainterTask implements Runnable {
    public void run() {
        System.out.println("The Painter is painting the walls and windows");
    }
}

4. Create Task Instances

Instantiate the task classes wherever you want to start a new thread for that task. Think of this as hiring a worker for a specific job.

Analogy: You hire a carpenter when you need carpentry work and a painter when you need painting.

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

        //Create the instances of the tasks in the main 
        CarpenterTask carpenter = new CarpenterTask();
        PainterTask painter = new PainterTask();

    }
}

5. Create Thread Objects

Create thread objects for each task instance you created. Threads are like supervisors that manage the workers (task instances).

Analogy: You assign a supervisor to each worker to oversee their tasks.

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

        //Create the instances of the tasks in the main 
        CarpenterTask carpenter = new CarpenterTask();
        PainterTask painter = new PainterTask();

        //Create the Thread Objects
        Thread carpenterThread = new Thread(carpenter);
        Thread painterThread = new Thread(painter);

    }
}

6. Start the Threads

Finally, start the threads using the start() method. This kicks off the tasks, and the workers (threads) begin working concurrently.

Analogy: You tell the supervisors to start overseeing their workers, and each worker begins their assigned task.

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

        //Create the instances of the tasks in the main 
        CarpenterTask carpenter = new CarpenterTask();
        PainterTask painter = new PainterTask();

        //Create the Thread Objects
        Thread carpenterThread = new Thread(carpenter);
        Thread painterThread = new Thread(painter);

        //Start the threads
        carpenterThread.start();
        painterThread.start();

    }
}

With these steps, you've created a multi-threaded program in Java where different tasks are performed concurrently, just like different workers at a construction site simultaneously working on carpentry and painting tasks.

How to Check Thread Names in Java?

In a multi-threaded Java program, you can easily obtain the name of the currently executing thread by calling Thread.currentThread().getName(). This allows you to identify which thread is executing a particular task.

Let's see how to do this in the context of our Carpenter and Painter tasks:

class CarpenterTask implements Runnable {
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println("Carpenter task is being executed by thread: " + threadName);
        // Code for carpentry work
    }
}

class PainterTask implements Runnable {
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println("Painter task is being executed by thread: " + threadName);
        // Code for painting work
    }
}

//Expcted Output -
//Carpenter task is being executed by thread: Thread-0
//Painter task is being executed by thread: Thread-1

In the above code, we've added lines to print the thread name within each task's run method using Thread.currentThread().getName().

In this example, "Thread-0" represents the thread executing the Carpenter task, and "Thread-1" represents the thread executing the Painter task. The thread names are generated automatically by Java, and they typically have a format like "Thread-X," where X is a unique identifier for each thread.

Closing Thoughts:

Stay connected with us for more insightful articles on various topics related to technology, programming, and much more.

DEV Community: Code Craft Club

COMPARATOR vs COMPARABLE - A Java Surprise You did in School!

Let's head back to Schooling Days

Comparable: A Natural Order of Students

Implementation of Comparable Interface in 3 Steps:

1. Implement the Comparable Interface:

2. Override the compareTo() Method:

3. Using Comparable:

Now let's see a twist in our example..

Implementation of Comparator Interface in 3 Steps:

1. Create a Comparator Class:

2. Override the compare() Method:

3. Use the Comparator:

Closing Thoughts:

Streams in Java made super simple with examples! — An Easy Beginner’s Guide!

Stream

Creating an Empty Stream

Creating a Stream with Collections

Direct creation of Stream

How to work with Streams?

Intermediate Operations

Filter()

Map()

Sorted()

Distinct()

Terminal Operations

ForEach()

reduce()

count()

ForEach() vs Map()

Closing Thoughts:

Semaphores, is that so easy!! The Clothing Store Analogy as a Guide for Beginners

Introduction to Semaphores

The Clothing Store Analogy

Creating the Java Classes

The Store Class (Critical Section)

The Producer Class

The Consumer Class

The Main Method

With Semaphores → Order is Restored

Adding Semaphores in the Main class

Adding Semaphores in the Producer class

Adding Semaphores in the Consumer class

Conclusion

Closing Thoughts:

Mutex & Race Conditions in Java Multi-Threading made so simple with real-life analogies

The Need for Synchronization

*Three Reasons for Synchronization Issues*

1. Critical Section

2. Race Conditions

3. Preemptiveness

Ideal Properties of a Synchronization Solution

MUTEX (Mutual Exclusion)

Properties of a Mutex Lock in Java

Synchronization in Adder & Subtractor

The SharedResource class:

The Adder class:

The Subtractor class:

The Main class:

Behavior of the code Without Locks:

Implementation for Synchronization:

Conclusion

Closing Thoughts:

Multi-Threading in JAVA using Callables

Introduction to Callables

Online Shopping:

Using Callables in Multi-Threaded Programs

Step 1: Identify Tasks Needing Data Returns

Step 2: Create Callable Classes

Step 3: Implement the call() Method

Step 4: Create a Main Class Using Executor Service

Understanding the use of Future with Callable

Analogy:

Closing Thoughts:

Generics in Java was never this EASY! — A Complete Beginner’s Guide!

What Are Generics?

The Need for Generics

Type Parameters and Representation

Generic Classes

Analogy -

The `Store` Class (Critical Section)

The `Producer` Class

The `Consumer` Class

The `Main` Method

Three Reasons for Synchronization Issues

The `SharedResource` class:

The `Adder` class:

The `Subtractor` class:

The `Main` class:

Step 3: Implement the `call()` Method

Understanding the use of `Future` with `Callable`