Java Additional Topics Tutorial

Welcome to the Java Additional Topics tutorial offered by Simplilearn. The tutorial is a part of the Java Certification Training Course.

Let us begin with the objectives of this tutorial in the next section.

Objectives

Let us now see the topics covered in this Java additional topics tutorial -

• Explain Inner Classes and Inner Interfaces

• Define String API

• Define Thread

• Determine Collection Framework

• Explain Comparable Comparator and other Functional Interfaces

• Identify File Handling and Serialization

Let us learn the Java inner classes and inner interfaces in the next section

Java Inner Class and Inner Interface

Let us now learn about the java inner class.

Java Inner Class

The inner class is a class declared inside the class or interface that can access all the members of the outer class, including private data members and methods.

The code snippet above gives the scope of the outer class. Within the outer class, we have defined an inner class.

The advantages of doing so include -

• Accessible to all data members and methods of the outer class, including private data members and methods.

• It develops a more maintainable and readable code.

• And it requires less coding effort. In our classes are also referred to as nested classes.

Java Interface - Inner

Inner interface, also known as the nested interface, declares an interface inside another interface.

Here we observe the outer loop of the interface and within it, we have in an interface that has been declared.

The advantages include -

• It can be used to group interfaces together.

• Encapsulation can be done using inner interfaces

• Interfaces are used to maintain and read codes better.

In the next section, we will learn about the Java threads.

Java Threads

A thread is an independent part of the execution within a program. The java.lang.Thread class enables you to create and control threads. A Java thread is composed of three main parts.

They are -

• The virtual CPU,

• The code that the CPU executes, and

• The data on which the code works.

All our systems have a processor, and ideally, then you run the public static void main program, You are typically running a single process on top of your processor. Although, your processor has much more capability.

Whenever the processor has some spare time, we can start parallel processes that run in parallel within the main thread so that we can utilize the time of the processor to effectively perform some computational action.

Hence, within the main thread that is already running, we can start parallel child processes or child threads that are running so that when the processor has some idle time, we can effectively utilize that idle time to do parallel processing and have multiple threads running in parallel.

Each thread can then be assigned a work, which could be a function to execute or some code block to execute.

Creating a Java Thread

A Java thread can be created by the thread class or by implementing Runnable Interface. Commonly used constructors of the Java thread class include -

• Thread()

• Thread(String name)

• Thread(Runnable r)

• Thread(Runnable r, String name)

They accept either a string name of the thread or a runnable object or both. To create a thread, the java.lang.The Runnable interface is preferred over inheriting from java.lang.Thread. Since Java doesn't support multiple inheritances, the extended Java thread class will lose the chance to further extend or inherit other classes.

Implementing Runnable interface will make the code easily maintainable as it does a logical separation of the task from the runner. In object-oriented programming, extending a class means modifying or improving the existing class, implementing Runnable is hence a good practice.

There are two ways in which we could create a thread, one of them is where you can go ahead and inherit the thread class, in which case you cannot further inherit from any other class as java follows the single inheritance. The other way which is also a better way is to implement the Runnable interface, and then you can go ahead and inherit from a class of your choice in parallel.

In the next section, let us look at an example of creating a Java Thread.

Example of Creating a Java Thread

Let us look at a simple example of creating a thread. Here, we have a class called ThreadTester and HelloRunner. The HelloRunner class implements the Runnable interface. Run method is the method that will be called the moment we start the thread and this method has been defined inside the Runnable interface.

In the next section, we will look at synchronizing a Java thread.

Synchronizing a Java Thread

Synchronized keyword enables a programmer to control threads that are sharing data. Synchronization can be done in two ways -

• It can be applied before a thread.

• It can be applied after the trip.

Every object is associated with a flag called object lock flag, and this flag is enabled by a synchronized keyword.

Let us now look at Applying synchronized before a thread and Applying synchronized after a thread.

Applying synchronized in Java before a thread:

To apply synchronized before a thread. When a thread reaches the synchronized statement, it examines the object, passed as the argument, and tries to obtain the lock flag from that object before continuing to the next step.

Here, the moment this particular code block is accessed, the thread simply tries to acquire a lock over this block of code and then proceeds with processing this code block.

Applying synchronized in Java after a thread:

In this example, we see that the synchronization is applied after a thread. That is where it will try to acquire a lock on this particular block of code. This is an example of the applying or acquiring a synchronized lock after the thread.

In the next section, we will learn about Java Deadlock.

Java Deadlock

Deadlock is a part of the Java multithreading. It occurs when a thread is waiting for an object lock that is held by another thread. But, the other thread is waiting for an object lock that has already been held by the first thread.

Let us understand deadlock with an example.

In the next section, we will look at the Java collection framework.

Java Collection Framework

This is part of the java.util.Collections package.

java.util.Collections

The java.util.Collections class consists exclusively of static methods that operate on or return collections. It contains polymorphic algorithms that operate on collections, "wrappers" (which return a new collection backed by a specified collection), and a few other odds and ends.

The methods of this class all throw a NullPointerException if the collections or class objects provided to them are null.

The fields for java.util.Collections class:

Modifier and Type	Field and Description
static List EMPTY_LIST	This is the empty list.
static Set EMPTY_SET	This is the empty set.
static Map EMPTY_MAP	This is the empty map

Java Collection Implementation

There are several purposes of implementation of core interfaces (Set, List, and Map) available as part of the Collection framework. This allows us to store information in memory which could be without a restriction often array where an array has a fixed size whereas collections do not have a fixed size.

	Hash Table	Resizable Array	Balanced Tree	Linked List	Hash Table + Linked List
Set	HashSet		TreeSet		LinkedHashSet
List		ArrayList		LinkedList
Map	HashMap		TreeMap		LinkedHashMap

General Purpose Collection Implementations

Java Collection Implementation Example—HashSet in Set

Let us now look at an example of the HashSet.

The declaration of the HashSet is specialized to the type string, so it will only accept the string type. We then add a few values to the HashSet. We know that, collections also accept duplicate values, therefore, in our code we are adding two duplicate values. We can also add null values as collections accept reference types and reference types are allowed to point to nothing.

Collection Implementation Example—ArrayList in List

This is an example of the ArrayList.

Here, we create a List object and specialize it to the ArrayList with a generic implementation of the type string which mentions that it can take only strings. We then add a few string values and then we can prit out the entire list.

Collection Implementation Example—HashMap in Map

Let us now look at the next collection which is the HashMap. Let us look at an example where at the start of the program, we are creating an object of the map. The map takes, a key and a pair value. We are specializing this to an integer so that all key should be of the type INT and all the values to the corresponding key should be of the type string.

Hierarchy of Java Collection Framework

This is the hierarchy of the collection framework. These are the interfaces that are available. There are three interfaces that inherit from Java collection, which is:

• the list,

• queue,

• set

In terms of the list, we have ArrayList that we've used earlier; in terms of queues, we have linked list in PriorityQueue, which is implemented as a queue. In terms of sets, which hold the key pair values, as we've seen in the HashSet.

Hierarchy of Collection—Map

In terms of the map, we have HashMap, HashTable, SortedMap, and TreeSet. So these are the set off collection classes that also provide, the hash table or a key pair value storage mechanism.

Java Comparable

The comparable interface is a member of the “java.lang” package. By implementing the Java comparable interface, you can provide order to objects of any class. You can also sort collections that contain objects of classes that implement the Comparable interface.

Some Java classes that can implement the comparable interface are Byte, Long, String, Date, and Float. To write custom comparable types, you need to implement the compareTo method of the Comparable interface.

The Comparable interface can be used to implement a compareTo method. This compareTo method can be used specifically when we are sorting custom objects. We can use it to evaluate whether the value of one object is larger than the other object and accordingly decide how to sort those objects.

In the next section, we will learn about the Java comparator.

Java Comparator

The comparator interface is used to order the objects of the user-defined class. For example, consider the Student class described previously; the sorting of students was restricted to sorting on GPAs. A comparator object is capable of comparing two objects of two different classes.

In the next section, we will look at the Java comparable and comparator example.

Comparable and Comparator Example

Let us see an example. We are creating a new package called comparable comparator demo. We create a class called bus that implements the comparable interface. The comparable interface is specialized to the type Bus.

We have getter and the setter for the bus id and the bus name to retreive and store values. We also have a getter and setter for the fare and also for the ratings.

From the above example, we will now create the main class:

Rate Comparator syntax from the example:

Fare Comparator syntax from the example:

Java Iterator

Iterator is used for looping through various collection classes such as HashMap, ArrayList, LinkedList, and so on. It is used to traverse collection object elements one by one. It is applicable for all Collection classes. Therefore, it is also known as Universal Java Cursor. It supports both READ and REMOVE Operations.

The syntax of Iterator:

Iterator Example

Let us now look at an example for the iterator. Here, we are importing three packages, the iterator package, the LinkedList package, and the List package. We create an object of the type LinkedList and add three names to it, John, James, and Joseph.

Java Iterator For-Each Loop

The For-each loop in Java is used to make the code clearly readable and also eliminates the programming errors.

The Syntax for Iterator For-each Loop is given by :  

Example for using the for-each loop:

Let us now look at an example of the for-each loop. We have a simple integer array that takes four elements.

Java File Handling

The various Java file handling methods include -

• Creating File objects

• Manipulating File objects

• Reading and Writing file streaming

File handling is saving data by creating a file on your file system. The file could be in the form of a text, a binary, or an XML. You can also manipulate those files by opening them, deleting them, inserting data, appending data to the file etc.

While reading and writing, we make use of the file stream. We can save all the data in the file stream and simply flush that data at one shot into the file. Hence, instead of having three round trips over the network, we will have a single round trip to push data into the file.

This is what is meant by file streaming. It is a temporary storage area, therefore, it is not required to keep doing I/O operations. I/O operations or reading and writing to the file frequently is expensive from a performance perspective and will hence degrade the performance of the application. Thus, the streaming feature prevents performance degradation.

Creating a New File Object in Java

The File class provides several utilities for handling files and obtaining information about them. You can create a File object that represents a directory and then use it to identify other files.

Manipulating File Object

After creating a File object, we can use one of the following methods to gather information about the file.

File Names:

The following are the methods that return file names:

General File Information and Utilities:

The following methods return General File Information:

Directory Utilities:

The following methods will provide directory utilities:

File Tests:

The following methods will provide information about file

attributes:

Reading from a File

In Java, we can use java.io.BufferedReader to read content from a file.

Writing from a File

To write a file we make use of the following method:

This is explained with an example below using the try-catch blocks.

Serialization

Serialization is a mechanism for saving the objects as a sequence of bytes and rebuilding the

byte sequence back into a copy of the object later. For a class to be serialized, the class must implement the java.io.Serializable interface.

The Serializable interface has no methods and only serves as a marker that indicates that the

class that implements the interface can be considered for serialization. The difference between the file.io and serialization is that in file.io we simply take data and save it to the file, whereas in serialization, we are actually saving an object.

Serialization stores data along with structure and hence we can serialize an entire object to a file. Thus, we can retrieve both the state and structure of the object and this process is called as deserialization.

Serialization and Object Graph

When a field is a reference to an object, the fields of that referenced object are also serialized if

that object’s class is serializable. The tree or structure of an object’s fields, including these sub-objects, constitutes the object graph.

If the object graph contains a non-serializable object reference, the object can still be serialized

if the reference is marked with the transient keyword.

Serialization Example

From this example let us learn how exactly serialization is done.

Writing to an object Stream

Here, we are creating a new Date object and we are putting a try block because it helps in saving data to a file and there is a high probability that there could be an exception. We create an output stream giving the name of date.serialization (date.ser), then we create an object output stream and passing it with a reference of f; where, f is the name of the file to save.   

Reading from an object Stream

After serializing the data from the previous example, we will now look at deserializing the data and converting it from the data we have saved in the file to an object. Thus, we create a date object and assign it to null.

We create an object input stream object and pass it a reference of file f. We then create, s.readObject which means it will read the object from the file called date.ser then we forcibly do a type cast to the type date and store that data in d.

Summary

Let us summarize what we have learned in this java additional topics tutorial :

• Java inner class or nested class is a class that is declared inside the class or interface.

• There are several purposes of implementations of core interfaces (Set, List, and

• Map) in Collection framework.

• A thread is an independent path of execution within a program.

• By implementing the Comparable interface, you can provide order to the objects of any class. The Comparator interface provides greater flexibility with ordering.

• Serialization is a mechanism for saving the objects as a sequence of bytes and rebuilding the byte sequence back into a copy of the object later.

Conclusion

Thus, we come to an end to the Java Additional Topics Tutorial.

Find our Java Certification Training Online Classroom training classes in top cities: