Serialization in Java

There are different ways in Java to read data from files and to write data to files.

1. Using Scanner

Scanner can be used to read input from the user. It can read all the primitive data types.

Scanner obj = new Scanner(System.in);

String input = obj.nextLine();

2. Using FileReader

FileReader can be used to read character data from a file. It returns the ASCII value for each character and -1 at the end.

FileReader fr=new FileReader("D:\\test.txt");    

int i;    

while((i=fr.read())!=-1)    

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

fr.close();

3. Using FileInputStream

FileInputStream can be used to read raw data (non-character) from a file. It returns a byte stream.

File file = new File("D:\\test.jpg");

FileInputStream in = new FileInputStream(file); // convert image to byte stream

byte[] arr = new byte[(int)(file.length())];

in.read(arr);  // convert byte stream to byte array

in.close();  

Serialization

Combining the features of FileInputStream and ObjectInputStream gives a new possibility. FileInputStream converts raw file data to byte stream and ObjectInputStream converts byte stream to object. Similarly, FileOutputStream converts byte stream to raw file and ObjectOutputStream converts  object to byte stream. This process of converting an object into a stream of bytes is called Serialization. The main purpose is to transmit the object over a network and recreate the object later. Though JSON is the most preferred way of Serialization, Java provides its own default way.

The class needs to implement the Serializable marker interface. All of the fields in the class must be serializable. If a field is not serializable, it must be marked transient. When the class will be de-serialized, the transient variable will be initialized with a default value. The serialVersionUID attribute needs to be added in the class to verify that sender and receiver of the serialized object is the same. 

FileOutputStream out = new FileOutputStream(filePath);

ObjectOutputStream objectOutputStream = new ObjectOutputStream(out);

objectOutputStream.writeObject(obj); // serialization

FileInputStream in = new FileInputStream(filePath);

ObjectInputStream objectInputStream = new ObjectInputStream(in);

obj = (Obj) objectInputStream.readObject(); //de-serialization

Externalizable is an Interface that extends Serializable Interface and sends data into Streams in Compressed Format.

Static in Java

Static keyword in java means 'belongs to class'. This applies to variables, methods, blocks and nested classes. 

Static variable

Static variables are loaded into the memory as soon as the JVM starts. The value of a static variable remains the same across the instances because a common static memory is allotted to it. They are accessed using Classname. The main purpose of a static variable is memory optimization when a common variable is used.

class Test{

    public static SCHOOL_NAME = "Horizon";

}

System.out.println(Test.SCHOOL_NAME);

The fields in an interface are implicitly public static final. If one object changes the value then the change gets reflected in all the objects. Static variables cannot be declared inside a method.

Static method

Static methods are also loaded when the application starts. They are mostly used as general purpose utility classes. The main() is a static method so that it can be called even before creating an object. A static method cannot be overridden.

public static void do() { }

Static block

Static block can be used to initialize static variables. Static blocks get executed when the class gets loaded into the memory. You cannot access a non-static variable from the static context in Java. If you try, it will give compile time error.

class A {

    static {

        System.out.print("hi");

    }

}

Static inner class

We can not declare top level class as static, but only inner class can be declared static.

public class Outer{

    static class Inner{

        public void my_method(){

            System.out.println("This is my nested class");

        }

    }

    public static void main(String args[]){

        Outer.Inner inner=new Outer.Inner();

        inner.my_method();

    }

}

Multithreading in Java

Thread is a single sequence stream within a process. Each thread uses different stack of memory, but the heap space is shared. In a single processor environment, threads just run concurrently. But in a multi-processor environment, threads are spread across processors, making them run in parallel. 

Thread creation

By default, JVM creates a single thread called main thread. The user can create more Threads to improve the speed of application in three ways:

• By extending Thread class

class A extends Thread{

    public void run(){ }

}

new A().start();

• By implementing Runnable

This has an advantage over the previous method that the class can extend another parent class.

class B implements Runnable{

    public void run(){ }

}

new Thread(new B()).start();

• By using the Executor framework

This uses a Thread pool where threads are already available, saving the time of creating new.

class C implements Runnable{

    public void run(){ }

}

Executors.newFixedThreadPool(3).execute(new C());

Executor can also call a Callable implemented class if a return value is expected.

In this case, submit() is used instead of execute() method.

 

Thread states

A Thread can take the following states:

·       New : A New Thread is just created

·      Runnable : The New Thread is started and running.

·      Waiting : The Thread is waiting for another Thread to finish its execution or sleeping for the specified time.

·      Blocked : The thread tries to acquire lock on object, but some other thread is already holding the lock.

·      Terminated : The Thread finished its execution or got an error.

 

Synchronized 

Multiple Threads may try to access the same resources, causing error. To avoid this, those resources can be locked using synchronization.

synchronized(this) { } // synchronized block with lock on object.

synchronized void do() { } // synchronized method with lock on the entire method.

 

Other important points

• Every thread has a priority of scheduling which ranges from 1 to 10.
• Invoking the run() method directly instead of start() will make the execution to run on the current stack itself rather than a new stack.
• Thread().join() makes other threads to wait for this thread to finish.
• Daemon Thread provides services to user threads for background supporting tasks. eg: garbage collector
• The wait() method causes the current thread to wait until another thread invokes the notify(). The notifyAll() method wakes up all the threads that called wait( ) on the same object. All three methods can be called only from within a synchronized context.
• The code sleep(1000) puts thread aside for exactly one second. But the code wait(1000) causes a wait of up to one second until it receives the notify() or notifyAll()
• Deadlock describes a situation where two or more threads are blocked forever, waiting for each other.

Collections in Java

Collection framework has one interface at top i.e. Collection. It is extended by Set, List and Queue interfaces. Map interface is also part of collection framework, but it does not extend Collection interface. 

List

A list is an ordered collection of elements. Its main implementations are ArrayList and LinkedList. ArrayList offers easier access of elements where as LinkedList offers faster add/delete.

ArrayList is internally implemented as an array of objects.

List lst = new ArrayList();

lst.add("item");

lst.addAll(set);

lst.get(1);  //or iterate and print

lst.set(2,"new item");  

lst.remove(2);

LinkedList uses nodes with each node pointing to the next node.

Set

Set is a collection of unique elements. It relies on equals() method to check for equality. Its main implementations are HashSet and TreeSet. The TreeSet is sorted as well. So addition/deletion is faster with a TreeSet. But HashSet offers easy retrieval.

Hashing is a technique of converting objects into numbers. This number is then used to identify a corresponding bucket. In HastSet, each bucket stores a set of elements. 

Set set = new HashSet();

set.add("item");

set.get(1); //or iterate and print

set.set(2,"new item");

lst.remove(2);

A TreeSet is internally implemented as a binary tree.

Queue

Queue is a FIFO based collection. LinkedList implements both List and Queue. A Deque is a double ended queue that can add or remove from both ends.

Map

Map is a collection of entries or key/value pairs. Its main implementations are HashMap and TreeMap. The keys have to be unique with one null key allowed. HashMap is preferred for easier insert, delete and retrieval of elements. TreeMap ensures that the keys are sorted.

HashMap is also implemented using hashing. There are buckets saved as an array. The hash function finds the bucket index from the key. Multiple keys can go into the same bucket. Each bucket stores the starting address of entries (key/value pairs) stored as linked lists. 

HashMap<String, Integer> map = new HashMap<>();

map.put("a", 10); //same for add,update

map.put("b", 30);

map.put("c", 20);

Integer a = map.get("b");

map.remove("c");

A TreeMap is internally implemented as a binary tree of entries.

Concurrent Collections

Concurrent Collection objects work on the clone, so they are thread safe. They are different from the synchronized Collections in that in synchronized Collections, locking is at the object level where as in Concurrent Collections, locking is at a much granular level like at a hash bucket. So Concurrent Collections do not throw Concurrent modification exception when we try to modify a Collection while iterating, thereby changing fail-fast to fail-safe.

CopyOnWriteArrayList This is the concurrent version of ArrayList

CopyOnWriteArraySet This is the concurrent version of a HashSet

ArrayBlockingQueue This queue waits for space to be vacated before inserting and space to be filled before removing. So this can be used in wait-notify issues.

ConcurrentHashMap This is the concurrent implementation of HashMap.

Collections class

Collections is a utility class that provides various static methods to work on Collection APIs like sort, reverse, min, max, copy etc.

Comparator

Classes like String and Integer implement the Comparable interface to provide a natural sorting order. Both TreeSet and TreeMap store elements in the sorted order where as other collection APIs can use Collections.sort() to sort their elements. However, it is the comparator that defines precisely what the sort order means. There are two ways of sorting.

1. Using Comparable interface

class A implements Comparable {

    public int compareTo(A a) {

        return this.compareTo(a);

    }

}

Collections.sort(list);

2. Using Comparator interface

class B implements Comparator {

    public int compare(B b1, B b2) {

        return b1.compareTo(b2);

    }

}

Collections.sort(list, new B());

Strings in Java

String is an immutable class in Java. That means, once value has been assigned to a String, it can’t be changed and if changed, a new object is created.

Create

The most commonly used methods of creating a String are,

1. As object

String s = new String("Test");

2. As literal

String s = "Test"

Retrieve

String characters can be retrieved with the index.

Char x = s.charAt(8);

int pos = str.lastIndexOf("o");

Add/Update/Delete

str = "Hello" + str;

str = str.replace('e', 'E');

str = str.substring(0, 10);

In all the three cases, the result has to be reassigned to the value, else value will return unchanged.

Operations

Other operations we can do with a String are,

str.length(), str.equals(str1), str.indexof("t"), str.split("_") etc.

Memory

String objects are saved in the heap just like any other object. String literals are stored in a space called 'String pool' within the heap. If the same literal is already present in the pool, Java uses that instead of creating a new literal. This saves a lot of memory.

The reference variable is stored in the stack which holds the memory address of the String.

Wrapper classes

Just like String, Wrapper classes (Integer, Boolean, BigDecimal etc.) are also immutable because they are defined as final. So a set method cannot be used to alter its state once constructor sets the state value. So there is no need to synchronize String and Wrappers. Since immutable, they both can be used as map keys.

StringBuilder and StringBuffer

If there is a necessity to make a lot of modifications to Strings, then you should use StringBuffer or StringBuilder instead. The only difference between both of them is that a few methods of StringBuffer are synchronized. Because of this fundamental difference, concatenation of String using StringBuilder is faster than StringBuffer. Since they are mutable, no need to assign the result after any change.

StringBuilder sb=new StringBuilder("Hello ");  // create

sb.append("World"); //insert

sb.replace(6,10,"Java"); //update

sb.delete(6,9);  //delete

str = new StringBuffer(str).reverse().toString(); //reverse a String

OOP concepts in Java

Java is an Object Oriented Programming Language. It uses objects, or the blueprints of a class, as the fundamental unit of programming. The Basic OOP concepts are,

Abstraction

Polymorphism

Inheritance

Encapsulation

(easily remembered as A-PIE).

Abstraction

What? Abstraction is the process of hiding certain details and showing only essential information to the user.

Why? It provides a template for creating classes, mandating its implementation.

How? There are two ways to achieve this.

1. Abstract Class

It has zero or more abstract methods.

abstract class Vehicle {

    abstract void drive();

}

• Variables cannot be abstract.
• We cannot create objects for abstract classes.
• Concrete class should implement abstract method, or it should again be declared abstract.
• An abstract class can have private methods, but the abstract method cannot be private.

2. Interface

An interface is different from abstract class in several ways, including:

interface Drivable {

    void drive();

}

• An interface does not contain any constructors.
• All of the methods in an interface are abstract except default and static methods.
• An interface cannot contain instance variables. The only fields that can appear in an interface must be declared both static and final.
• An interface is implicitly abstract. Each method in an interface is also implicitly abstract, so the abstract keyword is not needed.
• Abstract Methods in an interface are implicitly public.

Polymorphism

What? Polymorphism means the different forms of something.

Why? It establishes different ways of doing the same thing, thereby reducing the code.

How? Two ways of achieving this are,

1. Overloading

Method overloading refers to using multiple methods with the same name, but different signatures.

drive(String key) { }

drive(String button){ }

• A method can be overloaded in the same class or in a subclass

2. Overriding

Method overriding is rewriting a parent's function by a child.

drive(String x) { } in  the parent class

drive(String x) { } in the child class.

• There is no change in the signature while overriding.
• We cannot override a final or static method.

Inheritance

What? A parent-child relationship

Why? It puts common functionalities together and others separate.

How? Two ways of achieving this are,

1. Extend

A child class extends the parent and overrides its necessary methods. 

class Vehicle {

    drive() { }

}

class Car extends Vehicle {

    drive() { }

}

• It is mandatory to override if the parent is abstract.
• A class can extend only one parent.

2. Implement

A class can implement an interface and override all its non-default methods. 

interface Drivable {
    drive() { }
}
class Car implements Drivable {
    drive() { }
}
• A class can implement multiple interfaces.
• Each interface adds a behavior to the class. 

Encapsulation

What? Encapsulation is integrating attributes and methods into a single unit, called class.

Why? It provides security to the attributes of a class.

How? Attributes are declared private with public getter/setters to access them.

class Car {

    private String type;

    public String getType() {

        return this.type 

    }

    public void setType(String type) {

        this.type = type;

    }

}