Walking Techie

git-log useful options

2020-08-23T19:26:00.001+05:30

What does git log do?

The git log command display all the commits history in a repository.

By default, the command displays for each commits:

Secure Hash Algorithm (SHA)
author
date
commit message

Git log options

You can customize the information provided by git-log by passing the options.

--oneline

$ git log --oneline

The --oneline option causes git log to display each commit in one line

The first seven characters of SHA
The commit message

8fc4335 first commit
09cca7e Initial commit

--patch or -p

$ git log --patch

or, the shorter version

$ git log -p

The --patch option causes git log to display

Commit id, Author, Date, and commit message.
The files have been modified, addition/deletion in files.
The specific changes that happened in this commit. Like addition and deletion of changes.
Line number where addition/deletion happened.

You can see something like below, when you run git log --patch

Author: Santosh 
Date:   Sun Aug 23 18:02:21 2020 +0530

    initial commit

diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000..26d3352
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,3 @@

-- <absolute/relative path of file>

When you want to see the changes of specific file then you can write git log -- file name. Make sure that there is space between the -- and file name.

$ git log -- gradle.properties

The -- filename causes git log to display only specific commit happened to this file only

Secure Hash Algorithm
author
date
commit message

This will display recent commit first or can say in descending order of timestamp.

--oneline <absolute/relative path of file>

$ git log --oneline gradle.properties

The --oneline filename causes git log to display only specific commit happened to this file only

The first seven characters of SHA
The commit message

Commit made by particular author

You can see the commit made by specific user using the below command.

$ git log --author"author-name"

Start at specific commit

You can display display the commit with specific SHA and all of the commits made before that commit.

$ git log SHA

You can combine with other available options.

Search commit message

You can search commit message using the --grep.

$ git log --grep="first commit"

--graph

$ git log --graph

The --graph options enables you to view your git log as a graph. You can combine this with --oneline option you have learned from above.

$ git log --graph --online

The --graph option is very useful in git log when you are working on feature on which multiple developers are working.

You can combine with --decorate option.

How to see git configuration

2020-07-25T16:19:00.001+05:30

In the last post, we have seen how to install Git into Ubuntu machine and some configuration of it. In this post we will see more about config.

How to get username and email

We have set the user name and email in the last post. How can we get the username and email to verify it?

$ git config --get user.name

This will return the username. Username can be picked up from local config if you are in repository otherwise it will pick from global configuration.

$ git config --get user.email

This will return the email of user. Email can be picked up from local config if you are in repository otherwise it will pick from global configuration.

You can fetch user name and email from specific configuration by passing the options. You can do like below.

To get from global configuration file. Need to pass --global.

$ git config --global --get user.name

$ git config --global --get user.email

To get from local configuration file. Need to pass --local. To run the below command, you must be in local repository.

$ git config --local --get user.name

$ git config --local --get user.email

List Git Settings

You can print the Git setting using the below command.

$ git config --list

You are in local repository and run this command. It will list all the local, global and system config. But if you are not in git directory then it will list system and global config of git.

List Git Settings by config

To print the system config. pass the --system option.

$ git config --system --list

To print the global user config. pass the --global option.

$ git config --global --list

To print the local user config. pass the --local option. You must be in git repo.

$ git config --local --list

How To Install and Configure Git on Ubuntu 18.04

2020-07-15T21:27:00.005+05:30

What is Git?

Git is currently the most popular implementation of a distributed version control system.

Git originates from the Linux kernel development and was founded in 2005 by Linus Torvalds.

The core of Git was originally written in the programming language C, but Git has also been re-implemented in other languages, e.g., Java, Ruby and Python.

distributed version control system?

In a distributed version control system each user has a complete local copy of a repository on his individual computer. The user can copy an existing repository. This copying process is typically called cloning.

Every clone contains the full history of the collection of files and a cloned repository has the same functionality as the original repository.

Install git in local machine

You can install git in any OS based machine. I am going to install git in Ubuntu machine.

Command to install git in Ubuntu machine.

$ sudo apt-get install git

Hit enter. It will prompt for password. Enter it. It will take few seconds to install it.

Once Git installed in machine. It will serve as both an agent list server as well as a client. Nothing extra we need to install for a server.

Uninstall git

To remove just git package itself from Ubuntu 18.04 execute on terminal:

$ sudo apt-get remove git

Uninstall git and it's dependent packages

To remove the git package and any other dependant package which are no longer needed from Ubuntu.

$ sudo apt-get remove --auto-remove git

Purging git

If you want remove git package, configuration and/or data files of git from Ubuntu.

$ sudo apt-get purge git

To remove git package, it's dependencies, configuration and/or data files of git from Ubuntu.

$ sudo apt-get purge --auto-remove git

Configuration of Git

You need to logged as root user in your system to set up some global configurations. Git will use some of the global parameters. Default parameters will use when we will use git repository, unless there are local overrides that are provided as part of local git config or repository.

Here we will be configuring global user name and email. So that when we are not providing the name and email configuration in repository git config. It will take from global configuration when committing, checkout and push the code to origin or upstream.

Config file and location

Git use the config file based on level of configuration. These are the below config levels.

system
global
local

Below are the config files, location, and its meaning.

$(prefix)/etc/gitconfig: System wide configuration file.
$XDG_CONFIG_HOME/git/config: Second user-specific configuration file. If $XDG_CONFIG_HOME is not set or empty, $HOME/.config/git/config will be used.
Any single-valued variable set in this file will be overwritten by whatever is in ~/.gitconfig.
~/.gitconfig: User-specific configuration file. Also called "global" configuration file.
$GIT_DIR/config: Repository specific configuration file.

Repository config options:

--system

This option use the system config file.

For writing options: write to system-wide $(prefix)/etc/gitconfig rather than the repository .git/config.

For reading options: read only from system-wide $(prefix)/etc/gitconfig rather than from all available files.

--global

This option use the global configuration file.

For writing options: write to global ~/.gitconfig file rather than the repository .git/config, write to $XDG_CONFIG_HOME/git/config file if this file exists and the ~/.gitconfig file doesn’t.

For reading options: read only from global ~/.gitconfig and from $XDG_CONFIG_HOME/git/config rather than from all available files.

--local

Use repository config file.

For writing options: write to the repository .git/config file. This is the default behavior.

For reading options: read only from the repository .git/config rather than from all available files.

how to set git config username and email?

git config - Get and set repository or global options.

Set the git global parameter for username.

$ git config --global user.name "Santosh"

Set the git global parameter for email.

$ git config --global user.email "walkingtechie.blogspot@gmail.com"

We can also set the local git configuration username and email. Make sure that you are inside a git repository. Otherwise it will give fetal error like; "fatal: --local can only be used inside a git repository".

Set the git local parameter for username.

$ git config --local user.name "Santosh"

Set the git local parameter for email.

$ git config --local user.email "walkingtechie.blogspot@gmail.com"

how to set git system config?

Let's suppose you want to set the "vi" or "vim" system editor. So whenever you edit something it will always open that editor by default. Here, I am setting "vi" editor for that check where "vi" editor is located.

$ which vi

You will get output something like "/usr/bin/vi".

Now set the default "vi" editor for git.

$ git config --system core.editor "/usr/bin/vi"

Difference between save and persist method in Hibernate

2020-06-05T23:02:00.000+05:30

Both save and persist methods of Session class persist given transient instance into database.

The first difference between these two methods are their return type. Return type of save method is Serializable object while return type of persist method is void.
Both method persist given transient instance into database. However, persist method doest guarantee identifier value will be assigned to persistence instance immediately, the assignment might happen at flush time.
save operation cascades to associated instances if the association is mapped with cascade="save-update". While persist operation cascades to associated instances if the association is mapped with cascade="persist".
The save method persist a given transient instance inside and outside of a transaction boundary. While, The persist method does not execute a insert query if it is outside of a transaction boundary.
The persist method is called outside of transaction boundaries, it is useful in long-running conversations with an extended Session context. On the other hand save method is not good in a long-running conversation with an extended Session context.
The save method is only supported by Hibernate while persist method is supported by Hibernate and JPA too.

Example of save in Hibernate

package com.walking.techie.entity;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import lombok.Getter;
import lombok.Setter;

@Entity
@Table(name = "person")
@Getter
@Setter
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
}

package com.walking.techie;

import com.walking.techie.entity.Person;
import com.walking.techie.utils.HibernateUtil;
import java.io.Serializable;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class SaveClient {

  public static void main(String[] args) {
    // get session factory of an application
    SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

    // Open a session
    Session session = sessionFactory.openSession();

    // Begin a unit of work and return the associated Transaction object.
    Transaction transaction = session.beginTransaction();
    Person person = new Person();
    person.setName("Santosh");
    Serializable id = session.save(person);
    System.out.println("Person saved in DB with return serialized id: " + id);

    // commit the transaction
    transaction.commit();
    // End the session by releasing the JDBC connection and cleaning up.
    session.close();
  }
}

Once you run this application. You will see on console something like below:

Hibernate: create table person (id bigint not null auto_increment, name varchar(255), primary key (id)) engine=InnoDB
Hibernate: insert into person (name) values (?)
22:45:26,649 TRACE BasicBinder:65 - binding parameter [1] as [VARCHAR] - [Santosh]
Person saved in DB with return serialized id: 1

Example of persist in Hibernate

We will use the same Person entity for this example also.

package com.walking.techie;

import com.walking.techie.entity.Person;
import com.walking.techie.utils.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class PersistClient {

  public static void main(String[] args) {
    // get session factory of an application
    SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

    // Open a session
    Session session = sessionFactory.openSession();

    // Begin a unit of work and return the associated Transaction object.
    Transaction transaction = session.beginTransaction();
    Person person = new Person();
    person.setName("Mohan");
    session.persist(person);
    // commit the transaction
    transaction.commit();
    // End the session by releasing the JDBC connection and cleaning up.
    session.close();
  }
}

Hibernate: insert into person (name) values (?)
22:49:29,994 TRACE BasicBinder:65 - binding parameter [1] as [VARCHAR] - [Mohan]

After running the both examples. We have records like this in "person" table.

@AttributeOverride and @AttributeOverrides example

2020-06-03T23:25:00.000+05:30

@AttributeOverride annotation

Used to override the mapping of a Basic (whether explicit or default) property or field or Id property or field.

May be applied to an entity that extends a mapped superclass or to an embedded field or property to override a basic mapping or id mapping defined by the mapped superclass or embeddable class (or embeddable class of one of its attributes).

May be applied to an element collection containing instances of an embeddable class or to a map collection whose key and/or value is an embeddable class. When AttributeOverride is applied to a map, "key." or "value." must be used to prefix the name of the attribute that is being overridden in order to specify it as part of the map key or map value.

To override mappings at multiple levels of embedding, a dot (".") notation form must be used in the name element to indicate an attribute within an embedded attribute. The value of each identifier used with the dot notation is the name of the respective embedded field or property. If AttributeOverride is not specified, the column is mapped the same as in the original mapping.

@AttributeOverrides annotation

Used to override mappings of multiple properties or fields.

Understand using example

We strongly recommend to read these article before moving ahead, component mapping in hibernate using JPA annotation, this post, and how mapping of column happens when mapping file and @Column annotation is not used..

If we want to change the column names of component address to something like "address_street", "address_city", and "address_zipcode" as table below.

We can do the same by using the name attribute of @Column annotation.

package com.walking.techie.entity;

import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class Address {

  @Column(name = "address_street")
  private String street;
  @Column(name = "address_city")
  private String city;
  @Column(name = "address_zipcode")
  private String zipcode;

  public Address() {
  }

  public Address(String street, String city, String zipcode) {
    this.street = street;
    this.city = city;
    this.zipcode = zipcode;
  }
}

But sometimes, We need to override the settings of component class into the particular entity class. For example, Here by default attributes of address component class will be mapped to street, city, and zipcode columns. But, if you wanted to map these columns with some other name for this "Person" entity. You can do it using @AttributeOverride annotation.

package com.walking.techie.entity;

import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.Getter;
import lombok.Setter;

@Entity
@Table(name = "Person")
@Getter
@Setter
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id")
  private Long id;

  @Column(name = "name", nullable = false)
  private String name;

  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "street", column = @Column(name = "address_street")),
      @AttributeOverride(name = "city", column = @Column(name = "address_city")),
      @AttributeOverride(name = "zipcode", column = @Column(name = "address_zipcode"))
  })
  private Address address;

  public Person() {
  }

  public Person(String name, Address address) {
    this.name = name;
    this.address = address;
  }
}

In "Person" entity, street attribute mapped to "address_street" column, city attribute mapped to "address_city" column, and zipcode attribute mapped to "address_zipcode" column.

package com.walking.techie.entity;

import javax.persistence.Embeddable;

@Embeddable
public class Address {

  private String street;
  private String city;
  private String zipcode;

  public Address() {
  }

  public Address(String street, String city, String zipcode) {
    this.street = street;
    this.city = city;
    this.zipcode = zipcode;
  }
}

When requirement comes like "Person" entity should have two address say "homeAddress" and "billingAddress". We can achieve the same using the @AttributeOverride annotation. The "Address" class is embeddable as above. So it is a value type.

The "Person" entity will be like below.

package com.walking.techie.entity;

import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.Getter;
import lombok.Setter;

@Entity
@Table(name = "Person")
@Getter
@Setter
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id")
  private Long id;

  @Column(name = "name", nullable = false)
  private String name;

  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "street", column = @Column(name = "home_street")),
      @AttributeOverride(name = "city", column = @Column(name = "home_city")),
      @AttributeOverride(name = "zipcode", column = @Column(name = "home_zipcode"))
  })
  private Address homeAddress;

  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "street", column = @Column(name = "billing_street")),
      @AttributeOverride(name = "city", column = @Column(name = "billing_city")),
      @AttributeOverride(name = "zipcode", column = @Column(name = "billing_zipcode"))
  })
  private Address billingAddress;

  public Person() {
  }

  public Person(String name, Address homeAddress, Address billingAddress) {
    this.name = name;
    this.homeAddress = homeAddress;
    this.billingAddress = billingAddress;
  }
}

AttributeOverrideClient

package com.walking.techie;

import com.walking.techie.entity.Address;
import com.walking.techie.entity.Person;
import com.walking.techie.utils.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class AttributeOverrideClient {

  public static void main(String[] args) {
    // get session factory of an application
    SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

    // Open a session
    Session session = sessionFactory.openSession();
    Transaction transaction = null;

    try {
      // Begin a unit of work and return the associated Transaction object.
      transaction = session.beginTransaction();

      Address homeAddress = new Address("6th cross, 6th main", "Bangalore", "560078");
      Address billingAddress = new Address("11th cross, 7th main", "New Delhi", "110005");
      Person person = new Person("Santosh", homeAddress, billingAddress);

      session.persist(person);

      // commit the transaction
      transaction.commit();
    } catch (Exception e) {
      if (transaction != null) {
        transaction.rollback();
        e.printStackTrace();
      }
    } finally {
      if (session != null) {
        // End the session by releasing the JDBC connection and cleaning up.
        session.close();
      }
    }
  }
}

After running the code. The data in "Person" table will be like below.

Please find the working code from git.

Internally default mapping of Table and Column in Hibernate

2020-06-03T19:31:00.000+05:30

In last article, we have discussed about component mapping in hibernate using JPA annotation. Strongly recommend to read this post.

Lets start the discussion about mapping of columns with the object attributes (member variables).

@Entity
@Getter
@Setter
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(nullable = false)
  private String name;

  @Embedded
  private Address address;

  public Person() {
  }

  public Person(String name, Address address) {
    this.name = name;
    this.address = address;
  }
}

@Embeddable
public class Address {

  private String street;
  private String city;
  private String zipcode;

  public Address() {
  }

  public Address(String street, String city, String zipcode) {
    this.street = street;
    this.city = city;
    this.zipcode = zipcode;
  }
}

The table is automatic create by hibernate because of hbm2ddl.auto=create-drop properties set into hibernate.cfg.xml file. But we have nowhere defined the name of the table and column of the table. Where did this "Person" table come from and columns of this table?

We have not written the schema for it, no mapping file and not used @Table JPA annotations for mapping. Even we have not used @Column annotation or mapping file to map id attribute to id column of this table. Similarly for the rest of the attributes. Hibernate automatically figure out about it. First hibernate uses the reasonable default values for xml based mapping metadata and also for annotations based mapping metadata.

So when it finds a mapping information missing. Then it uses sensible default value for that.

When It doesn't find the @Table annotation on entity. It is going to use the name of entity as table name. So here name of the entity is "Person" so it is mapped to the name of the table i.e "Person".

Similarly, It doesn't find the @Column annotation on an attribute. It is going to use the attribute name as column name of the table.

Hibernate internally treats them like below:

@Entity
@Table(name = "Person")
@Getter
@Setter
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id")
  private Long id;

  @Column(name = "name", nullable = false)
  private String name;

  @Embedded
  private Address address;

  public Person() {
  }

  public Person(String name, Address address) {
    this.name = name;
    this.address = address;
  }
}

@Embeddable
public class Address {

  @Column(name = "street")
  private String street;
  @Column(name = "city")
  private String city;
  @Column(name = "zipcode")
  private String zipcode;

  public Address() {
  }

  public Address(String street, String city, String zipcode) {
    this.street = street;
    this.city = city;
    this.zipcode = zipcode;
  }
}

When we run the application that time It create the DDl script using the mapping metadata of the person entity and execute the schema against the "helloworld" database.

create table Person (id bigint not null auto_increment, city varchar(255), 
street varchar(255), zipcode varchar(255), name varchar(255) not null, 
primary key (id)) engine=InnoDB

The name column of the Person table is having not null constraint that is coming because of @Column(nullable=false).

Hibernate Component Mapping

2020-06-03T17:20:00.001+05:30

A component is a part of whole in such a way that if component is destroyed, all its parts are also destroyed with it.

For example, Here the house has its rooms as part and the house itself as a whole. When the house is destroyed its rooms are also destroyed. Each part (component) belongs to only one whole. It means it is not shared with others just like a room in a house. Room is the part of your house, not your neighbors.

The term "component" refers to the object-oriented notion of composition. It is a embedded object that is persisted as a value type. So its existence depend only on the entity type that contains it. Because component does not have its own identity in database.

Let's take one example of Person and Address object model. Here Address is a component (HAS-A relation) of Person.

Address class is a component of Person class. In this situation, You will have more classes than the number of corresponding database's tables to store data of them.

In this example, we have two classes Person and Address, but have only one table person to store data of them. So we are mapping to classes to one table.

package com.walking.techie.entity;

import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(nullable = false)
  private String name;

  @Embedded
  private Address address;

  public Person() {
  }

  public Person(String name, Address address) {
    this.name = name;
    this.address = address;
  }
}

Person class is an entity class and it has address member variable. To make address attribute as a component of Person class. We mark it with @Embedded annotation.

package com.walking.techie.entity;

import javax.persistence.Embeddable;

@Embeddable
public class Address {

  private String street;
  private String city;
  private String zipcode;

  public Address() {
  }

  public Address(String street, String city, String zipcode) {
    this.street = street;
    this.city = city;
    this.zipcode = zipcode;
  }
}

Here, Address class is a component, that is a dependent object. We have mark it with @Embeddable annotation to make it a persistent class.

Data of both the class will save into one table like below.

Hibernate Properties

hibernate.cfg.xml is a Hibernate configuration xml file which contain the required Hibernate properties. Most of the properties have their default properties. Some of the properties values need to have into this file, so Hibernate use these properties to create connection with database.

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
  <session-factory>
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql://localhost:3306/helloworld?useSSL=false</property>
    <property name="connection.username">root</property>
    <property name="connection.password">santosh</property>
    <property name="hbm2ddl.auto">create-drop</property>

    <!-- SQL Dialect -->
    <property name="dialect">org.hibernate.dialect.MariaDBDialect</property>
    <!--Echo all executed SQL query to console-->
    <property name="show_sql">true</property>
    <mapping class="com.walking.techie.entity.Person"/>
  </session-factory>
</hibernate-configuration>

ComponentMappingClient

This class main method will save the person object into Person table of helloworld database.

package com.walking.techie;

import com.walking.techie.entity.Address;
import com.walking.techie.entity.Person;
import com.walking.techie.utils.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class ComponentMappingClient {

  public static void main(String[] args) {
    // get session factory of an application
    SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

    // Open a session
    Session session = sessionFactory.openSession();
    Transaction transaction = null;

    try {
      // Begin a unit of work and return the associated Transaction object.
      transaction = session.beginTransaction();

      Address address = new Address("6th cross, 6th main", "Bangalore", "560078");
      Person person = new Person("Santosh", address);

      session.persist(person);

      // commit the transaction
      transaction.commit();
    } catch (Exception e) {
      if (transaction != null) {
        transaction.rollback();
        e.printStackTrace();
      }
    } finally {
      if (session != null) {
        // End the session by releasing the JDBC connection and cleaning up.
        session.close();
      }
    }
  }
}

Before running this application you need to create the helloworld database into MySQL. Table will created automatically because we have set the hbm2ddl.auto to create-drop.

Output

This application will save the person object and its component address object in Person table.

output in console

Hibernate: create table Person (id bigint not null auto_increment, city varchar(255), street varchar(255), zipcode varchar(255), name varchar(255) not null, primary key (id)) engine=InnoDB
Jun 03, 2020 4:49:03 PM org.hibernate.resource.transaction.backend.jdbc.internal.DdlTransactionIsolatorNonJtaImpl getIsolatedConnection
INFO: HHH10001501: Connection obtained from JdbcConnectionAccess [org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator$ConnectionProviderJdbcConnectionAccess@1e0f9063] for (non-JTA) DDL execution was not in auto-commit mode; the Connection 'local transaction' will be committed and the Connection will be set into auto-commit mode.
Jun 03, 2020 4:49:04 PM org.hibernate.tool.schema.internal.SchemaCreatorImpl applyImportSources
INFO: HHH000476: Executing import script 'org.hibernate.tool.schema.internal.exec.ScriptSourceInputNonExistentImpl@63a270c9'
Hibernate: insert into Person (city, street, zipcode, name) values (?, ?, ?, ?)

You can find the working code of above example on github.

Hibernate mapping types and Entity vs Value Types

2020-06-03T13:09:00.000+05:30

In Hibernate, mapping types categorized into two groups. In this article we will see overview of Hibernate mapping types and the difference between them.

Hibernate mapping types

Hibernate categorized into two groups with respect to persistence.

Entity Type
Value Type

Entity Type

An object of Entity type has its own database identity means primary key in table.

An entity has its own lifecycle. It may exist independently of any other entity.

A reference of entity object is persisted as a reference in database (foreign key).

Value Type

An object of Value type has no database identity and it belongs to entity.

The lifecycle of Value type object is bounds to its owning entity object's lifecycle.

Value type object is identified by its owning entity.

It is embedded into owning entity and it represented as table's column in database./p>

Value types further divided into three groups.

Basic value types
Composite types
Collection types

Basic value types

Basic value types maps a single database value (column) to a single, non-aggregated Java type.
Hibernate provides a number of built-in basic types and all the Java wrapper classes.
String, Character, Boolean, Byte, Short, Integer, Long, Float, Double, BigInteger, BigDecimal, java.util.Date or java.sql.Timestamp, java.sql.Time, java.sql.Date, java.util.Calendar, java.util.Currency, java.util.UUID, java.lang.Class, java.sql.Blob .. etc are built-in basic value types.
You can find the all the built-in basic types from Hibernate documentation Basic value types.

Composite types

The Java Persistence API calls these embedded types, while Hibernate traditionally called them components.
Components represent aggregations of values into a single Java type.
In many ways, Composite types looks exactly like an entity. Composite types does not own its own lifecycle nor does it define an identifier.

Collection types

Hibernate allows to persist collections. Collections types further sub categorized into three types.

Collection of basic value types.
Collection of Composite or embeddable types.
Collection of custom types.

Now we take one example to understand the Entity type, and Value Type. Below USERS table has user details, home address, and billing address.

Now we a represent the same table in the object model like below with the six-member variables homeStreet, homeCity, homePincode, billingStreet, billingCity, and billingPincode.

public class User {

  private Long id;
  private String name;
  private String homeStreet;
  private String homeCity;
  private String homePincode;
  private String billingStreet;
  private String billingCity;
  private String billingPincode;
}

Rather we would like to have a separate class User and Address. Address class only have address related details. The homeAddress and billingAddress member variable of class User to access user's address from it. This is better design from code reuse perspective.

public class User {

  private Long id;
  private String name;
  private Address homeAddress;
  private Address billingAddress;
}

public class Address {

  private String street;
  private String city;
  private String pincode;
}

The id attribute in User class identity the record uniquely in database's table. Here we don't have id attribute in Address class and didn't have any significance of identity of an address.

You can follow the article this article to create Hello World application with Hibernate. and Hello world application using JPA Annotations. You can also follow this article to find out the difference between @Entity and @Table annotation.

The objects that have their own database identity are Entity type object. So here User is an Entity type and Address is a Value type.

Aggregation and Composition

2020-06-01T13:46:00.000+05:30

Aggregation

Aggregation indicates a relationship between whole and its parts.

For example, A music band is made up of artists. So music band has its artists as its parts and the band is the whole. If the band is broken. Its artists does not have to broken with it. They could still join other band independently or some of them can even start their own band.

In aggregation relationship, When the whole is destroyed, its parts are not destroyed with it.

Composition

Composition is a strong form of aggregation. When we talk about composition relationship, when the whole is destroyed its parts are also destroyed with it. it is a strong form of aggregation.

For example, Here the house has its rooms as part and the house itself as a whole. When the house is destroyed its rooms are also destroyed. In composition relationship each part belongs to only one whole. It means it is not shared with others just like a room in a house. Room is the part of your house, not your neighbors.

Unlike aggregation relationship, when the whole is destroyed its parts are also destroyed with it.

profile based logback in spring boot

2020-01-30T22:03:00.000+05:30

You can print the log in the spring boot based on your deployment enviornment. create logback-spring.xml file under the resources folder of spring boot project structure.

<?xml version="1.0" encoding="UTF-8"?>

<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}}/spring.log}"/>
    <property name="LOG_PATH" value="/home/santosh/logs/some-path"/>
    <property name="LOG_ARCHIVE" value="${LOG_PATH}/archive"/>
    <timestamp key="timestamp-by-second" datePattern="yyyyMMdd'T'HHmmss"/>
    <include resource="org/springframework/boot/logging/logback/console-appender.xml"/>

    <!---->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder>
            <pattern>${FILE_LOG_PATTERN}</pattern>
        </encoder>
        <file>${LOG_FILE}</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i</fileNamePattern>
        </rollingPolicy>
    </appender>

    <springProfile name="dev">
        <root level="DEBUG">
            <appender-ref ref="CONSOLE"/>
        </root>
    </springProfile>
    <springProfile name="stage">
        <root level="INFO">
            <appender-ref ref="CONSOLE"/>
            <appender-ref ref="FILE"/>
        </root>
    </springProfile>
    <springProfile name="prod">
        <root level="INFO">
            <appender-ref ref="FILE"/>
        </root>
    </springProfile>
</configuration>

Difference between Entity and Table annotation

2019-06-02T18:23:00.000+05:30

@javax.persistence.Entity:Specifies that the class is an entity. This annotation is applied to the entity class.
@javax.persistence.Table:Specifies the primary table for the annotated entity. Additional tables may be specified using SecondaryTable or SecondaryTables annotation. If no Table annotation is specified for an entity class, the default values apply.

Difference between @Entity and @Table

@Entity(name = "someName") : this name will be used to name the Entity
@Table(name = "otherName") : this name will be used to name a table in DB

There will be only two valid scenario. Let's understand this with examples. We will using persistence Message class through out this discussions.

package com.walking.techie.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@Entity
public class Message {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "ID")
  private Long id;

  @Column(name = "MESSAGE")
  private String message;

  public Message(String message) {
    this.message = message;
  }
}

We will have both properties <property name="hbm2ddl.auto">create-drop</property> and <property name="show_sql">true</property> in hibernate.cfg.xml file. You can refer this from here. So that every time we run Hibernate application table will deleted if it exists in DB and create new one in DB and sql queries will print on console.

Scenario 1: Only @Entity annotation used

Scenario 1.1: When only @Entity annotation used on persistence class

@Entity
public class Message {
    .............
    .............
}

If you don't use name element then table and entity name will be same as default; name of persistence class.

Hibernate Query: create table Message (ID bigint not null auto_increment, MESSAGE varchar(255), primary key (ID)) engine=InnoDB

Scenario 1.2: When @Entity annotation used with name element on persistence class

@Entity(name = "message")
public class Message {
    .............
    .............
}

If you use name element then table and entity name will be same as value of name element.

Hibernate Query: create table message (ID bigint not null auto_increment, MESSAGE varchar(255), primary key (ID)) engine=InnoDB

In this case table and entity will have the same name, that will allow you to access your table with the same name as the entity while writing HQL or JPQL.

Scenario 2: Both @Entity and @Table annotations used

Scenario 2.1: @Entity and @Table annotations used on persistence class

@Entity
@Table
public class Message {
    .............
    .............
}

This is same as scenario 1.1.

Hibernate Query: create table Message (ID bigint not null auto_increment, MESSAGE varchar(255), primary key (ID)) engine=InnoDB

Scenario 2.2: @Entity(name = "MESSAGE") and @Table annotations used on persistence class

@Entity(name = "MESSAGE")
@Table
public class Message {
    .............
    .............
}

Hibernate Query: create table MESSAGE (ID bigint not null auto_increment, MESSAGE varchar(255), primary key (ID)) engine=InnoDB

Scenario 2.3: @Entity and @Table(name = "text_message") annotations used on persistence class

@Entity
@Table(name = "text_message")
public class Message {
    .............
    .............
}

Hibernate Query: create table text_message (ID bigint not null auto_increment, MESSAGE varchar(255), primary key (ID)) engine=InnoDB

Scenario 2.4: @Entity(name = "MESSAGE") and @Table(name = "text_message") annotations used on persistence class

@Entity(name = "MESSAGE")
@Table(name = "text_message")
public class Message {
    .............
    .............
}

Hibernate Query: create table text_message (ID bigint not null auto_increment, MESSAGE varchar(255), primary key (ID)) engine=InnoDB

In this case, while writing queries you have to use the name given in @Entity and the name given in @Table will be used to name the table in the DB. So the entity name you use in your JPQL will refer to otherName in the DB.

Hello World application with Hibernate using JPA annotations

2019-05-30T16:42:00.000+05:30

Welcome to the Hibernate tutorial from beginner to advance. Hibernate is one of the most popular ORM tool. We will discuss each and every concept in detail. You will find this post very useful even you are beginner or advance in Hibernate.

We will understand the basic concept of Hibernate using the Hello World program with JPA annotations that will be very simple hibernate program, will explain about hibernate concept.

In the previous post, we have discussed about the Hello World program using the mapping file.

Hello World Program with JPA annotations

We will create the hello-world-hibernate-jpa-anno gradle based application. Project structure of this application is something like below.

Hibernate Properties

hibernate.cfg.xml is a Hibernate configuration xml file which contain the required Hibernate properties. Most of the properties have their own default value. Some of the properties values need to have into this file, so Hibernate use these properties to create connection with database.

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/helloworld?useSSL=false</property>
        <property name="connection.username">root</property>
        <property name="connection.password">santosh</property>
        <property name="hbm2ddl.auto">update</property>

        <!-- SQL Dialect -->
        <property name="dialect">org.hibernate.dialect.MariaDBDialect</property>
        <!--Echo all executed SQL query to console-->
        <property name="show_sql">true</property>
        <mapping class="com.walking.techie.entity.Message"/>

    </session-factory>
</hibernate-configuration>

This table show some of the important properties that you will use into Hibernate configuration file.

Properties	Description
connection.driver_class	The JDBC driver class.
connection.url	The JDBC URL to the database instance.
connection.username	The database username to authenticate.
connection.password	The database password to authenticate.
hbm2ddl.auto	This property validates or exports schema DDL to the database when the SessionFactory is created.
dialect	This property makes Hibernate to generate the appropriate SQL for the chosen database.
show_sql	This property echo the generated SQL query on console.

Create SessionFactory

Usually an application has single SessionFactory instance and Session instance can get from this factory instance. Client request served by threads using Session instance.

The internal state of a SessionFactory is immutable. Once it is created this internal state is set. This internal state includes all of the metadata about Object/Relational Mapping.

package com.walking.techie.utils;


import org.hibernate.SessionFactory;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

public class HibernateUtil {

    public static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder()
                    .configure("hibernate.cfg.xml").build();
            Metadata metadata = new MetadataSources(standardRegistry).getMetadataBuilder().build();
            return metadata.getSessionFactoryBuilder().build();
        } catch (Exception ex) {
            System.err.println("Initial session factory creation failed: " + ex.getMessage());
            throw new ExceptionInInitializerError();
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Model

Message Java class is a persistence entity that will save into relational database. I have used the lombok annotation here to create getter, setter, default constructor of the Message class.

package com.walking.techie.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@Entity
@Table(name = "MESSAGE")
public class Message {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "ID")
  private Long id;

  @Column(name = "MESSAGE")
  private String message;

  public Message(String message) {
    this.message = message;
  }
}

In the previous post, we have used XML based mapping file to specify mapping between Message class and "MESSAGE" table. In XML based metadata that will have to manage in separate file for each and every entity class.
@Entity: specifies that the class is an entity. This annotation is applied to the entity class.
@Table: specifies the name of the table in database with which entity class is mapped.
@Id: This annotation specifies the primary key of the entity.
@GeneratedValue: This annotation specifies the generation strategies for the values of primary keys.
@Column: is used to specify the mapped column for a persistent property or field.
Now let's see, how Hibernate using these annotations for Message entity class in details:

The @Entity annotation tells Hibernate that Message class is a persistent entity that to have its state persisted to the "helloworld" database.
The @Table annotation specifies the name of the table and we are mapping it to the "MESSAGE" table.
The @Id annotation indicate that id attribute or field of this class represents a primary key or unique identifier of message table and @GeneratedValue annotation with auto strategy tells hibernate that whenever a new message entity is persisted to the "helloworld" database. The database generate the unique primary key value for that entity and the hibernate is going to set the value of this id attribute using the newly generated primary key value. This is same as what native strategy in the mapping file was doing for us.
The @Column annotation tells Hibernate about the column you want to map this id attribute and message attribute to "ID" and "MESSAGE" respectively in the "MESSAGE" table.

Then one final change we need to make in hibernate.cfg.xml file is to change the mapping resource attribute to a mappingclass attribute and specify the class we declared as entity.

HelloWorldClient

This class main method will save the message object into MESSAGE table of helloworld database.

package com.walking.techie;

import com.walking.techie.entity.Message;
import com.walking.techie.utils.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class HelloWorldClient {
  public static void main(String[] args) {
    // get session factory of an application
    SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

    // Open a session
    Session session = sessionFactory.openSession();

    // Begin a unit of work and return the associated Transaction object.
    Transaction transaction = session.beginTransaction();

    Message message = new Message("Hello world with hibernate using JPA annotations");

    // save the message object into table
    session.save(message);

    // commit the transaction
    transaction.commit();

    // End the session by releasing the JDBC connection and cleaning up.
    session.close();
  }
}

Before running this application you need to create the helloworld database into MySQL. Table will created automatically because we have set the hbm2ddl.auto to update.

Output

This application will save the message object in MESSAGE table.

output in console

May 30, 2019 3:55:59 PM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {5.2.12.Final}
May 30, 2019 3:55:59 PM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 30, 2019 3:55:59 PM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {5.0.1.Final}
May 30, 2019 3:55:59 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH10001002: Using Hibernate built-in connection pool (not for production use!)
May 30, 2019 3:55:59 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001005: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost:3306/helloworld?useSSL=false]
May 30, 2019 3:55:59 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001001: Connection properties: {user=root, password=****}
May 30, 2019 3:55:59 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001003: Autocommit mode: false
May 30, 2019 3:55:59 PM org.hibernate.engine.jdbc.connections.internal.PooledConnections <init>
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
May 30, 2019 3:55:59 PM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MariaDBDialect
May 30, 2019 3:56:00 PM org.hibernate.resource.transaction.backend.jdbc.internal.DdlTransactionIsolatorNonJtaImpl getIsolatedConnection
INFO: HHH10001501: Connection obtained from JdbcConnectionAccess [org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator$ConnectionProviderJdbcConnectionAccess@71454b9d] for (non-JTA) DDL execution was not in auto-commit mode; the Connection 'local transaction' will be committed and the Connection will be set into auto-commit mode.
Hibernate: create table hibernate_sequence (next_val bigint) engine=InnoDB
Hibernate: insert into hibernate_sequence values ( 1 )
Hibernate: create table MESSAGE (ID bigint not null, MESSAGE varchar(255), primary key (ID)) engine=InnoDB
Hibernate: select next_val as id_val from hibernate_sequence for update
Hibernate: update hibernate_sequence set next_val= ? where next_val=?
Hibernate: insert into MESSAGE (MESSAGE, ID) values (?, ?)

find the above working code from git.

Inserting a node in a singly linked list

2018-12-13T16:41:00.000+05:30

In the previous post, we have introduced about Linked Lists. We have also discussed to create a singly linked list with 3 nodes.

All program uses the below representation of the Singly linked list.

public class SinglyLinkedList<E> {

  // instance variables of the SinglyLinkedList
  private Node<E> head = null; // head node of the list (or null if empty)

  // ---------------- nested Node class ----------------
  private static class Node<E> {
    private E data;
    private Node<E> next;

    public Node(E data) {
      this.data = data;
    }
  }
  // ----------- end of nested Node class -----------
}

In this post, we will discuss to insert a node in the linked list. Below are following ways to insert the node in the linked list.

Insert a node at the head of a singly linked list.
Insert a node at the tail of a singly linked list.
Insert a node after given node of a singly linked list.

Insert a node at the head of a singly linked list.

The new node is always inserted at front of the linked list and newly inserted node become the head of the linked list.

When using a singly linked list, we can easily insert an element at the head of the list. The main idea is that we create a new node, set its data(element) to the new node, set its next link to refer to the current head, and set the list’s head to point to the new node.

Example: Let's take an example of singly linked list is 20->30->40 and we want to insert 10 at the head, then the linked list becomes 10->20->30->40.

Let's implement a method call it as addFirst that will insert a node at the head of the linked linked.

Following are the step to add node at the head of the linked list.

/* This method add a node at the head of the linked list or
 * you can say add a node at front of the linked list.*/
private void addFirst(E e) {
  // Create a new node and allocate element or data into it
  Node<E> newNode = new Node<E>(e);

  // refer next of new node to head
  newNode.next = this.head;

  // reassign head reference to the new node
  this.head = newNode;
}

Insert a node at the tail of a singly linked list.

The new node is always added after the last node of the linked list. Let's take an example If the given linked list is 20->30->40 and we want to insert 50 at the end of the linked list, then the linked list becomes 20->30->40->50.

Here we are not maintaining the tail reference of the linked list so we need to traverse the linked to till end then change the last node's next to new node.

Following is the Java code to insert node at the end of the linked list.

/* This method add a new element at the tail of the linked list or
 * you can say at the end of the linked list.*/
private void addLast(E e) {
  // Create a new node and allocate element or data into it
  Node<E> newNode = new Node<E>(e);

  // New node is going to be the last node, so assign new's next as null
  // refer next of new node to null
  newNode.next = null;

  // If the linked list is empty then make the new node as head and return.
  if (this.head == null) {
    newNode = this.head;
    return;
  }

  // If linked list not empty then need to reach at the end of linked list
  Node<E> current = this.head;
  while (current.next != null) {
    current = current.next;
  }

  // reassign tail reference to the new node
  current.next = newNode;
}

Insert a node after given node of a singly linked list.

To insert a node after the given node of the linked list, we will get the reference to the given node as the parameter in method call of addAfter.

Example: Let's take an example of singly linked list is 20->30->40 and we want to insert a node with data 35 after the given node 30 in the linked list, then the linked list becomes 20->30->35->40.

Following is the Java code to insert a node after the given node. This method accept two parameter, one is an element and other is reference of the given node after which need to insert a node.

/*The addAfter method will add the new element or data after the given node.
 * This method takes two parameters.*/
private void addAfter(E e, Node<E> givenNode) {
  // check if the given node is null and head is null
  if (givenNode == null) {
    System.out.println("The given node can't be null.");
    return;
  }

  // check if the linked list is empty or head is null
  if (this.head == null) {
    System.out.println("The given linked list is empty.");
    return;
  }

  // Create a new node and allocate element or data into it
  Node<E> newNode = new Node<E>(e);

  // assign newNode's next to givenNode's next
  newNode.next = givenNode.next;

  // assign givenNode's next as newNode
  givenNode.next = newNode;
}

Following is the complete program of the insertion of node in the linked list. This program has consolidated all the discussed method above.

public class SinglyLinkedList<E> {

  // instance variables of the SinglyLinkedList
  private Node<E> head = null; // head node of the list (or null if empty)

  // ---------------- nested Node class ----------------
  private static class Node<E> {
    private E data;
    private Node<E> next;

    public Node(E data) {
      this.data = data;
    }
  }
  // ----------- end of nested Node class -----------

  /* instance method of Singly linked list
   * which will print the data of nodes starting from the head.*/
  private void printList() {
    Node<E> current = this.head;

    while (current != null) {
      System.out.print(current.data + "->");
      current = current.next;
    }
    System.out.println("null");
  }

  // This method adds a node at the head of the linked list or
  // you can say add a node at front of the linked list.
  private void addFirst(E e) {
    // Create a new node and allocate element or data into it
    Node<E> newNode = new Node<E>(e);

    // refer next of new node to head
    newNode.next = this.head;

    // reassign head reference to the new node
    this.head = newNode;
  }

  // This method adds a new element at the tail of the linked list or
  // you can say at the end of the linked list.
  private void addLast(E e) {
    // Create a new node and allocate element or data into it
    Node<E> newNode = new Node<E>(e);

    // New node is going to be the last node, so assign new's next as null
    // refer next of new node to null
    newNode.next = null;

    // If the linked list is empty then make the new node as head and return.
    if (this.head == null) {
      newNode = this.head;
      return;
    }

    // If linked list not empty then need to reach at the end of linked list
    Node<E> current = this.head;
    while (current.next != null) {
      current = current.next;
    }

    // reassign tail reference to the new node
    current.next = newNode;
  }

  // The addAfter method will add the new element or data after the given node.
  // This method takes two parameters.
  private void addAfter(E e, Node<E> givenNode) {
    // check if the given node is null and head is null
    if (givenNode == null) {
      System.out.println("The given node can't be null.");
      return;
    }

    // check if the linked list is empty or head is null
    if (this.head == null) {
      System.out.println("The given linked list is empty.");
      return;
    }

    // Create a new node and allocate element or data into it
    Node<E> newNode = new Node<E>(e);

    // assign newNode's next to givenNode's next
    newNode.next = givenNode.next;

    // assign givenNode's next as newNode
    givenNode.next = newNode;
  }

  // method to create a simple linked list with 3 nodes
  public static void main(String[] args) {
    // Start with the empty list.
    SinglyLinkedList<Integer> singlyLinkedList = new SinglyLinkedList<Integer>();

    // add element to the front of the linked list
    // Linked list become 15->null
    singlyLinkedList.addFirst(15);

    // add element to the end of the linked list
    // Linked list become 15->50->null
    singlyLinkedList.addLast(50);

    // add element 18 after node's element is 15
    // linked list now become 15->18->50->null
    singlyLinkedList.addAfter(18, singlyLinkedList.head);

    // add element 55 after node's element is 18
    // linked list now become 15->18->55->50->null
    singlyLinkedList.addAfter(55, singlyLinkedList.head.next);

    // add element 10 to the front of the linked list
    // linked list now become 10->15->18->55->50->null
    singlyLinkedList.addFirst(10);

    // print the elements of the linked list
    singlyLinkedList.printList();
  }
}

Output:

10->15->18->55->50->null

Implementation of singly linked list

2018-12-02T18:42:00.000+05:30

Singly linked list is a collection of nodes that collectively form a linear sequence. In a singly linked list, each node stores data, and as well as a reference to the next node of the list.

Implementation

The linked list instance must keep a reference to the first node of the list, known as the head. If linked list is empty, then value of head is null.

Our implementation also takes advantage of Java’s support for nested classes, as we define a private Node class within the scope of the public SinglyLinkedList class. Having Node as a nested class provides strong encapsulation, shielding users of our class from the underlying details about nodes and links.

public class SinglyLinkedList<E> {

  // instance variables of the SinglyLinkedList
  private Node<E> head = null; // head node of the list (or null if empty)

  // ---------------- nested Node class ----------------
  private static class Node<E> {
    private E data;
    private Node<E> next;

    public Node(E data) {
      this.data = data;
    }
  }
  // ----------- end of nested Node class -----------
}

Let's create first simple singly linked list with 3 nodes.

public class SinglyLinkedList<E> {

  // instance variables of the SinglyLinkedList
  private Node<E> head = null; // head node of the list (or null if empty)

  // ---------------- nested Node class ----------------
  private static class Node<E> {
    private E data;
    private Node<E> next;

    public Node(E data) {
      this.data = data;
    }
  }
  // ----------- end of nested Node class -----------

  /* method to create a simple linked list with 3 nodes*/
  public static void main(String[] args) {
    /* Start with the empty list. */
    SinglyLinkedList<Integer> singlyLinkedList = new SinglyLinkedList<Integer>();

    // creates 3 nodes
    Node<Integer> first = new Node<Integer>(10);
    Node<Integer> second = new Node<Integer>(20);
    Node<Integer> third = new Node<Integer>(30);

    // Three nodes have been allocated  dynamically.
    // and references to these three blocks as first,
    // second and third.
    //
    //       first               second           third
    //         |                   |                 |
    //         |                   |                 |
    //     +----+------+     +----+------+     +----+------+
    //     | 10  |     |     | 20  | null |    |  30 | null |
    //     +----+------+     +----+------+     +----+------+

    // lets assign reference of first to head of singly linked list
    singlyLinkedList.head = first;

    // Singly linked list head is referencing to first node
    //
    // singlyLinkedList.head
    //        and
    //       first               second           third
    //         |                   |                 |
    //         |                   |                 |
    //     +----+------+     +----+------+     +----+------+
    //     | 10  |     |     | 20  | null |    |  30 | null |
    //     +----+------+     +----+------+     +----+------+

    // assign reference of second node to next of first
    first.next = second;

    // Now next of first Node refers to second.  So they
    //   both are linked.
    //
    // singlyLinkedList.head    second           third
    //       |                   |                 |
    //       |                   |                 |
    //   +----+------+     +----+------+     +----+------+
    //   | 10  |  -------->| 20  | null |    |  30 | null |
    //   +----+------+     +----+------+     +----+------+ *

    second.next = third; // Link second node with the third node

    // Now next of second Node refers to third.  So all three
    //     nodes are linked.
    //
    // singlyLinkedList.head        second              third
    //     |                        |           |
    //     |                        |           |
    // +----+------+     +----+------+     +----+------+
    // | 10 |  -------->| 20  |   -------->| 30 | null |
    // +----+------+     +----+------+     +----+------+
  }
}

Traversal of singly linked list

In the previous example we have created a singly linked list with three nodes. Now we will write a method to traverse over a linked list and print the data of the list. Let's give method name as printList.

public class SinglyLinkedList<E> {

  // instance variables of the SinglyLinkedList
  private Node<E> head = null; // head node of the list (or null if empty)

  // ---------------- nested Node class ----------------
  private static class Node<E> {
    private E data;
    private Node<E> next;

    public Node(E data) {
      this.data = data;
    }
  }
  // ----------- end of nested Node class -----------

  // instance method of Singly linked list
  //which will print the data of nodes starting from the head.
  private void printList() {
    Node<E> current = this.head;

    while (current != null) {
      System.out.print(current.data + "--->");
      current = current.next;
    }
    System.out.println("null");
  }

  // method to create a simple linked list with 3 nodes
  public static void main(String[] args) {
    // Start with the empty list.
    SinglyLinkedList<Integer> singlyLinkedList = new SinglyLinkedList<Integer>();

    // creates 3 nodes
    Node<Integer> first = new Node<Integer>(10);
    Node<Integer> second = new Node<Integer>(20);
    Node<Integer> third = new Node<Integer>(30);

    // lets assign reference of first to head of singly linked list
    singlyLinkedList.head = first;

    // assign reference of second node to next of first
    first.next = second;

    // assign reference of third node to next of second
    second.next = third;

    // print the elements of the linked list
    singlyLinkedList.printList();
  }
}

Output:

10--->20--->30--->null

Introduction to Linked List in Data Structure

2018-12-02T16:07:00.000+05:30

Introduction

Like array, Linked list is a linear data structure. Unlike array, linked list nodes (elements) are not stored in continuous memory location, nodes are connected using reference to the node. Nodes and elements can be used interchangeably.

Each element(node) of a list is comprising of two items - the data and a reference to the next node.

Why Linked List?

Both Array and Linked list are linear data structure, but have following limitation.

The size of an array is fixed. So we must know the upper limit of it in advance. The allocated memory is equal to upper limit irrespective of usage.
Insertion and deletion of an element in an array is expensive. Let's suppose you need to insert an element in sorted array then need to create room for new element, for that need to shift the elements of array.

For example: Lets suppose a sorted array of ids.

ids[] = [100, 110,120,130,140]

115

Lets we want to delete an id 110 from sorted array, then to maintain the sorted order we have to shift all the element to left. Now the sorted array become [100, 120,130,140].

Advantage of Linked List

Linked List is dynamic in nature which allocates memory when required. You don't need to specify the size while creating the linked list.
Ease of insertion and deletion.
Stack and queue can be easily implemented using linked list.

Disadvantage of Linked List

Memory is wasted as reference need to maintained for next node.
Random access of nodes is not possible. We have to access the node sequentially from starting of the first node.
Not cache friendly. Node stored in non-continuous address location.

Type of Linked List

There is three type of linked list. They are

Singly Linked List
Doubly Linked List
Circularly Linked List

Let's know more about them and how they are different from each other.

Singly Linked List

Singly linked list is a collection of nodes that collectively form a linear sequence. In a singly linked list, each node stores data, and as well as a reference to the next node of the list.

Doubly Linked List

The doubly linked contain data and an explicit reference to the node before it and a reference to the node after it.

Circularly Linked List

The circularly linked list is almost same as singly linked list, only difference is that the last node of it holds the reference to first node hence forming the circular chain.

Execute schema.sql and data.sql on startup of Spring Boot

2018-12-01T19:54:00.000+05:30

An SQL database can be initialized manually and can also be done through code. You can create the table and insert the data into tables using JPA.

Initialise the database using JPA

JPA has feature for DDL(Data definition language: DROP, RENAME, CREATE, ALTER, TRUNCATE) generation, and these can be setup to run on startup against database. This is controlled through two external properties:

spring.jpa.generate-ddl (boolean)

By default, its value is false. Whether to initialize schema on startup and it is vendor independent.

spring.jpa.hibernate.ddl-auto

It is a Hibernate feature that control the behavior in more fine grained way. It is DDL mode. This is actually a shortcut for the hibernate.hbm2ddl.auto property. Defaults to create-drop when using an embedded database and no schema manager was detected. Otherwise, defaults to none.

Initialize a database using Hibernate

You can set spring.jpa.hibernate.ddl-auto explicitly and standard hibernate properties values are enum: none,validate, update, create, create-drop. Spring boot choose a default value type based on the embedded database. It defaults to create-drop if no schema manager has been detected, and none is all other cases. Available embedded databases in spring boot are hsqldb, h2, and derby. An embedded database is detected by looking at Connection type.

You can create the schema from scratch by setting the ddl-auto properties to create or create-drop along with a file import.sql should be in the root of classpath is executed on startup. This is the Hibernate feature and has nothing to do with Spring framework. It is advisable to do for testing or demos, not in production environment.

Initialize a Database

Spring boot automatically create the schema(DDL scripts) of your DataSource and initialize it (DML scripts). It loads the SQL from the standard root classpath locations: schema.sql and data.sql respectively. You can create the schema and initialize it based on the platform. Platform value is of spring.datasource.platform. Now you can create files schema-${platform}.sql and data-${platform}.sql which is processed by Spring Boot. It allows you to choose the database specific scripts if necessary. You can choose the vendor name of database(platform) like hsqldb, h2, oracle, mysql, postgresql, and so on.

In the JPA based app, You should not use both spring.jpa.hibernate.ddl-auto and schema.sql. Make sure to disable spring.jpa.hibernate.ddl-auto if you use schema.sql.

Spring Boot automatically creates the schema of embedded DataSource. You can customize this behaviour using spring.datasource.initialization-mode property. You can always initialize the DataSource regardless of its type setting spring.datasource.initialization-mode=always. The property spring.datasource.initialization-mode supports three values:

always

Always initialize the datasource.

embedded

Only initialize an embedded datasource.

never

Do not initialize the datasource.

By default Spring Boot enables the fail-fast feature of the Spring JDBC initializer. This means application fails to start when scripts causes exception. You can tune that behavior by setting spring.datasource.continue-on-error.

Initialize a Spring Batch Database

In Spring Batch, Spring Boot detect your database type and execute the scripts on startup and it happens by defaults for the embedded database. You can enable it for any database by setting spring.batch.initialize-schema=always. You can also switch off the initialization explicitly by setting spring.batch.initialize-schema=never.

Execute schema.sql and data.sql with Spring Boot

Lets initialize a database with spring boot. Create schema.sql and data.sql files under resources folder. Lets understand with spring boot maven based sample application.

Project dependencies

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.walking.techie</groupId>
    <artifactId>sample-data-schema-sql</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>

    <name>sample-data-schema-sql</name>
    <description>This is a sample spring boot project which demonstrate to load schema.sql and data.sql file
    </description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

application.properties

Here, spring.jpa.generate-ddl is false and spring.jpa.hibernate.ddl-auto is none so that It will not auto generate schema scripts. In this example User is an entity class so corresponding table will not create in Database. The property spring.datasource.initialization-mode control the initialisation of datasource with available DDL and DML scripts.

spring.jpa.generate-ddl=false
spring.jpa.hibernate.ddl-auto=none
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=true
spring.datasource.username=root
spring.datasource.password=santosh
spring.datasource.initialization-mode=always

schema.sql

The schema.sql contains the DDL scripts. We will create person table in Database.

DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
);

data.sql

The data.sql contains the DML scripts. We will insert some data into person table.

INSERT INTO `person` (name) VALUES ('Santosh');
INSERT INTO `person` (name) VALUES ('Kumar');
INSERT INTO `person` (name) VALUES ('Walking');
INSERT INTO `person` (name) VALUES ('Techie');

Java model class

The User is an entity class.

package com.walking.techie.entity;

import lombok.Data;

import javax.persistence.*;

@Data
@Table(name = "user")
@Entity
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
}

Run Application

package com.walking.techie;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Once you run this spring boot application. You can see that table person is created in test Database.

You can also create user table through spring boot auto generate script if you set spring.jpa.generate-ddl to true or set spring.jpa.hibernate.ddl-auto to any validate, update, create, create-drop.

You can also run scripts based on platform. Lets suppose you want to run for mysql plateform then create files schema-mysql.sql and data-mysql.sql under resources folder and set property spring.datasource.platform=mysql in application.properties file.

Java return statement

2018-11-06T00:54:00.000+05:30

The return statement is used to explicitly return from a method. That is, it causes program control to transfer back to the caller of the method. It belongs to jump statement.

At any time in a method, the return statement can be used to control back to caller of the method. Thus, the return statement immediately terminates the method in which it is executed.

Example:

// Demonstrate return statement
class ReturnStatement {

  public static void main(String args[]) {

    boolean t = true;
    System.out.println("Before the return statement.");
    if (t) return; // return to caller
    System.out.println("This won't execute.");
  }
}

Output:

Before the return statement.

In the above program, return statement used inside the main() method. Java run-time system calls the main method, so return causes execution to return to the Java run-time system.

As you can see, the final println( ) statement is not executed. As soon as return is executed, control passes back to the caller.

Important point: if(t) statement is necessary. Without it, the Java compiler would flag an "unreachable code" error because the compiler would know that the last println() statement would never be executed. To prevent this error, the if statement is used here to trick the compiler for the sake of this demonstration.

Array in Java

2018-11-06T00:53:00.000+05:30

An array is a group of like-typed variables that are referred to by a common name. Arrays of any type can be created and may have one or more dimensions. A specific element in an array is accessed by its index.

One-Dimensional Arrays

The general form of a one-dimensional array declaration is

type var-name[ ];
or
type[] var-name;

An array declaration has two components: the type and the name. type declares the element type of the array. The element type determines the data type of each element that comprises the array. Like array of int type, we can also create an array of other primitive data types like char, float, double etc.. or user defined data type(objects of a class).Thus, the element type for the array determines what type of data the array will hold.

// both declaration are valid
int ia[];
int[] ia2;

Although this declaration establishes the fact that ia is an array variable, no array actually exists. To link ia with an actual, physical array of integers, you must allocate one using new and assign it to ia. new is a special operator that allocates memory.

Initiating the one dimensional Array in Java

When an array is declared, only reference of an array is created. To actually create the physical form of an array, need to allocate memory to array. The general form of new as it applies to one-dimensional arrays appears as follows:

array-var = new type [size];

Here, type specifies the type of data being allocated, size specifies the number of elements in array, and array-var is the variable name of array. The new is used to allocate the memory to an array.

The elements of an array allocated by new will automatically initialized to zero (for numeric type), false (for boolean), and null (for reference types).

Example:

int intArray[] = new int[10];

int intArray[]; // declare an array
intArray = new int[10]; // initialize an array

After the above statement executes, intArray will refer to an array of 10 elements. Further, all element in the array will be initialized to zero.

Creating an array in java is two step process. First, you must declare a variable of desired data type. Second, you must allocate the memory that will hold the array, using new, and assign to an array variable.

In Java, all arrays are dynamically allocated.

The element of the array can access by using the index inside the square brackets. All array indexes start at zero.

public class ArrayDemo {
  public static void main(String[] args) {
    int month_days[];
    month_days = new int[12];
    month_days[0] = 31;
    month_days[1] = 28;
    month_days[2] = 31;
    month_days[3] = 30;
    month_days[4] = 31;
    month_days[5] = 30;
    month_days[6] = 31;
    month_days[7] = 31;
    month_days[8] = 30;
    month_days[9] = 31;
    month_days[10] = 30;
    month_days[11] = 31;
    System.out.println("April has " + month_days[3] + " days.");
  }
}

Output of the program:

April has 30 days.

Array literals

Array can be initialized when they are declared. An array initializer is a list of comma-separated expressions surrounded by curly braces. The array will automatically be created large enough to hold the number of elements you specify in the array initializer.

There is no need to use new.

// An improved version of the previous program.
class ArrayDemo {
  public static void main(String args[]) {
    int month_days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    System.out.println("April has " + month_days[3] + " days.");
  }
}

Java strictly checked the range of array when you try to store or reference value and access the array element.

For example, the run-time system will check the value of each index into month_days to make sure that it is between 0 and 11 inclusive.

If you try to access elements outside the range of the array (negative numbers or numbers greater than the length of the array), you will get a run-time error(ArrayIndexOutOfBoundsException).

Accessing elements of array using for loop

Lets create an example that demonstrate average of elements of array.

Refer: For loop in Java in detail.

public class Average {
  public static void main(String args[]) {
    double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5};
    double result = 0;
    int i;
    int length = nums.length;

    // for loop
    for (i = 0; i < length; i++) result = result + nums[i];
    System.out.println("Average is " + result / length);

    result = 0;
    // foreach
    for (double num : nums) {
      result = result + num;
    }
    System.out.println("Average is " + result / length);
  }
}

Arrays are object in Java so that we can find the length of array using the length member.

Output of the above program:

Average is 12.299999999999999
Average is 12.299999999999999

Multidimensional Arrays

In Java, multidimensional arrays are actually arrays of arrays. To declare a multidimensional array variable, specify each additional index using another set of square brackets([]).

int twoD[][]= new int[3][5]; // create 3 by 5 array(2D array)
int threeD[][][]=new int[3][4][5]; // create 3 by 4 by 5 array(3D array)

public class TwoDArray {
  public static void main(String[] args) {
    int twoD[][] = new int[3][3];
    int i, j, k = 0;

    for (i = 0; i < 3; i++) {
      for (j = 0; j < 3; j++) {
        twoD[i][j] = k++;
      }
    }

    // print elements of 2D array
    for (i = 0; i < 3; i++) {
      for (j = 0; j < 3; j++) {
        System.out.print(twoD[i][j] + " ");
      }
      System.out.println();
    }
  }
}

Output of the above program

0 1 2
3 4 5
6 7 8

When you allocate memory for multi-dimensional array, you can specify the memory for the first (leftmost) dimension. You can allocate the remaining dimensions separately.

Example:

int twoD[][] = new int[3][];
twoD[0] = new int[4];
twoD[1] = new int[4];
twoD[2] = new int[4];

There is no advantage of individually allocating the second dimension in this situation.

Let's see an example with working program.

// demonstrate 2D array where manually allocate different size of second dimensions
public class UnEqualTwoDArray {

  public static void main(String[] args) {

    int twoD[][] = new int[3][];
    twoD[0] = new int[1];
    twoD[1] = new int[2];
    twoD[2] = new int[3];

    for (int i = 0; i < twoD.length; i++) {
      for (int j = 0; j < twoD[i].length; j++) {
        twoD[i][j] = i * j;
      }
    }

    // print elements of twoD array
    for (int i = 0; i < twoD.length; i++) {
      for (int j = 0; j < twoD[i].length; j++) {
        System.out.print(twoD[i][j] + " ");
      }
      System.out.println();
    }
  }
}

Output:

0
0 1
0 2 4

Let's see one more example of multidimensional array. The following program creates 3 by 4 by 5, three dimensional array.

// Demonstrate a three-dimensional array.
class ThreeDMatrix {
  public static void main(String args[]) {
    // 3D array of 3 by 4 by 5
    int threeD[][][] = new int[3][4][5];

    int i, j, k;

    for (i = 0; i < 3; i++) {
      for (j = 0; j < 4; j++) {
        for (k = 0; k < 5; k++) {
          threeD[i][j][k] = i * j * k;
        }
      }
    }

    // print 3D array
    for (i = 0; i < 3; i++) {
      for (j = 0; j < 4; j++) {
        for (k = 0; k < 5; k++) {
          System.out.print(threeD[i][j][k] + " ");
        }
        System.out.println();
      }
      System.out.println();
    }
  }
}

Example:

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12

0 0 0 0 0
0 2 4 6 8
0 4 8 12 16
0 6 12 18 24

Alternative Array Declaration Syntax

Declare one dimension array.

type[ ] var-name;

type var-name[ ];

Example:

Following two declarations are equivalent:

int a1[] = new int[5];
int[] a2 = new int[5];

Declare multidimensional array.

type[ ][ ] var-name;

type var-name[ ][ ];

Example:

Following two declarations are equivalent:

int a1[][] = new int[3][5];
int[][] a2 = new int[3][5];

You can declare multiple arrays at the same time using comma separated.

Example:

Following two declarations are equivalent:

int a1[], a2[], a3[]; // create three arrays of type int
int[] b1, b2, b3; // create three arrays of type int

Java continue statement

2018-11-04T13:55:00.000+05:30

The continue statement is used to control the flow of execution of loops. In while and do-while loops, a continue statement causes control to be transferred directly to the conditional expression that controls the loop. In a for loop, control goes first to the iteration portion of the for statement and then to the conditional expression. For all three loops, any intermediate code is bypassed.

Example:

// continue statement with for loop
public class continueForLoop {
  public static void main(String[] args) {

    for (int i = 0; i < 10; i++) {
      System.out.print(i + " ");

      if (i % 2 == 0) continue;

      System.out.println();
    }
  }
}

Output:

continue statement with label for loop

As you can use label break statement, continue can also use the label to describe which enclosing loop to continue.

Example:

Print triangular multiplication table for 0 to 9 using the continue statement.

/ Using continue with a label.
class TriangularMultiplication {
  public static void main(String args[]) {

    outer:
    for (int i = 0; i < 10; i++) {

      for (int j = 0; j < 10; j++) {

        if (j > i) {
          System.out.println();
          continue outer;
        }

        System.out.print(i * j + " ");
      } // inner loop
    } // outer loop
    System.out.println("\nOutside the outer label for loop");
  }
}

Output:

0
0 1
0 2 4
0 3 6 9
0 4 8 12 16
0 5 10 15 20 25
0 6 12 18 24 30 36
0 7 14 21 28 35 42 49
0 8 16 24 32 40 48 56 64
0 9 18 27 36 45 54 63 72 81
Outside the outer label for loop

Java continue statement with do-while loop

Example:

// continue statement with do-while loop
public class ContinueDoWhileLoop {
  public static void main(String[] args) {
    int i = 0;
    do {
      if (i == 5) continue;

      System.out.println("Value of i= " + i);

    } while (++i < 10);

    System.out.println("Outside the do-while loop.");
  }
}

Output:

Value of i= 0
Value of i= 1
Value of i= 2
Value of i= 3
Value of i= 4
Value of i= 6
Value of i= 7
Value of i= 8
Value of i= 9
Outside the do-while loop.

As you can see in the above output. Value of i= 5 is not printed.

Java continue statement with while loop

Example:

/ continue statement with while loop
public class ContinueWhileLoop {
  public static void main(String[] args) {
    int i = 0;
    while (i < 5) {
      i++; // value of i is increased by 1
      if (i == 2) continue;
      System.out.println("Value of i= " + i);
    }

    System.out.println("Outside the while loop.");
  }
}

Output:

Value of i= 1
Value of i= 3
Value of i= 4
Value of i= 5
Outside the while loop.

Java break statement inside nested loop

Java continue statement will continue the inner loop only when if you used the continue statement inside it.

Example:

// demonstrate continue statement with nested loop
public class ContinueNestedtLoop {

  public static void main(String[] args) {
    // Outer loop
    for (int i = 0; i < 3; i++) {
      System.out.println("Outer loop: i= " + i);

      // Inner loop
      for (int j = 1; j <= 3; j++) {
        if (j == 2) continue; // continue the inner loop

        System.out.println(" Inner loop: j= " + j);
      }
    }
  }
}

Output:

Outer loop: i= 0
 Inner loop: j= 1
 Inner loop: j= 3
Outer loop: i= 1
 Inner loop: j= 1
 Inner loop: j= 3
Outer loop: i= 2
 Inner loop: j= 1
 Inner loop: j= 3

Java break statement

2018-11-04T12:30:00.000+05:30

Java break statement has three uses:

It can use to exit a loop.
it can be used as a "civilized" form of goto i.e label
It terminates a statement sequence in switch statement.

Using break to exit a loop

By using break, you can force immediate termination of a loop, bypassing the conditional expression and any remaining code in the body of the loop. When a break statement is encountered inside a loop, the loop is terminated and program control resumes at the next statement following the loop.

Example:

/ Using break to exit from a loop
public class BreakForLoop {
  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      System.out.println("Value of i= " + i);
      if (i == 5) {
        break;
      }
    }
    System.out.println("Outside the for loop.");
  }
}

Output:

Value of i= 0
Value of i= 1
Value of i= 2
Value of i= 3
Value of i= 4
Value of i= 5
Outside the for loop.

As you can see the output, although the for loop is designed to run from 0 to 9, the break statement caused it to terminate early, when i equals to 5.

Java break statement can be used with any Java's loops, including intentionally infinite loops.

Java break statement with do-while loop

Example:

// break statement with do-while loop
public class BreakDoWhileLoop {
  public static void main(String[] args) {
    int i = 0;
    do {
      System.out.println("Value of i= " + i);

      if (i == 5) break;

    } while (++i < 10);

    System.out.println("Outside the do-while loop.");
  }
}

Output:

Value of i= 0
Value of i= 1
Value of i= 2
Value of i= 3
Value of i= 4
Value of i= 5
Outside the do-while loop.

Java break statement with while loop

Example:

// break statement with while loop
public class BreakWhileLoop {
  public static void main(String[] args) {
    int i = 0;
    while (i < 10) {
      System.out.println("Value of i= " + i);

      if (i == 5) break;
      i++;
    }

    System.out.println("Outside the while loop.");
  }
}

Output:

Value of i= 0
Value of i= 1
Value of i= 2
Value of i= 3
Value of i= 4
Value of i= 5
Outside the while loop.

Java break statement inside nested loop

Java break statement will only break out from the innermost loop, when it is used inside a set of nested loops.

Example:

// demonstrate break statement with nested loop
// break statement break out from the innermost loop.
public class BreakInnerMostLoop {

  public static void main(String[] args) {
    // Outer loop
    for (int i = 0; i < 10; i++) {
      System.out.println("Outer loop: i= " + i);

      // Inner loop
      for (int j = 0; j < 10; j++) {
        System.out.println(" Inner loop: j= " + j);
        if (j == 2) break; // break out from the inner loop
      }
    }
  }
}

Output:

Outer loop: i= 0
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 1
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 2
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 3
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 4
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 5
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 6
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 7
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 8
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2
Outer loop: i= 9
 Inner loop: j= 0
 Inner loop: j= 1
 Inner loop: j= 2

Using break as a form of goto (label)

Java does not have a goto statement because it provides a way to branch in an arbitrary and unstructured manner. This usually makes goto-ridden code hard to understand and hard to maintain. It also prohibits certain compiler optimizations.

The goto can be useful when you are exiting from a deeply nested set of loops. Java provides labeled break statement to achieve it. Using this form of the break statement, you can break out of one or more blocks of code. These blocks need not be part of a loop or a switch. They can be any block.

Syntax:

break label;

abel is the name of a label that identifies a block of code.

The labeled block must enclose the break statement, but it does not need to be the immediately enclosing block.

Example:

Using labeled break statement with if block.

// Using break as a civilized form of goto.
class BreakBlocksOfCode {
  public static void main(String args[]) {
    boolean t = true;

    first:
    {
      second:
      {
        third:
        {
          System.out.println("Before the break.");
          if (t) break second; // break out of second block
          System.out.println("This won't execute");
        } // end of third label
        System.out.println("This won't execute");
      } // end of second label
      System.out.println("This is after second block.");
    } // end of first label
    System.out.println("This is after first block.");
  }
}

Output:

Before the break.
This is after second block.
This is after first block.

Java break statement with labeled for loop

Mostly labeled break statement is used to break out from nested for loop.

Example:

// Using break to exit from nested loops
class BreakNestedLoop {
  public static void main(String args[]) {

    outer:
    for (int i = 0; i < 3; i++) {
      System.out.print("Pass " + i + ": ");

      for (int j = 0; j < 10; j++) {
        if (j == 5) break outer; // exit both loops
        System.out.print(j + " ");
      } // end of inner loop

      System.out.println("This will not print");
    } // end of outer label loop

    System.out.println("Loops complete.");
  }
}

Output:

Pass 0: 0 1 2 3 4 Loops complete.

Keep in mind that you cannot break to any label which is not defined for an enclosing block.

Example:

// This program contains an error.
class BreakErr {
  public static void main(String args[]) {
    one:
    for (int i = 0; i < 3; i++) {
      System.out.print("Pass " + i + ": ");
    }

    for (int j = 0; j < 100; j++) {
      if (j == 10) break one; // compile time error
      System.out.print(j + " ");
    }
  }
}

Compile give error like java: undefined label: one

Since the loop labeled one does not enclose the break statement, it is not possible to transfer control out of that block

Java break Statement with Switch

The break that terminates a switch statement affects only that switch statement and not any enclosing loops.

Example:

public class ForLoopWithSwitch {
  public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
      System.out.println("Value of i= " + i);

      switch (i) {
        case 0:
          System.out.println("Zero");
          break;
        case 1:
          System.out.println("One");
          break;
        case 2:
          System.out.println("Two");
          break;
        case 3:
          System.out.println("Three");
          break;
        case 4:
          System.out.println("Four");
          break;
        default:
          System.out.println("Values is not between 1 to 4.");
      }
    }
  }
}

Output:

Value of i= 0
Zero
Value of i= 1
One
Value of i= 2
Two
Value of i= 3
Three
Value of i= 4
Four

To understand the example of the break with the switch statement, please visit here: Java Switch Statement.

Java do while loop

2018-11-03T14:14:00.000+05:30

As you saw in Java while loop, if the condition expression in while loop is false initially, then the body of the loop will not be executed at all. However, sometimes it is desirable to execute the body of a loop at least once, even if the conditional expression is false to begin with.

The Java do while loop is a control flow statement that executes the program at least once and the further execution depends on given boolean condition.

Syntax:

do {
// code to be executed
} while (condition);

Each iteration of the do-while loop first executes the body of the loop and then evaluates the conditional expression. If this expression is true, the loop will repeat. Otherwise, the loop terminates. As with all of Java’s loops, condition must be a Boolean expression.

Flowchart:

Example:

// demonstrate the do-while loop
public class DoWhileLoopDemo {

  public static void main(String[] args) {
    int i = 10;

    do {
      System.out.println("i= " + i);
      i--; // decrease value of i by 1
    } while (i >= 0);
  }
}

You can write above program more efficiently as below:

// demonstrate the do-while loop
public class DoWhileLoopDemo {

  public static void main(String[] args) {
    int i = 10;

    do {
      System.out.println("i= " + i);
    } while (--i >= 0);
  }
}

In this example, the expression (--i > 0) combines the decrement of i and the test for zero into one expression. Here is how it works. First, the --i statement executes, decrementing i and returning the new value of i. This value is then compared with zero. If it is greater than or equal to zero, the loop continues; otherwise, it terminates.

Output:

i= 10
i= 9
i= 8
i= 7
i= 6
i= 5
i= 4
i= 3
i= 2
i= 1
i= 0

Java infinite do-while loop

If you pass true or boolean expression that will be always true after evaluation in the do-while loop, it will be infinite loop.

Syntax:

do {
// code to be executed
} while (true);

Example:

// demonstrate the infinite do-while loop
public class InfiniteDoWhileLoop {
  public static void main(String[] args) {

    int i = 0, j = 0;
    do {
      System.out.println("Infinite while loop..");

      // post increment operator
      i++;
      j++;
    } while (i == j); // value of i and j will be always same
  }
}

Output:

Infinite while loop..
Infinite while loop..
Infinite while loop..
Infinite while loop..
Infinite while loop..
ctrl+c

Now, you need to press ctrl+c to exit from the program.

The do-while loop is especially useful when you process a menu selection, because you will usually want the body of a menu loop to execute at least once.

Example:

// Using a do-while to process a menu selection
class Menu {

  public static void main(String args[]) throws java.io.IOException {
    char choice;

    do {
      System.out.println("Enter either 1, 2, 3, 4 or 5 for help:");
      System.out.println(" 1. if");
      System.out.println(" 2. switch");
      System.out.println(" 3. while");
      System.out.println(" 4. do-while");
      System.out.println(" 5. for\n");
      System.out.println("Choose one:");
      choice = (char) System.in.read();
    } while (choice < '1' || choice > '5');

    System.out.println("\n");
    switch (choice) {
      case '1':
        System.out.println("The if:\n");
        System.out.println("if(condition) statement;");
        System.out.println("else statement;");
        break;
      case '2':
        System.out.println("The switch:\n");
        System.out.println("switch(expression) {");
        System.out.println(" case constant:");
        System.out.println(" statement sequence");
        System.out.println(" break;");
        System.out.println(" //...");
        System.out.println("}");
        break;
      case '3':
        System.out.println("The while:\n");
        System.out.println("while(condition) statement;");
        break;
      case '4':
        System.out.println("The do-while:\n");
        System.out.println("do {");
        System.out.println(" statement;");
        System.out.println("} while (condition);");
        break;
      case '5':
        System.out.println("The for:\n");
        System.out.print("for(init; condition; iteration)");
        System.out.println(" statement;");
        break;
    }
  }
}

Output:

Enter either 1, 2, 3, 4 or 5 for help:
 1. if
 2. switch
 3. while
 4. do-while
 5. for

Choose one:
2


The switch:

switch(expression) {
 case constant:
 statement sequence
 break;
 //...
}

In the above program, System.in.read( ) is used to read character from keyboard. System.in.read( ) is used here to obtain the user’s choice. It reads characters from standard input (returned as integers, which is why the return value was cast to char). By default, standard input is line buffered, so you must press enter before any characters that you type will be sent to your program.

One other point to consider: Because System.in.read( ) is being used, the program must specify the throws java.io.IOException clause.

While loop in Java

2018-11-03T12:52:00.000+05:30

The Java while loop is a control flow statement that controls the execution of the programs repeatedly on the basis of given boolean condition.

Syntax:

while (condition) {
// code to be executed
}

The condition can be any boolean expression. The body of the loop will be executed as long as the conditional expression is true . When condition becomes false, control passes to the next line of code immediately following the loop. The curly braces are unnecessary if only a single statement is being repeated.

Flowchart:

Example:

// demonstrate the while loop
public class WhileLoopDemo {

  public static void main(String[] args) {
    int i = 10;

    while (i >= 0) {
      System.out.println("i= " + i);
      i--; // decrease value of i by 1
    }
  }
}

Output:

i= 10
i= 9
i= 8
i= 7
i= 6
i= 5
i= 4
i= 3
i= 2
i= 1
i= 0

Java infinite while loop

If you pass true or boolean expression that will be always true after evaluation in the while loop, it will be infinite loop.

Syntax:

while (true) {
// code to be executed
}

Example:

// demonstrate the infinite while loop
public class InfiniteWhileLoop {
  public static void main(String[] args) {

    int i = 0, j = 0;
    while (i == j) { // value of i and j will be always same
      System.out.println("Infinite while loop..");

      // post increment operator
      i++;
      j++;
    }
  }
}

Output:

Infinite while loop..
Infinite while loop..
Infinite while loop..
Infinite while loop..
Infinite while loop..
ctrl+c

Now, you need to press ctrl+c to exit from the program.

Empty body of while loop

The body of the while (or any other of Java’s loops) can be empty. This is because a null statement (one that consists only of a semicolon) is syntactically valid in Java. For example, consider the following program:

/*Loop can have empty body.
 * Demonstrate the while loop with empty body*/
class NoBody {
  public static void main(String args[]) {
    int i, j;
    i = 100;
    j = 200;

    // find midpoint between i and j

    while (++i < --j) ; // no body in this loop
    System.out.println("Midpoint is " + i);
  }
}

Output:

Midpoint is 150

Switch statement in Java

2018-11-01T20:55:00.000+05:30

The switch statement is Java’s multiway branch statement. It provides an easy way to dispatch execution to different parts of your code based on the value of an expression. Here is general form of switch statement:

switch (expression) {
case value1:
// statement sequence
break; // optional
case value2:
// statement sequence
break; // optional
......
......
......
case valueN :
// statement sequence
break; // optional
default:
// default statement sequence
}

Switch provides better alternative than a large series of if-else-if statements. Prior to JDK 7, expression must be of type byte, short, int, char, Byte, Short, Integer, Character or enum. Beginning with JDK 7, expression can also be of type String.

Important point to be noted:

There can be one or N number of case values for a switch expression.
Each value specified in case statement must be unique. In case of duplicate value, it renders compile-time error.
Type of each value must be compatible with the type of expression. The value of case must be unique constant expression or literal.
The Java switch expression must be of byte, short, int, char (with its Wrapper type), enums and string.
Each case statement can have a break statement which is optional. When control reaches to the break statement, it jumps the control after the switch expression. If a break statement is not found, it executes all the subsequent cases.
If none of the constants matches the value of the expression, then the default statement is executed.
Switch can have optional default statement.
If no case matches and no default is present, then no further action is taken.
The break statement is used inside the switch to terminate a statement sequence.

// demonstration of Switch
public class SwitchDemo {
  public static void main(String[] args) {
    // variable for switch expression
    int exp = 10;

    switch (exp) {
      case 5:
        System.out.println("5");
        break;
      case 10:
        System.out.println("10");
        break;
      case 15:
        System.out.println("15");
        break;
      default: // default case statement
        System.out.println("Not in 5, 10 or 15");
    }
  }
}

Output:

Lets see another example of switch statement inside for loop.

// A simple example of the switch.
class SampleSwitch {
  public static void main(String args[]) {

    for (int i = 0; i < 6; i++)
      switch (i) {
        case 0:
          System.out.println("i is zero.");
          break;
        case 1:
          System.out.println("i is one.");
          break;
        case 2:
          System.out.println("i is two.");
          break;
        case 3:
          System.out.println("i is three.");
          break;
        default:
          System.out.println("i is greater than 3.");
      }
  }
}

Output:

i is zero.
i is one.
i is two.
i is three.
i is greater than 3.
i is greater than 3.

Java switch statement is fall-through

The break statement is optional. If you omit the break, execution will continue on into the next case. It is sometimes desirable to have multiple cases without break statements between them.

// In a switch, break statements are optional.
class MissingBreak {
  public static void main(String args[]) {
    for (int i = 0; i < 12; i++)
      switch (i) {
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
          System.out.println("i is less than 5");
          break;
        case 5:
        case 6:
        case 7:
        case 8:
        case 9:
          System.out.println("i is less than 10");
          break;
        default:
          System.out.println("i is 10 or more");
      }
  }
}

Output:

i is less than 5
i is less than 5
i is less than 5
i is less than 5
i is less than 5
i is less than 10
i is less than 10
i is less than 10
i is less than 10
i is less than 10
i is 10 or more
i is 10 or more

Lets see more practical example

public class SeasonSwitch {
  public static void main(String args[]) {
    int month = 4;

    String season;

    switch (month) {
      case 12:
      case 1:
      case 2:
        season = "Winter";
        break;
      case 3:
      case 4:
      case 5:
        season = "Spring";
        break;
      case 6:
      case 7:
      case 8:
        season = "Summer";
        break;
      case 9:
      case 10:
      case 11:
        season = "Autumn";
        break;
      default:
        season = "Bogus Month";
    }
    System.out.println("April is in the " + season + ".");
  }
}

Output:

April is in the Spring.

public class SwitchFallThrough {
  public static void main(String[] args) {
    int exp = 10;

    switch (exp) {
      case 5:
        System.out.println("5");
      case 10:
        System.out.println("10");
      case 15:
        System.out.println("15");
      case 20:
        System.out.println("20");
      case 25:
        System.out.println("25");
      default: // default case statement
        System.out.println("Default statement.");
    }
  }
}

Output:

10
15
20
25
Default statement.

Java switch statement with String

Beginning with JDK 7, you can use String to control a switch statement.

class StringSwitch {
  public static void main(String args[]) {
    String str = "two";
    switch (str) {
      case "one":
        System.out.println("one");
        break;
      case "two":
        System.out.println("two");
        break;
      case "three":
        System.out.println("three");
        break;
      default:
        System.out.println("no match");
        break;
    }
  }
}

Output:

two

Switching on strings can be more expensive than switching on integers. Therefore, it is best to switch on strings only in cases in which the controlling data is already in string form. In other words, don’t use strings in a switch unnecessarily.

Java Nested Switch Statement

You can use switch statement inside other switch statement in Java. It is known as nested switch statement. Since a switch statement defines its own block, no conflicts arise between the case constants in the inner switch and those in the outer switch.

public class NestedSwitch {
  public static void main(String[] args) {
    int exp = 1, target = 0;
    switch (exp) {
      case 1:
        switch (target) { // nested switch
          case 0:
            System.out.println("Inner switch exp: 1");
            System.out.println("target is zero");
            break;
          case 1: // no conflicts with outer switch
            System.out.println("target is one");
            break;
        }
        System.out.println("Outer switch exp: 1");
        break;
      case 2:
        target = 3;
        System.out.println("Outer switch: 2");
        break;
    }
  }
}

Output:

Inner switch exp: 1
target is zero
Outer switch exp: 1

In summary, there are three important features of the switch statement to note:

The switch differs from the if in that switch can only test for equality, whereas if can evaluate any type of Boolean expression. That is, the switch looks only for a match between the value of the expression and one of its case constants.
No two case constants in the same switch can have identical values. Of course, a switch statement and an enclosing outer switch can have case constants in common.
A switch statement is usually more efficient than a set of nested ifs.

Java using enum with switch statement

Java allow to use enum with switch statement. Lets see an example:

public class EnumSwitchDemo {
  public enum Days {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
  }

  public static void main(String[] args) {
    Days[] days = Days.values();
    for (Days day : days) {
      switch (day) {
        case MONDAY:
          System.out.println("Monday");
          break;
        case TUESDAY:
          System.out.println("Tuesday");
          break;
        case WEDNESDAY:
          System.out.println("Wednesday");
          break;
        case THURSDAY:
          System.out.println("Thursday");
          break;
        case FRIDAY:
          System.out.println("friday");
          break;
        case SATURDAY:
          System.out.println("Saturday");
          break;
        case SUNDAY:
          System.out.println("Sunday");
          break;
      }
    }
  }
}

Output:

Sunday
Monday
Tuesday
Wednesday
Thursday
friday
Saturday

Java using wrapper with switch statement

Java allows to use four wrapper classes with swith statement. Wrapper classes are Character, Byte, Short, and Integer.

public class WrapperSwitchDemo {
  public static void main(String[] args) {
    // example of Character wrapper class
    Character exp = new Character('a');
    switch (exp) {
      case 'a':
        System.out.println("a");
        break;
      case 'b':
        System.out.println("b");
        break;
      default:
        System.out.println("Other character.");
    }

    // example of Byte wrapper class with switch statement
    Byte age = new Byte((byte) 18);
    switch (age) {
      case 16:
        System.out.println("You are under 18.");
        break;
      case 18:
        System.out.println("You are eligible for vote.");
        break;
      case 65:
        System.out.println("You are senior citizen.");
        break;
      default:
        System.out.println("Please give the valid age.");
        break;
    }

    // example of Short wrapper class with switch statement
    Short age1 = new Short((short) 65);
    switch (age1) {
      case 16:
        System.out.println("You are under 18.");
        break;
      case 18:
        System.out.println("You are eligible for vote.");
        break;
      case 65:
        System.out.println("You are senior citizen.");
        break;
      default:
        System.out.println("Please give the valid age.");
        break;
    }
    // example of Integer wrapper class with switch statement
    Integer age2 = new Integer(16);
    switch (age2) {
      case 16:
        System.out.println("You are under 18.");
        break;
      case 18:
        System.out.println("You are eligible for vote.");
        break;
      case 65:
        System.out.println("You are senior citizen.");
        break;
      default:
        System.out.println("Please give the valid age.");
        break;
    }
  }
}

Output:

a
You are eligible for vote.
You are senior citizen.
You are under 18.

How Java compiler works with switch statement

When it compiles a switch statement, the Java compiler will inspect each of the case constants and create a "jump table" that it will use for selecting the path of execution depending on the value of the expression. Therefore, if you need to select among a large group of values, a switch statement will run much faster than the equivalent logic coded using a sequence of if-elses. The compiler can do this because it knows that the case constants are all the same type and simply must be compared for equality with the switch expression. The compiler has no such knowledge of a long list of if expressions.

Java if-else statement

2018-11-01T20:53:00.000+05:30

Java if statement is used to control the flow of program's execution based upon conditions. Condition evaluated to either true or false. There are various type of if statements in Java:

if statement
if-else statement
if-else-if ladder
nested if statement

Java if statement

The if statement is Java’s conditional branch statement. It can be used to route program execution through two different paths.

Java if statement test the condition. It execute the if statement or if block only if condition is true. If condition is false then statement or block of statements is bypassed. Here is the general form of the if statement:

if (condition) statement;

if (condition) {
//.....
//code to be executed
//.....
}

You can see an example of if(condition) statement.

// demonstrate If statement
public class IfDemo {
  public static void main(String[] args) {
    // declare a num variable and initialise 20 to it
    int num = 20;

    // relation expression
    // evaluate to true or false
    if (num > 10) {
      System.out.println("Num is greater than 10.");
    }
  }
}

Output:

Num is greater than 10.

p>We have seen the expression used to control if statement is relational operators. It can control using the boolean variable. Example:

// Demonstrate if statement using boolean variable
public class IfBooleanDemo {
  public static void main(String[] args) {
    boolean flag = true;
    int a = 5;

    if (flag) System.out.println("This is an example of single statement.");

    if (flag) {
      a = 10;
      a = a >> 2;
      System.out.println("\nThis is an example of block of statements.");
      System.out.println("Value of a = " + a);
    }
  }
}

Output:

This is an example of single statement.

This is an example of block of statements.
Value of a = 2

Java if statement

Java if statement test the condition. It execute the if statement or if block only if condition is true. If condition is false then else statement or block of statements is executed. Here is the general form of the if-else statement:

if (condition) statement1;
else statement2;

if (condition) {
//.....
//code to be executed
//.....
}else {
// .......
// else code to be executed
// ......
}

// demonstrate if-else statement
public class IfElseDemo {
  public static void main(String[] args) {
    int num = 12;
    // single if-else statement
    if (num % 2 == 0) System.out.println("num is even.");
    else System.out.println("num is odd.");

    num = 21;
    // single if and block of else statements
    if (num % 2 == 0) System.out.println("\nnum is even.");
    else {
      System.out.println("\nBlock of statements in else block.");
      System.out.println("num is odd.");
    }

    // best practice to write statement's in opening curly and curly braces
    if (num >= 21) {
      System.out.println("\nnum is greater than or equal to 21");

    } else {
      System.out.println("\nnum is less than 21");
    }
  }
}

Output:

num is even.

Block of statements in else block.
num is odd.

num is greater than or equal to 21

if-else-if ladder

The if-else-if ladder statement executes one of the condition from the multiple statements.

if (condition1) {
//code to be executed if condition1 is true
} else if (condition2) {
//code to be executed if condition2 is true
} else if (condition3) {
//code to be executed if condition3 is true
}
...
else {
//code to be executed if all the conditions are false
}

The if statements are executed from the top down. As soon as one of the if conditions is true then the corresponding associated if statements is executed, and rest of the ladder is bypassed. If none of the conditions is true, then the final else statement will be executed. The else act as default condition; it will be executed if all other conditional tests fail. If there is no final else and all other conditions are false, then no action will take place.

// Demonstrate if-else-if statements.
class IfElseIfLadder {
  public static void main(String args[]) {

    int month = 4; // April

    String season;

    if (month == 12 || month == 1 || month == 2) season = "Winter";
    else if (month == 3 || month == 4 || month == 5) season = "Spring";
    else if (month == 6 || month == 7 || month == 8) season = "Summer";
    else if (month == 9 || month == 10 || month == 11) season = "Autumn";
    else season = "Bogus Month";

    System.out.println("April is in the " + season + ".");
  }
}

Output:

April is in the Spring.

nested if statement

The nested if statement represents the if block within another if block or else block.

if (condition) {
  // code to be executed
  if (condition) {
    // code to be executed
  }
} else {
  if (condition) {
    // code to be executed
  }
}

// Demonstrate Nested if
public class NestedIfDemo {
  public static void main(String[] args) {
    int i = 10, j = 30;
    int a = 0, b = -1;
    int k = 120;
    int c = 12, d = 21;

    if (i == 10) {

      if (j < 20) a = b;

      if (k > 100) c = d; // this if is
      else a = c; // associated with this else

    } else a = d; // this else refers to if(i == 10)

    System.out.println("Value of i = " + i + " j = " + j);
    System.out.println("Value of a = " + a + " b= " + b);
    System.out.println("Value of c = " + c + " d= " + d);
    System.out.println("Value of k = " + k);
  }
}

Output:

Value of i = 10 j = 30
Value of a = 0 b= -1
Value of c = 21 d= 21
Value of k = 120

Java Control statements

2018-11-01T20:51:00.000+05:30

A programming language uses control statement to control the flow of execution of a program. Java's program control statement can be categories in three: selection, iteration and jump.

Selection statement allows the different paths of execution based on outcomes of the expression or the state of variable.

Iteration statement allows execution to repeat the one or set of statements(block of code).

Jump statement allows program to run in non-linear fashion.

Selection statement

Java supports two selection statements: if and switch. These statements allow you to control the flow of your program’s execution based upon conditions known only during runtime.

if statement Read more »
switch statement Read more »

Iteration statement

We call iteration statement as loops. Loop repeatedly execute the same set of instructions until termination condition is met. Java's iteration statement are:

while loop Read more »
do-while loop Read more »
for loop Read more »

Comparison	while loop	do while loop	for loop
Introduction	The Java while loop is control flow statement that control the execution of the programs repeatedly on the basis of given boolean condition.	The Java do while loop is control flow statement that executes the program at least once and the further execution depends on given boolean condition.	The Java for loop is control flow statement that iterates the set of instruction multiple times.
when to use	If the number of iteration is unknown or not fixed, it is recommended to use while loop.	If the number of iteration is not fixed and you must have to execute the set of code at least once, it is recommended to use do-while loop.	If the number of iteration is known or fixed, it is recommended to use for loop.
Syntax	while (condition) { // code to be executed }	do { // code to be executed } while (condition);	for(initialization; condition; increment/decrement) { // code to be executed }
Syntax for infinite loop	while (true) { // code to be executed }	do { // code to be executed } while (true);	for (; ; ) { // code to be executed }
Example	int i = 0; while (i <= 5) { System.out.println(i); i++; }	int i = 0; do { System.out.println(i); i++; } while (i <= 5);	for (int i = 0; i <= 5; i++) { System.out.println(i); }

We will also see the For-Each version of for loop and nested loops.

Jump statement

Jump statement transfer the control statement to another part of program. Java support three jump statements:

break statement Read more »
continue statement Read more »
return statement Read more »