DEV Community: aryan

Static Class in Java

aryan — Mon, 09 Nov 2020 07:43:47 +0000

Take a look at this article, we are going to study what is a static class in java and how we can create it. Later, we will discuss some implementation consideration and benefits of using a static class

Visit the original article: https://www.java8net.com/2020/11/static-class-in-java.html

Before starting our tutorial on the static class, we first want to briefly remind you that "What is static?", Static is a keyword that can be used with class, variable, method, and block to create static members. Static members belong to the class instead of a specific instance, this means if you make a member static, .you can access it without an object.

A static member can be:

static variables,
static methods,
static block or static initialization block, and,
static class

Static classes are basically a way of grouping classes together in Java. Java doesn't allow you to create top-level static classes; only nested (inner) classes. For this reason, a static class is also known as a static inner class or static nested class. Let's have a look at how to define a static class in java. Let's have a look at how to define a static class in java.

class Employee {
    private String name;
    private String email;
    private String address;

    User(String name, String email, String address) {
        this.name = name;
        this.email = email;
        this.address = address;
    }
    public String getName() {
        return name;
    }
    public String getEmail() {
        return email;
    }
    public String getAddress() {
        return address;
    }

    static class Validator {

        boolean validateEmployee(Employee employee) {
            if (!isValidName(employee.getName())) {
                return false;
            }
            if (!isValidEmail(employee.getEmail())) {
                return false;
            }
            return true;
        }
        private boolean isValidName(String name) {
            if (name == null) {
                return false;
            }
            if (name.length() == 0) {
                return false;
            }
            return true;
        }
        private boolean isValidEmail(String email) {
            if (email == null) {
                return false;
            }
            if (email.length() == 0) {
                return false;
            }
            return true;
        }
    }
}

Points to be considered while writing a static class

It can only be a nested or inner class only.
It can have any access modifier (private, protected, public, or default) like any other static member.
It can only access the static members of its enclosing class.
It cannot access the non-static members of its enclosing class directly. It can interact with the non-static member only through the object of its enclosing class only.

Benefits of Static class in java

We can define the related or helper classes inside the class by making it static.
It can access the private member of the enclosing class through the object reference.
It provides a nice namespace for the nested class.
If the enclosing class gets updated, we are able to update the static class as well at the same location.
Classloader loads the static class in JVM only at the time of the first usage, not when its enclosing class gets loaded.

Visit the original article: https://www.java8net.com/2020/11/static-class-in-java.html

Conclusion

In this article, we have studied what is a static class in java, how to create it and it's benefits. We have created a User with UserValidator class to provide the facility to check whether it is a valid user or not. It is good to have helper classes as a static class inside the enclosing class.

Immutable class in Java

aryan — Wed, 04 Nov 2020 11:05:06 +0000

In this article, we'll define the typical steps for creating an immutable class in Java and also shed light on the common mistakes which are made by developers while creating immutable classes.

visit the original article: https://www.java8net.com/2020/11/immutable-class-in-java.html

Steps to create Immutable class in java

Make your class final, so that no other classes can extend it.
Make all fields private so that direct access is not allowed.
Don’t provide “setter” methods — methods that modify fields or objects referred to by fields.
Special attention when having mutable instance variables 4.1) Inside the constructor, make sure to use a clone copy of the passed argument and never set your mutable field to the real instance passed through the constructor. 4.2) Make sure to always return a clone copy of the field and never return the real object instance.

Implementation of Immutable class in java

class Address{
    private String houseNumber;
    private String street;
    private String city;
}

final class User {
    private final int id;
    private final String name;
    private final String email;
    private final Address address;

    /*
     * To clone the address.
     */
    private static Address cloneAddress(Address address) {
        return new ObjectMapper().convertValue(address, Address.class);
    }

    User(int id, String name, String email, Address address) {
        this.id = id;
        this.name = name;
        this.email = email;
        /*
         * Any field contains reference of any mutable 
                 * object must be
         * initialized with the cloned object
         */
        this.address = cloneAddress(address);
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public String getEmail() {
        return email;
    }
    public Address getAddress() {
        /*
         * Getter method must return the reference of cloned object.
         */
        return cloneAddress(address);
    }
}

Pre-defined Immutable class in java

The string class represents the immutable object for the sequence of characters.
Wrapper classes like Integer, Float, Long, etc. all represent the immutable object for the corresponding primitive type.
java.util.UUID represents a unique 128-bit hexadecimal string.

Benefits of making an Immutable class in java

Immutable objects are by default thread-safe.
Immutable objects can easily be cached.
Immutable objects are the best options to use as a key object in any map like HashMap.

visit the original article: https://www.java8net.com/2020/11/immutable-class-in-java.html

Synchronized ArrayList in Java

aryan — Mon, 06 Apr 2020 16:36:12 +0000

Implementation of arrayList is not synchronized is by default. It means if a thread modifies it structurally and multiple threads access it concurrently, it must be synchronized externally. Structural modification means the addition or deletion of the element from the list or explicitly resizes the backing array. Changing the value of existing element is not structural modification.

See Reference: https://www.java8net.com/2020/03/synchronized-arraylist-in-java.html

import java.util.*;

class ArrayListExample
{
public static void main (String[] args)
{
List list =
Collections.synchronizedList(new ArrayList());

    list.add("A"); 
    list.add("B"); 
    list.add("C"); 

    synchronized(list) 
    { 
        // must be in synchronized block 
        Iterator it = list.iterator(); 

        while (it.hasNext()) 
            System.out.println(it.next()); 
    } 
}

}

See Reference: https://www.java8net.com/2020/03/synchronized-arraylist-in-java.html

Further Readings
https://www.java8net.com/2020/03/java-arraylist-common-program-examples.html
https://www.java8net.com/2020/02/how-to-sort-arraylist-in-java.html
https://www.java8net.com/2020/03/initialize-arraylist-in-java.html
https://www.java8net.com/2020/03/how-to-remove-duplicates-from-arraylist-in-java.html
https://www.java8net.com/2020/03/arraylist-to-hashmap-in-java.html

How to serialize and deserialize ArrayList in Java

aryan — Mon, 23 Mar 2020 07:18:23 +0000

ArrayList is serializable by default. This means you need not to implement Serializable interface explicitly in order to serialize an ArrayList. In this tutorial, we will learn how to serialize and de-serialize an ArrayList.

See original article: https://www.java8net.com/2020/03/serialize-arraylist-in-java.html

Serialization of ArrayList:

ArrayList arrayList = new ArrayList<>(
Arrays.asList("A", "B", "C", "D", "E"));
try {
FileOutputStream fileOutputStream = new FileOutputStream("data");
ObjectOutputStream objectOutputStream
= new ObjectOutputStream(fileOutputStream);

  objectOutputStream.writeObject(arrayList);

  objectOutputStream.close();
  fileOutputStream.close();

} catch (IOException e) {
e.printStackTrace();
}

Deserialization of ArrayList:

try {
FileInputStream fileInputStream = new FileInputStream("data");
ObjectInputStream objectInputStream
= new ObjectInputStream(fileInputStream);

   ArrayList<String> arrayList 
            = (ArrayList<String>) objectInputStream.readObject();
   System.out.println(arrayList);

   fileInputStream.close();
   objectInputStream.close();

} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}

To learn in details, visit: https://www.java8net.com/2020/03/serialize-arraylist-in-java.html

Further Readings:
https://www.java8net.com/2020/03/synchronized-arraylist-in-java.html
https://www.java8net.com/2020/02/how-to-sort-arraylist-in-java.html
https://www.java8net.com/2020/03/initialize-arraylist-in-java.html
https://www.java8net.com/2020/03/arraylist-to-hashmap-in-java.html

How to initialize ArrayList in Java?

aryan — Wed, 18 Mar 2020 05:56:36 +0000

The Java ArrayList can be initialized in number of ways depending on the requirement. In this tutorial, we will learn to initialize ArrayList based on some frequently seen usecases.

See original article: https://www.java8net.com/2020/03/initialize-arraylist-in-java.html

How to initialize ArrayList in Java - using Arrays.asList() method?

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayListExample {
public static void main(String[] args) {
ArrayList list = new ArrayList<>(
Arrays.asList("A", "B", "C", "D", "E"));
System.out.println("ArrayList : " + list);
}
}

How to compare two ArrayList in Java?

aryan — Sat, 14 Mar 2020 14:24:53 +0000

Learn to compare two ArrayList in Java with simple examples. We will first test if two ArrayList are equal or not. If both lists are not equal, we will find the difference between lists.

The difference in the list equals another third list which contains either additional elements or missing elements.

Also, learn to find common elements between two ArrayList.

See the original post: https://www.java8net.com/2020/03/compare-two-arraylist-in-java.html

Compare two ArrayList for equality

With the help of the equals() method, we can compare two ArrayList in java and check whether they are the same or not. But, here is a condition, the order of the elements of both the ArrayList must be the same. Otherwise, it won't work. To be sure, we can sort the ArrayList (sorting can be ascending or descending) and then apply the equals() method for comparison.

Read Article to learn how to sort ArrayList in Java: https://www.java8net.com/2020/02/how-to-sort-arraylist-in-java.html

import java.util.ArrayList;

public class ArrayListExample {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
list1.add("A");
list1.add("B");
list1.add("C");
list1.add("D");
ArrayList list2 = new ArrayList();
list2.add("A");
list2.add("B");
list2.add("C");
list2.add("D");
System.out.println(list2);
System.out.println(list1.equals(list2));
}
}

If you want to learn in detail: https://www.java8net.com/2020/03/compare-two-arraylist-in-java.html

Further Reading:
https://www.java8net.com/2020/03/java-arraylist-common-program-examples.html
https://www.java8net.com/2020/03/java-sublist-from-arraylist.html
https://www.java8net.com/2020/03/how-to-remove-duplicates-from-arraylist-in-java.html
https://www.java8net.com/2020/03/iterate-arraylist-in-java.html
https://www.java8net.com/2020/03/arraylist-to-array-in-java.html

How HashMap works internally in java

aryan — Tue, 03 Mar 2020 18:14:22 +0000

This is article is about how hashmap works internally in java. It is very important to understand the concept of hashmap as hashmap comes into our day-to-day programming practice and it is the most favorite question on the interviewer during the interviews.

Original Article: https://www.java8net.com/2020/01/how-hashmap-works-internally-in-java.html

What is Hashmap and Hashing in java?

How Hashmap works Internally in Java is majorly dependent upon the Hashing Principle. So, Before going to learn how HashMap works internally in java, lets first understand what is HashMap and hashing.

HashMap :
A HashMap is a map used to store mappings of key-value pairs. Also, it works on the Principle of Hashing. To know more about the HashMap, visit this article: https://www.java8net.com/2020/01/hashmap-in-java.html

Hashing Principle :
Simply, Hashing is a method used to produce an integer value from an object and this integer value known as the hash value. In HashMap, the key object is used for Hashing.

Before understanding the internal working of HashMap, you must be aware of the hashCode() and equals() method.

hashCode() : hashCode() method is used to get the hash code of an object. This method is provided by Object class. You can override this in your class to provide your own implementation.

equals(): equals method is used to check that 2 objects are equal or not. This method is provided by Object class. You can override this in your class to provide your own implementation.

What is Buckets?:
The array of the node is called buckets. Each node has a data structure like a LinkedList. More than one node can share the same bucket. It may be different incapacity.
A single bucket can have more than one nodes, it depends on the hashCode() method. The better your hashCode() method is, the better your buckets will be utilized.

Hash Collision :
Here comes the main part. Now, as we know that two unequal objects can have the same hash code value, how two different objects will be stored in the same array location called a bucket.

The answer is LinkedList. If you remember, the Entry class had an attribute “next”. This attribute always points to the next object in the chain. This is exactly the behavior of the LinkedList.

How Hashmap Calculate the Index of Bucket in java?

To understand how HashMap works internally in Java, we must know about how the HashMap calculates the index of the bucket. Till now, we know the internal structure of HashMap, that HashMap maintains an array of the bucket. But when we store or retrieve any key-value pair, HashMap calculates the index of the bucket for each and every operation.

The Key object is used to calculate the index of the bucket. By using this key, the hash value is calculated using the hash(key) private method of HashMap.

Note: hash(key) method is a private method of HashMap that returns the hash value of the key, also if the hash value is too large then converts it into a smaller hash value.

But what will happen, if the hash value of Key Object returns the integer that is greater than the size of the array i.e., hash(key) > n, then ArrayOutOfBoundsException could be raised. To handle this situation, HashMap reduces the hash value between 0 and n-1 using an expression:

Index Calculating Expression
index = hash(key) & (n-1)
Now, this index value is generated is used by HashMap to find bucket location and can never generate any Exception as the index value always from 0 to n-1.

To know more about the internal working of the hashmap, read this blog: https://www.java8net.com/2020/01/how-hashmap-works-internally-in-java.html

Further Learning:
https://www.java8net.com/2020/02/sort-hashmap-by-key-and-by-value.html
https://www.java8net.com/2020/11/static-class-in-java.html
https://www.java8net.com/2020/02/treemap-in-java.html
https://www.java8net.com/2020/03/java-optional.html
https://www.java8net.com/2020/01/lambda-expression-java.html
https://www.java8net.com/2020/01/functional-interface-in-java.html

Sort HashMap By key and By value

aryan — Tue, 03 Mar 2020 18:07:32 +0000

In this article, we are going to have look at how to sort HashMap by key and to sort HashMap by value in Java. We are going to learn different approaches to sort HashMap.

Visit this link to read the full article: https://www.java8net.com/2020/02/sort-hashmap-by-key-and-by-value.html

HashMap does not sort its key-value pair and also it does not maintain any order (neither insertion nor sorted). If we want to sort HashMap then we need to provide custom logic that can sort HashMap and sort HashMap by key we can use either TreeMap or LinkedHashMap but in case of sort HashMap by value, we have the only option of LinkedHashMap as TreeMap cannot be used to sort HashMap by value.
To sort HashMap by key, we can use TreeMap class. TreeMap in java is used to store key-value pairs and sort all the pairs w.r.t. keys. We can create a TreeMap from the HashMap and TreeMap sort HashMap by key.

Steps to sort HashMap by key using TreeMap

Create a Comparator, which provides logic to sort HashMap by key.
Create a TreeMap using Comparator.
Add all the entries of HashMap into the TreeMap

Java Sort HashMap Example
HashMap hashMap = new HashMap<>();
hashMap.put("Programming In Java", 450);
hashMap.put("Introduction to Algorithms", 800);
hashMap.put("Data Structures", 600);
hashMap.put("Learn C++", 350);
System.out.println("-----------Before Sorting--------------");
Set> unsortedEntrySet = hashMap.entrySet();
for (Entry entry : unsortedEntrySet) {

System.out.println(entry.getKey() + " = " + entry.getValue());
}

Comparator keyComparator = (s1, s2) -> s1.compareTo(s2);
TreeMap treeMap = new TreeMap<>(keyComparator); treeMap.putAll(hashMap);
System.out.println("-----------After Sorting---------------");
Set> sortedEntrySet = treeMap.entrySet();
for (Entry entry : sortedEntrySet) {
System.out.println(entry.getKey() + " = " + entry.getValue());
}

Visit this link to read the full article: https://www.java8net.com/2020/02/sort-hashmap-by-key-and-by-value.html

Further Learning:
https://www.java8net.com/2020/02/how-to-sort-arraylist-in-java.html
https://www.java8net.com/2020/02/treemap-in-java.html
https://www.java8net.com/2020/03/java-optional.html
https://www.java8net.com/2020/01/lambda-expression-java.html
https://www.java8net.com/2020/01/functional-interface-in-java.html