Java Exception Hierarchy

As shown in the exception hierarchy, a Throwable class is a superclass of all errors and exceptions in Java. Objects those are instances of Throwable or one of its subclasses are thrown by JVM or by Java throw statement.

Error:
An Error is a subclass of Throwable that represents serious errors that can’t be handled. A method is not required to declare throws clause for Error or any of its subclasses for the errors thrown during execution of the method but not caught.

Error and its subclasses are unchecked exceptions.
Here are the examples of errors: OutOfMemoryError, StackOverflowError, AssertionError, IOError, NoClassDefFoundError etc.

Exception:
Exception is a subclass of Throwable. Exception and its subclasses represent the problems from which a program can recover and should be handled by the application.
Exception has two sub type:

1. RunTimeException or Unchecked Exception:
The classes that extends RunTimeException are called unchecked Exception. An unchecked exception occurs at run-time, it can’t be checked at compile time, an application should handle these exceptions. For example: NullPointerException, ArithmeticException, IllegalArgumentException, IndexOutOfBoundException etc.

2. Checked Exception:
The classes that extends Throwable class except RunTimeExpception and Error are called Checked Exception. Checked exception are checked at compile time and application should handle these exceptions. For example: IOException, SQLException, FileNotFoundException, ClassNotFoundException, NoSuchMethodException etc.

User-defined custom exception:
We can also create our own exception. Here are few rules:
1. All exception must be a child of Throwable.
2. To create a RuntimeException, we need to extend the RunTimeException class.
3. To create the checked exception, we need to extend the Exception class.

Reference:
https://docs.oracle.com/javase/8/docs/api/java/lang/Throwable.html
https://docs.oracle.com/javase/8/docs/api/java/lang/Error.html

The post Java Exception Hierarchy appeared first on Manish Sanger.

Generics in Java provide type checking at compile time and it has nothing to do at runtime. Java compiler uses Type Erasure feature to remove all generics type checking code (replace it with bound or Object if the type parameters are unbounded) in bytecode, insert type casting if necessary and generate bridge methods to preserve polymorphism in extended generic types.

Here is an example of generic a class:

class TypeErasureExample {

private T t;

public TypeErasureExample(T t) {

this.t = t;

}
public T getT() {

return t;

}

}

After compilation the type will be replaced with String as follows:

class TypeErasureExample {

private String t;

public TypeErasureExample(String t) {

this.t = t;

}
public String getT() {

return t;

}

}

Type erasure at class or class variable level:
At the class level, type parameters on the class are removed at compile time and replaced with its first bound or Object if the type parameter is unbound.
Here are few examples:
Type erasure when type parameter is unbound:

class TypeErasureUnboundExample {

private T t;

public TypeErasureUnboundExample(T t) {

this.t = t;

}
public T getT() {

return t;

}

}

After compilation the type will be replace with Object (because type parameter is unbound) as follows:

class TypeErasureUnboundExample {

private Object t;

public TypeErasureUnboundExample(Obhect t) {

this.t = t;

}
public Object getT() {

return t;

}

}

Type erasure when type parameter is bound:

class TypeErasureExample {

private T t;

public TypeErasureExample(T t) {

this.t = t;

}
public T getT() {

return t;

}

}

After compilation the type will be replaced with String (with first bound) as follows:

class TypeErasureExample {

private String t;

public TypeErasureExample(String t) {

this.t = t;

}
public String getT() {

return t;

}

}

For example:
If type parameter is unbounded:

public static  void genericMethod(T t){

        System.out.println(t);

    }

Will be converted to following at compile time:

public static void genericMethod(Object t){

        System.out.println(t);

    }

If type parameter is bounded:

public static  void genericMethod(T t){

        System.out.println(t);

    }

Will be converted to following at compile time:

public static void genericMethod(String t){

        System.out.println(t);

    }

The post Type Erasure – Java Generics appeared first on Manish Sanger.

Here is an example of ArrayList without using generics:

List names = new ArrayList();

names.add("Manish");

String name = (String) names.get(0); //Type casting when retrieving the element from the array list

Integer number = (Integer) names.get(0); //Run-time error, ClassCastException will be thrown.

When we use the ArrayList without generics, will have to type cast when we retrieve the element from the ArrayList, as the program doesn’t know the type of element stored in ArrayList. Also, when we try to type cast the element in the wrong way as I did in the code above, trying to type cast the element to Integer it will throw run-time ClassCastException error. Without generics, we only get the errors at the run-time not at compile time.

We can rewrite the code using generics as follows:

List names = new ArrayList();

names.add("Manish");

String name = names.get(0); //No type casting is required.

Creating custom Java generic Class:
We can create our own generic class. A generic type is a class or interface that is parameterized over types, we use angle bracket (<>) to specify the type parameter.
Note: Type argument can’t be of a primitive type.

public class GenericExample {

    private T t;

    public T getT() {

        return t;

    }

    public void setT(T t) {

        this.t = t;

    }

}

class GenericTest{

    public static void main(String[] args) {

        //Instance with String type

        GenericExample genericExample = new GenericExample<>();

        genericExample.setT("Test");
        //Instance with Integer type

        GenericExample genericExample1 = new GenericExample<>();

        genericExample1.setT(100);
        //Type argument can't be primitive type.

    }

}

Class with multiple type parameters:

public class GenericExample {

    private T t;

    private U u;

    public GenericExample(T t, U u) {

        this.t = t;

        this.u = u;

    }

}
class GenericTest{

    public static void main(String[] args) {

        //Instance with String type

        GenericExample genericExample = new GenericExample<>("Test", 100);

    }

}

Generic Method
We can also create the generic method or constructor, no need to parameterize the whole class.

class GenericMethodTest{

    static  void genericMethod(T t){

        System.out.println(t);

    }

    public static void main(String[] args) {

        GenericMethodTest.genericMethod("Test");

        GenericMethodTest.genericMethod("Test 2"); //Using type interface

    }

}

In the above code, we can specify the type when calling the method or can just call like a normal method without specifying any type, JVM will do it for you. This feature is called type interface.

Java generics bounded type parameters:
If we want to restrict the type of objects which can be used as parametrized type:

class GenericBound {

    private T t;

    public GenericBound(T t) {

        this.t = t;

    }

}

Java generic type naming convention (Best practices)
As per the Java best practices, type parameter should be single and uppercase letters. Following are the commonly used type parameters:

• T – Type
• E – Element (Used extensively in collection framework)
• N – Number
• K – Key
• V – Value
• S,U,V etc. – 2nd, 3rd, 4th types

The post Java Generics appeared first on Manish Sanger.

Prior to Java 7, there was no auto resource management, we open the resource in a try block and close the resource in finally block. For example:

try{

//open resources

}catch(IOException){

//Exception handling

}finally{

//close resource

}

In the above approach there were few drawbacks:

1. It causes memory leaks and performance issue if the developer forgot to close the resource.
2. Finally block will always be executed, it doesn’t matter if the exception is thrown from the try block. It means, it tries to close the resource in finally block, even if it doesn’t exist which again cause an exception to be thrown from finally block.
3. Exception thrown from finally block will be propagated up the call stack, though exception from try block is more relevant.

try-with-resource
In Java 7, a new approach called “try-with-resources” is introduced for auto resource management. In this when try block finishes, it automatically closes the resource.

Here is an example for try-with-resource construct:

private static void readFile() throws IOException {

try(FileInputStream input = new FileInputStream("file.txt")) {

int data = input.read();

while(data != -1){

System.out.print((char) data);

data = input.read();

}

}

}

try-with-resource using multiple resources
We can use multiple resources in try-with-resource block, it will automatically close both the resources when program finish executing try block.

private static void readFile() throws IOException {

try(  FileInputStream input = new FileInputStream("file.txt");

BufferedInputStream bufferedInput = new BufferedInputStream(input)

) {

int data = bufferedInput.read();

while(data != -1){

System.out.print((char) data);

data = bufferedInput.read();

}

}

}

The resources are closed in reverse order of they are declared inside the try. BufferedInputStream will be closed first, then FileInputStream.
 
AutoCloseable Custom implementation
Java 7 has introduced an interface java.lang.AutoCloseable. To use any resource in try-with-resource block, it must implement the AutoCloseable interface. We can also implement java.lang.AutoCloseable interface in our own classes and use them with the try-with-resources construct.
AutoCloseable interface only has one method class close(). Here is the AutoCloseable interface:

public interface AutoCloseable {

public void close() throws Exception;

}

 
Exception handling with try-with-resource:
If one or more exceptions are thrown by try block in try-with-resources, the exceptions thrown are suppressed exception.
Java added an constructor and two methods in Throwable class to deal with suppressed exceptions. We can get these exceptions by using the getSuppress() method of Throwable class.

Advantages of using try-with-resource construct:

1. Auto resource management.
2. More readable code.
3. No need of finally block just to close the resource.
4. Meaning & relevant exceptions.

The post Java Try with Resources appeared first on Manish Sanger.

In java 8, predicate is an functional interface java.util.function.Predicate<T> which defines an abstract method named test, that accepts an object of generic type T and returns a boolean. Predicate can be used as assignment target for a lambda expression or method reference.

Example:

package com.manishsanger.Predicate;

public class Vehicle {

private String type;

private Integer displacement;
public Vehicle(String type, Integer displacement) {

this.type = type;

this.displacement = displacement;

}
@Override

public String toString() {

return "Vehicle - Type:" + this.getType() + ", Displacement:" + this.getDisplacement() +"cc";

}
public String getType() {

return type;

}
public void setType(String type) {

this.type = type;

}
public Integer getDisplacement() {

return displacement;

}
public void setDisplacement(Integer displacement) {

this.displacement = displacement;

}

}

If we need to get the vehicle whose displacement is more that 1500 cc, we can write a predicate for it as below:

public class VehiclePredicate {

public static Predicate<Vehicle> isDisplacementAbove1500() {

return vehicle -> vehicle.getDisplacement() >= 1500;

}

}

We can user this predicate in filter(), to filter list of vehicle by condition in the predicate.

package com.manishsanger.Predicate;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;
public class Example {
public static void main(String[] args) {

List<Vehicle> vehicles = Arrays.asList(

new Vehicle("SUV", 2200),

new Vehicle("SUV", 1800),

new Vehicle("SEDAN", 1600),

new Vehicle("HATCHBACK", 1400),

new Vehicle("SUV", 2800)

);
//Using default filter() method, using stream and lambda expression.
//return all Vehicles those have displacement more than 1500

System.out.println("All vehicles those have displacement more than 1500, Using default filter() method.");

vehicles.stream().filter(vehicle -> {

return vehicle.getDisplacement() >= 1500;

}).collect(Collectors.toList()).forEach(System.out::println);
//return all Vehicles those have displacement more than 1500

System.out.println("All SUV those have displacement more than 1500, Using default filter() method.");

vehicles.stream().filter(vehicle -> {

return vehicle.getType().equals("SUV") && vehicle.getDisplacement() >= 1500;

}).collect(Collectors.toList()).forEach(System.out::println);
}

}

Following will be the output:

All vehicles those have displacement more than 1500, Using default filter() method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

All SUV those have displacement more than 1500, Using default filter() method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SUV, Displacement:2800cc

We can also define our own custom filter method(), Now add a filterVehicles() method in VehiclePredicate class.

public static List<Vehicle> filterVehicles(List vehicles, Predicate<Vehicle> predicate) {

return vehicles.stream().filter(predicate).collect(Collectors.toList());

}

Add following code to Main class, to filter data using custom Predicate filter:

//Using custom filter method and java 8 lambda

System.out.println("\nAll vehicles those have displacement more than 1500, Using default custom filter method.");

VehiclePredicate.filterVehicles(vehicles, vehicle -> {

return vehicle.getDisplacement() >= 1500;

}).forEach(System.out::println);

Here is the output:

All vehicles those have displacement more than 1500, Using default custom filter method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

Here is how you can filter the list without lambda expression:

//Using custom filter method and without lambda

System.out.println("\nAll vehicles those have displacement more than 1500, Using default custom filter method without lambda.");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isDisplacementAbove1500()).forEach(System.out::println);

Here is the output, for the above block of code:

All vehicles those have displacement more than 1500, Using default custom filter method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

Java 8 Predicate Methods
Let’s now go through the methods available for Predicate:

1. Default Predicate and (Predicate other)

It returns a composed predicate that represents a logical AND of two predicates.

To understand this let’s add another predicate in the VehiclePredicates class:

public static Predicate<Vehicle> isTypeSUV() {

return vehicle -> vehicle.getType().equals("SUV");

}

Now we can apply and() and or() function if we want to predicate for Vehicle of type SUV and displacement more than 1500 cc.

Here is the code for Main method:

//Multiple filter with AND logical operator

System.out.println("\nAll SUV those have displacement more than 1500, Using custom Predicate filter without lambda.");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isDisplacementAbove1500().and(VehiclePredicate.isTypeSUV())).forEach(System.out::println);

//Multiple filter with OR logical operator

System.out.println("\nAll Vehicle those have displacement more than 1500 or SUV, Using custom Predicate filter without lambda.");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isDisplacementAbove1500().or(VehiclePredicate.isTypeSUV())).forEach(System.out::println);

Here is the output:

All SUV those have displacement more than 1500, Using custom Predicate filter without lambda.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SUV, Displacement:2800cc

All Vehicle those have displacement more than 1500 or SUV, Using custom Predicate filter without lambda.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

2. Default Predicate negate()
It return an predicate that represents logical NOT operator.

For example all Vehicles other than SUV:

//default negate(), Logical NOT operator. All vehicles other than SUV

System.out.println("\nAll vehicles other than SUV, using negate()");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isTypeSUV().negate()).forEach(System.out::println);

Here is the output:

All vehicles other than SUV, using negate()

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:HATCHBACK, Displacement:1400cc

3. Boolean test (T t)
Predicate test evaluates this predicate on the given argument.
For example we can pass an Vehicle object to check if this predicate return true or false:

Add the following code in main method:

//boolean test(T t) predicate

System.out.println("\nboolean test predicate");

Vehicle testVehicle = new Vehicle("SUV", 1000);

System.out.println(VehiclePredicate.isTypeSUV().test(testVehicle));

System.out.println(VehiclePredicate.isDisplacementAbove1500().test(testVehicle));

Here is the output:

boolean test(T t) predicate

true

false

4. static Predicate isEqual(Object targetRef)
Returns a predicate that tests if two arguments are equal according to Objects.equals() method.

Let’s say we overridden equals() method for Vehicle class

@Override

public boolean equals(Object obj) {

Vehicle vehicle = (Vehicle) obj;

if (this.getType().equals(vehicle.getType()) && this.getDisplacement().equals(vehicle.getDisplacement())) {

return true;

}

return false;

}

Now let’s say we have a Vehicle which has standard type & displacement. Then we can get a Predicate, that will test if the given Vehicle is standard or not.

//static Predicate isEqual(Object targetRef)

System.out.println("\nstatic Predicate isEqual(Object targetRef)");

Predicate standardVehiclePredicate = Predicate.isEqual(new Vehicle("SUV", 1800));

System.out.println(standardVehiclePredicate.test(new Vehicle("SUV", 1800)));

System.out.println(standardVehiclePredicate.test(new Vehicle("SUV", 1500)));

Here is the output:

static Predicate isEqual(Object targetRef)

true

false

Click here to see the source code

The post Predicate – Functional Interface (Java 8) appeared first on Manish Sanger.

Java introduced Functional interface & Lambda Expressions in Java 8, to leverage functional programming to reduce verbosity.

What is functional Interface?

A Functional Interface is an interface which specifies exactly one abstract method. Its implementation may be treated as Lambda Expression.

Note: An interface is still a functional interface if it has many default methods, as long as it specifies only one abstract method.

Since default methods have an implementation, they are not abstract. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface’s abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere

While the main use of Functional interfaces is for lambda expressions, method references, and constructor references, they can still be used, like any interface, with anonymous classes, implemented by classes, or created by factory methods.

Java 8 provides some inbuilt functional interfaces like Comparable, Runnable, Callable etc.

If you want to define any functional interface of your own, you can use annotation @FunctionalInterface for compiler level errors. It will allow to specify only one abstract method.

Example:

@FunctionalInterface

public interface SomeInterface {

public String someMethod(String param);

}

A functional interface is valid even if the @FunctionalInterface annotation would be omitted. It is only for informing the compiler to enforce single abstract method inside interface.

Public interface SomeInterface {

String someMethod(String param);

}

//With default method

@FunctionalInterface

Public interface SomeInterface {

public String someMethod(String param);

default void someDefaultMethod(){

//method Implementation

}
}
// When overriding methods from the java.lang.Object
@FunctionalInterface

Public interface SomeInterface {

public String someMethod(String param);

@Override

public String toString();  //Overridden from Object class
@Override

public boolean equals(Object obj); //Overridden from Object class
}

The signature of abstract method in functional interface is called Functional descriptor because it defines the signature of the lambda expression.

Java 8 has introduced several functional interfaces in java.util.function package which can be used to describe the signature of various lambda expressions.

Here is the complete list of functional interfaces available in java.util.functional:

1. Predicate
2. Consumer
3. Function<T, R>
4. Supplier
5. UnaryOperator
6. BinaryOperator
7. BiPredicate<L, R>
8. BiConsumer<T, U>
9. BiFunction<T, U, R>

The post Functional Interface – Java 8 appeared first on Manish Sanger.