What is package-info.java used for in Java

package-info.java is a special file which is used for generating package level documentations as well as keeping all package level annotations. For each package we can have one package-info file.
Here will see two different examples of package-info.java.

Package Documentation

For instance in a project, I have the following package-info.java for package javaexp.corejava.collection.
 * Tutorials and Samples form Java  Collection framework.

package javaexp.corejava.collection;
If we see the generated Javadocs we will notice the package level comments as well.

Package Level Annotation

We have the following entry, to mark the whole package deprecated.
package javaexp.corejava.oldcollection;
If we see the generated Javadoc we will see the package is marked as deprecated.


All though package-info.java is not must for java project, but it do add a lot of value specially if the code base is large and we want to generate package level documentations or say apply Annotations to all the classes in the packge.

Java @Deprecated Annotation

@Deprecated is an annotation to mark method class or package as deprecated. We mark something deprecated to let developers know that the deprecated item can be removed in future.

Where @Deprecated can be used

  • Method can be marked @Deprecated.
  • Class can be marked with @Deprecated.
  • Package can be also marked deprecated with @Deprecated.

Effect of marking with @Deprecated

When we mark a method or class say @Deprecated then the IDE will mark the method with special style to alert about the deprecations. Also the generated Javadocs will covers deprecated items.


OldCalculator with @Deprecated
 * Sample Calculator which can add two numbers

public class OldCalculator {

	 * Add two number and return the value as Number
	 * @param a : First number
	 * @param b : Second number
	 * @return result of addition as Number
	 * @see Number
	public Number add(Number a, Number b) {
		return a.doubleValue() + b.doubleValue();

	@Deprecated(forRemoval = false, since = "1.1")
	public Number add(CalParameter a, CalParameter b) {
		return a.val.doubleValue() + b.val.doubleValue();


class CalParameter {
	Integer val;
In the above example class CalParameter is marked as @Deprecated. Where as method add is marked @Deprecated.

Documentation of @Deprecated

Following image shows Javadocs generated for a project, where some method, class and package are marked @Deprecated

When to use @Deprecated

When we have a better implementation of a method and want to let other developers use the new method rather then old method, we can mark old method @Deprecated. While refactoring code and marking @Deprecated to yet to be refactored code makes refactoring effective and easier.

Create Java project using maven

Here we will create a project using maven template and import the project in eclipse.
Technology used
  • Java 2022-04-22
  • Apache Maven 4.0.0-alpha-3
  • OS: MacOS Monterey (M1)
  • Eclipse IDE

Create project

Using maven we will generate the project using archetype = maven-archetype-quickstart. archetype is predefined templates. And then we will generate the eclipse related config files so that the generate project can be imported in eclipse.
Console : Command
mvn archetype:generate -DgroupId=com.project -DartifactId=java-module-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false  
Console : Output
$ mvn archetype:generate -DgroupId=com.project -DartifactId=java-module-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
[INFO] Scanning for projects...
[INFO] -----------------------------------------< org.apache.maven:standalone-pom >-----------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] -------------------------------------------------------[ pom ]-------------------------------------------------------
[INFO] --- archetype:3.2.1:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-quickstart:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: basedir, Value: /Users/sbhome
[INFO] Parameter: package, Value: com.project
[INFO] Parameter: groupId, Value: com.project
[INFO] Parameter: artifactId, Value: java-module-project
[INFO] Parameter: packageName, Value: com.project
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: /Users/sbhome/java-module-project
[INFO] ---------------------------------------------------------------------------------------------------------------------
[INFO] ---------------------------------------------------------------------------------------------------------------------
[INFO] Total time:  6.667 s
[INFO] Finished at: 2023-02-07T22:46:00-08:00
[INFO] ---------------------------------------------------------------------------------------------------------------------
Terminal:: $ 
After the maven command execution is complete it will create the project folder java-module-project. Next move inside the folder (cd java-module-project)
Console : Command
cd java-module-project

Create Eclipse Project

Console : Command
mvn eclipse:eclipse
Console : Output
[INFO] Scanning for projects...
[INFO] -----------------------------------------< com.project:java-module-project >-----------------------------------------
[INFO] Building java-module-project 1.0-SNAPSHOT
[INFO]   from pom.xml
[INFO] -------------------------------------------------------[ jar ]-------------------------------------------------------
[INFO] --- eclipse:2.10:eclipse (default-cli) @ java-module-project ---
[WARNING] The POM for org.apache.maven.wagon:wagon-http-lightweight:jar:1.0-beta-6 is invalid, transitive dependencies (if any) will not be available, enable verbose output (-X) for more details
[WARNING] The POM for org.apache.maven.wagon:wagon-http:jar:1.0-beta-6 is invalid, transitive dependencies (if any) will not be available, enable verbose output (-X) for more details
[WARNING] The POM for org.apache.maven.wagon:wagon-webdav-jackrabbit:jar:1.0-beta-6 is invalid, transitive dependencies (if any) will not be available, enable verbose output (-X) for more details
[WARNING] The POM for org.apache.maven.wagon:wagon-http-lightweight:jar:1.0-beta-2 is invalid, transitive dependencies (if any) will not be available, enable verbose output (-X) for more details
[INFO] Using Eclipse Workspace: null
[INFO] Adding default classpath container: org.eclipse.jdt.launching.JRE_CONTAINER
[INFO] Not writing settings - defaults suffice
[INFO] Wrote Eclipse project for "java-module-project" to /Users/sbhome/java-module-project.
[INFO] ---------------------------------------------------------------------------------------------------------------------
[INFO] ---------------------------------------------------------------------------------------------------------------------
[INFO] Total time:  0.494 s
[INFO] Finished at: 2023-02-07T22:51:03-08:00
[INFO] ---------------------------------------------------------------------------------------------------------------------

Import Project in Eclipse

Project in Eclipse

POM file


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

Build Project

Console : Command
mvn install
Console : Output
[INFO] -------------------------------------------------------
[INFO] Running com.project.AppTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.006 s - in com.project.AppTest
[INFO] Results:
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] --- jar:3.2.0:jar (default-jar) @ java-module-project ---
[INFO] Building jar: java-module-project-1.0-SNAPSHOT.jar
[INFO] --- install:3.0.0-M1:install (default-install) @ java-module-project ---
[INFO] ---------------------------------------------------------------------------------------------------------------------

Java logical operator short circuiting

In java we logical operator when we can use short circuit (&& ||)to not evaluate right hand side condition. Short circuiting is using double AND or double OR.
Logical OR and AND :- returns final verdict only after evaluating both expressions. Does not matter if first expression is true or false it will always evaluate the second expression. Short Circuit OR and AND:- if left hand side operand returns true, In case of OR => it will not evaluate second expression if first expression is true. In case of AND => it will not evaluate second expression if first expression is false.
Sample method to test logical and shortcircuit
private static boolean appleIsFruit() {
	System.out.println("calling apple ");
	return true;

private static boolean bananaIsFruit() {
	System.out.println("calling banana ");
	return true;

private static boolean cloudIsfruit() {
	System.out.println("calling cloud ");
	return false;
Logical Operator
System.out.println("\n\napple | banana");
if (appleIsFruit() | bananaIsFruit()) {
	System.out.println("inside apple | banana");

System.out.println("\n\ncloud & apple");
if (cloudIsfruit() & appleIsFruit()) {
	System.out.println("inside cloud & apple");
apple | banana
calling apple 
calling banana 
inside apple | banana

cloud & apple
calling cloud 
calling apple 
Above we can see even though the first method returned false (cloud & apple) the second method was still invoked.
Short circuit logical operation
System.out.println("apple || banana");
if (appleIsFruit() || bananaIsFruit()) {
	System.out.println("inside apple || banana");

System.out.println("\n\ncloud && apple");
if (cloudIsfruit() && appleIsFruit()) {
	System.out.println("inside cloud && apple");
Short circuit
apple || banana
calling apple 
inside apple || banana

cloud && apple
calling cloud 
In the short circuit case the second expression is not evaluated.


Short circuiting logical operation can improve performance and efficiency of code. But we have to keep in mind the way short circuiting works.

How to iterate Java Map

Java Map can be iterated various ways to go over all the key:value pairs
Create Map and add some values
Map<Integer, String> map = new HashMap<>();
Using EntrySet Iterator
//EntrySet Iterator
System.out.println("\nEntrySet foreach");
Iterator<Entry<Integer, String>> it = map.entrySet().iterator();
while(it.hasNext()) {
    Map.Entry<Integer, String> keyVal = it.next();
    System.out.println(keyVal.getKey() + " " + keyVal.getValue());
Using EntrySet and foreach
//EntrySet and foreach
System.out.println("\nEntrySet foreach");
Set<Entry<Integer, String>> entrySet = map.entrySet();
entrySet.forEach((e-> { System.out.println(e.getKey() + " " + e.getValue());}));
Using Keyset Iterator
//Keyset Iterator
System.out.println("\nKeyset Iterator");
Iterator<Integer> kit = map.keySet().iterator();
while(kit.hasNext()) {
    Integer key = kit.next();
	System.out.println(key + " " + map.get(key));
Keyset For loop
//Keyset For loop
System.out.println("\nKeyset For loop");
for (Integer key : map.keySet()) {
	System.out.println(key + " " + map.get(key));
Using Java 8 Lambda
//map foreach (Java 8 Lambda)
System.out.println("\nUsing Map.foreach (Java 8 Lambda");
map.forEach((key,value)-> {System.out.println(key + " " + value);});


Here I have covered 5 different ways to iterate over Java Map and access both key and values.

When to use LinkedHashMap.removeEldestEntry method

removeEldestEntry method exists only on subclasses of LinkedHashMap
removeEldestEntry always invoked after an element is inserted. Based on what this method returns following action will happen if method returns true based on some condition, then the oldest entry will be removed. if method always returns true then basically list will be empty. if method return false, then nothing will be deleted and map will behave like any other LinkedHashMap. after every put or putAll insertion, the eldest element will be removed, no matter what. The JavaDoc shows a very sensible example on how to use it:
Lets see an example of removeEldestEntry.
MapRemoveEntry Example
import java.util.LinkedHashMap;
import java.util.Map;

public class MapRemoveEntry {

	public static void main(String argv[]) {

		LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>() {
			private static final long serialVersionUID = 1L;

			protected boolean removeEldestEntry(Map.Entry<Integer,String> eldest) {
				return size() > 4;

		map.put(0, "A");
		map.put(1, "B");
		map.put(2, "C");
		map.put(3, "D");
		map.put(4, "E");
		map.forEach((k,v) -> { System.out.println("key = " + k + " value = " + v);});
If we run the above example we will get following output.
key = 1 value = B
key = 2 value = C
key = 3 value = D
key = 4 value = E
Reason is, method removeEldestEntry returns true when the map size is >4. That means when the map size is greater than 4 => the oldest entry will be removed. In this case oldest is the very first entry with (key=0, value=A).


Using removeEldestEntry we can control when to remove the most oldest entry from the map. This can be used for creating a cache.

About sealed classes and interfaces

Starting Java 17 we can now allow additional class modifiers like sealed, non-sealed etc. A sealed class or interface can be extended or implemented only by those classes and interfaces permitted to do so.
Earlier we had only two options, allow subclasses to inherit the parent class or interface or not at all. In the later case using Final class modifier. Using sealed we can take a more controlled middle path where the Parent Class or Interface can dictate the Sub classes which can inherit from the Class.
Following are the keywords related to sealed classes. sealed : only permitted classes can extend a sealed class/interface permits: used along with sealed and mentions the names of the child classes. non-sealed: if we want a specific class (inherited from a sealed class) to be inheritable we can open it up by marking it non-sealed.

Defining sealed class

Let's define a sealed class Tesla with 3 known subclasses that it can have.

sealed Tesla

package java17.sealed;

public abstract sealed class Tesla permits Model3, ModelS, TeslaSUV{
	public abstract Integer maxRange();
	public String basePrice() {
		return "25000 USD";

Now start implementing the subclasses possible. We implement Model3 and mark it final which will make the inheritance chance closed at this level.
//Subclass 1
public final class Model3 extends Tesla {
	public Integer maxRange() {
		return 200;

//Subclass 2
public final class ModelS extends Tesla {
	public Integer maxRange() {
		return 400;
In this third case we want the TeslaSUV to be extendable so that it can be extended. That's why we will mark it with non-sealed.
//Subclass3 (non-sealed)
public non-sealed class TeslaSUV extends Tesla {
	public Integer maxRange() {
		// TODO Auto-generated method stub
		return null;

Style Two: Using member classes

We can also directly implement possible child classes that we want to allow as member classes without using permit. In the following example we are creating a sealed class BMWCars and three member classes.
package java17.sealed;

public sealed class BMWCars {

	public final class BMW3 extends BMWCars implements ElectricVehicle{

	public final class BMWI extends BMWCars implements Vehicle {

	public non-sealed class BMWJV extends BMWCars implements Vehicle {



Rules for Defining Sealed Classes or Interfaces

Both Class and Interface can be marked with sealed. Inherited child classes can be marked with either final, sealed and non-sealed. Every permitted subclass must directly extend the sealed class. A permitted subclass may be non-sealed so that it is open for extension by unknown subclasses.


With introduction of sealed classes we can define the known subclasses of an abstract class. In other words now we can enforce extension of classes that is known in compile time. It allows us to have greater control of class proliferation and improve security.

Java record in details with example

With Java 14 we have a new way to represent data intensive objects with less boilerplate codes.
Consider the following object representing Address and containing 5 fields. Address:{ street: city: zip: state: country: }
following record AddressRecord will be able to represent above address information.
package Java14;

public record AddressRecord(String street, String city, Integer zip, String state, String country) {

We can instantiate AddressRecord record instance by passing the parameter values. Also system will generate the getter methods. The JVM will generate the getter methods for us. like, street() city() zip() state() country()
package Java14;

public class AddressRecordDemo {

	public static void main (String arg[]) {
		AddressRecord address1 = new AddressRecord("1044 Main Street", "Livermore", 94550, "CA", "USA");
Record can be very useful when we want to write DTO objects which is to carry or represent information. Following are some of the properties/rules that record have.
Rules for record
  • record can have Constructor.
  • record can have only static fields.
  • record cannot have instance field.
  • record can implement Interfaces.
  • We cannot extends record since implicitly it is final.

How to check if a Java object is final

final modifier can be applied at class level. If a Class is marked final it cannot be extended.
Sample final Class

final class MyCustomClass {

Using java.lang.reflect.Modifier

Using java.lang.reflect.Modifier,, We can check if a class is final though java.lang.reflect.Modifier.isFinal() method. MyCustomClass.class.getModifiers() will provide an integer number representing the class modifier. For example for the above class it prints 16. Now the value returned from the getModifiers() can be decoded with method Modifier.isFinal();
import java.lang.reflect.Modifier;

public class JavaReflectionModifiers {

	public static void main(String[] args) {
                 //prints 16
                 //returns true



final class MyCustomClass {

More Examples

package Java14;

import java.lang.reflect.Modifier;

public class JavaReflectionModifiers {

	public static void main(String[] args) {
		//prints true
		//prints true
		//prints false



final class MyCustomClass {

Can Java record be extended?

Java record introduced in java 14. It provides a way to reduce boiler plate code while defining data classes. record is final implicitly and cannot be extended.
For example in the following record MobilePhone, we cannot extend it.
record MobilePhone
record MobilePhone(String brand, String modelName, Number osVersion, boolean canFlip) {

Java records are implicitly final it can be confirmed by the following code. Which checks if the java.lang.Class for the object have final modifier or not.
package Java14;

import java.lang.reflect.Modifier;

public class RecordFinalTest {

	public static void main(String[] args) {
		MobilePhone phone1 = new MobilePhone("Samsung", "Galaxy1", 1, false);



For more details about record in Java please check the following references.


How to create double linked list in Java

In Double Linked List we have each node pointing to the previous and next node. Here we will see how to create a custom Double Linked List in java.
Some properties of linked list is that, it has a node that can contain some value and then each node is linked to next node and also previous node. That's why we can traverse the linked list sequentially given we know the starting (head) node or last (tail) node.
Custom Linked List
class MyLinkedList<E> {

	/* first points to head of the list */
	public Node<E> first = null;

	/* last points to tail of the list */
	public Node<E> last = null;

	 * Add item to tail (end) of the List
	 * @param item
	 * @return
	public boolean add(E item) {
		Node<E> newNode = new Node<E>(last, item, null);

		if (last == null) {
			// last points to the new node created
			first = newNode;
		} else {
			last.next = newNode;
		// update last so that it points to the new node
		last = newNode;
		return true;

	static class Node<E> {
		public E value;
		public Node<E> next;
		public Node<E> prev;

		Node(Node<E> prev, E element, Node<E> next) {
			this.value = element;
			this.next = next;
			this.prev = prev;

In the above implementation we have defined the main class MyLinkedList and inside it we defined a generic static class Node. Each Node object can hold a value and has links to previous (prev) and next nodes.
Create Instance of MyLinkedList
//create instance
MyLinkedList<Integer> list = new MyLinkedList<Integer>();

//add values 1,2,3,4,5
Print the content of the node
//Get the first node (head node) and then print it by traversing all nodes
MyLinkedList.Node<Integer> node = list.first;
while (node != null) {
	System.out.println("Content of Node: " + node.value);
	node = node.next;
Content of Node: 1
Content of Node: 2
Content of Node: 3
Content of Node: 4
Content of Node: 5