Java provides several mechanism to read Files. The most useful package that is provided for this is thejava.io.Reader. This class contains the Class BufferedReader under package java.io.BufferedReader

Let us see what this class has in store for us.

This class reads the text from an Input stream (like file) by buffering characters that efficiently reads characters, arrays or lines.

In general, each read request made of a Reader causes a corresponding read request to be made of the underlying character or byte stream. It is therefore advisable to wrap a BufferedReader around any Reader whose read() operations may be costly, such as FileReaders and InputStreamReaders.

A typical usage would involve passing the file path to the BufferedReader as follows:

The code will look like: (Assuming you have a text file in D drive)

objReader = new BufferedReader(new FileReader("D:\DukesDiary.txt"));

This basically loads your file in the objReader. Now, you will need to iterate through the contents of the file and print it. The while loop in the below code will read the file until it has reached the end of file i. e. there is no contents in the objReader.readLine() – that basically returns a string. Hence, the loop will iterate until it’s not null.

The below code shows the complete implementation.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFileExample {

	public static void main(String[] args) {

		BufferedReader objReader = null;

		try {
			String strCurrentLine;

			objReader = new BufferedReader(new FileReader("D:\DukesDiary.txt"));

			while ((strCurrentLine = objReader.readLine()) != null) {

				System.out.println(strCurrentLine);
			}

		} catch (IOException e) {

			e.printStackTrace();

		} finally {

			try {
				if (objReader != null)
					objReader.close();
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
	}
}

Note:

The above code has some very important handlings especially in the finally block of the code. This code will ensure that the memory management is done efficiently and the objReader.close() method is called that releases the memory.

Let us first understand the parameters that consist of a Date.

It will primarily contain -

• The year (in either 2 or 4 digits)
• The month (in either 2 digits, First 3 letters of the month or the entire word of the month).
•  The date (it will be the actual date of the month).
• The day (the day at the given date – like Sun, Mon, Tue etc).

In terms of computer systems, there are quite a lot of parameters that can be used to associate with a date. We shall see them in the later parts of this topic.

Displaying a Date in Java

Now let us see how Java provide us the Date, first we shall see how to get the current date-

Java provides a Date class under the java.util package, The package provides several methods to play around with the date.

You can use the Date object by invoking the constructor of Date class as follows:

import java.util.Date;

class Date_Ex1 {
public static void main(String args[]) {

// Instantiate a Date object by invoking its constructor
Date objDate = new Date();

// Display the Date & Time using toString()
 System.out.println(objDate.toString());
}
}

This will result in the following output-

Wed Sep 26 05:40:45 PST 2012

Show the date in the specified format:

You all must have learnt the alphabets in your kindergarten ….

Let us now learn the ABC’s of the date format.

Don’t worry, you don’t need to remember all of these, they can be referred anytime you need to format a particular date.

How Dates Formats can be used?

Java provides a class called a SimpleDateFormat that allows you to format and parse dates in the as per your requirements.

You can use the above characters to specify the format-

For example:

1. Date format required: 2012.10.23 20:20:45 PST

The appropriate date format specified will be- yyyy.MM.dd HH:mm:ss zzz

2 .  Date format required:09:30:00 AM 23-May-2012

The appropriate date format specified will be-hh:mm:ss a dd-MMM-yyyy

Tip: Be careful with the letter capitalization . If you mistake M with m , you will undesired results!

Lets learn this with a code example

import java.text.SimpleDateFormat;
import java.util.Date;

class TestDates_Format {
 public static void main(String args[]) {

 Date objDate = new Date( ); // Current System Date and time is assigned to objDate
 System.out.println(objDate);

String strDateFormat = "hh:mm:ss a dd-MMM-yyyy";//Date format is Specified
 SimpleDateFormat objSDF = new SimpleDateFormat (strDateFormat);//Date format string is passed as an argument to the Date format object
 System.out.println(objSDF.format(objDate));//Date formatting is applied to the current date

 }

}

Output of above code will be the current date in the specified format:

Wed Dec 26 09:11:08 GMT 2012
09:11:08 AM 26-Dec-2012

Comparison of Dates

The most useful method of comparing dates is by using the method – compareTo()

Let us take a look at the below code snippet-

import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;

class TestDates_Compare{
public static void main(String args[]) throws ParseException{

SimpleDateFormat objSDF = new SimpleDateFormat("dd-mm-yyyy");
Date dt_1 = objSDF.parse("20-08-1981");
Date dt_2 = objSDF.parse("12-10-2012");

System.out.println("Date1 : " + objSDF.format(dt_1));
System.out.println("Date2 : " + objSDF.format(dt_2));

if (dt_1.compareTo(dt_2)>0){
System.out.println("Date 1 occurs after Date 2");
}// compareTo method returns the value greater than 0 if this Date is after the Date argument.

else if (dt_1.compareTo(dt_2)<0){
System.out.println("Date 1 occurs before Date 2");
}// compareTo method returns the value less than 0 if this Date is before the Date argument;

else if (dt_1.compareTo(dt_2)==0){
System.out.println("Both are same dates");
}// compareTo method returns the value 0 if the argument Date is equal to the second Date;
else{
System.out.println("You seem to be a time traveller !!");
}
}
}

Thus the output of the above code will be as –

Date1 : 20-08-1981
Date2 : 12-10-2012
Date 1 occurs before Date 2

A HashMap basically designates unique keys to corresponding values that can be retrieved at any given point. Some core features of the HashMap are-

a)      The values can be stored in a map by forming a key-value pair. The value can be retrieved using the key by passing it to the correct method.

b)      If no element exists in the Map, it will throw a ‘NoSuchElementException’.

c)       HashMap stores only object references. That’s why, it’s impossible to use primitive data types like double or int. Use wrapper class (like Integer or Double) instead.

Using Maps in Java Programs:

Following are the two ways to declare a HashMap:

HashMap<String, Object> map = new HashMap<String, Object>();
Map<String, Object> map = new HashMap<String, Object>();

The most important methods of HashMap are-

• get(Object KEY) – This will return the value associated with specified key in this hash map.
• put(Object KEY, String VALUE) – This method stores the specified value and associates it with the specified key in this map.

Following is a sample implementation of HashMap:

  import java.util.HashMap;
  import java.util.Map;

public class Sample_TestMaps{

    public static void main(String[] args){

      Map<String, String> objMap = new HashMap<String, String>();
      objMap.put("Name", "Suzuki");
      objMap.put("Power", "220");
      objMap.put("Type", "2-wheeler");
      objMap.put("Price", "85000");

      System.out.println("Elements of the Map:");
      System.out.println(objMap);

    }
}

Output of the above code:

Elements of the Map:
{Name=Suzuki, Type=2-wheeler, Power=220, Price=85000}

Lets us ask a few queries to the HashMap itself to know it better

Q: So Mr.HashMap, how can I find if a particular key has been assigned to you?

A: Cool, you can use the containsKey(Object KEY) method with me, it will return a Boolean value if I have a value for the given key.

Q: How do I find all the available keys that are present in the Map?

A: I have a method called as keyset() that will return all the keys in the map. In the above example, if you write a line as –
System.out.println(objMap.keySet());

It will return an output as-
[Name, Type, Power, Price]

Similarly, if you need all the values only, I have a method as values().
System.out.println(objMap.values());

It will return an output as-
[Suzuki, 2-wheeler, 220, 85000]

Q: Suppose, I need to remove only a particular key from the Map, do I need to delete the entire Map?

A: No buddy!! I have a method as remove(Object KEY) that will remove only that particular key-value pair.

Q: How can we check if you actually contain some key-value pairs?

A: Just check if I am empty or not!! In short, use isEmpty() method against me

Java has had several advanced usage application  including working with complex calculations in physics, architecture/designing of structures, working with Maps and corresponding latitudes/longitudes etc. All such applications require using complex calculations/equations that are tedious to perform manually. Programmatically, such calculations, would involve usage of logarithms, trigonometry, exponential equations etc.

Now, you cannot have all the log or trigonometry tables hard-coded somewhere in your application or data. The data would be enormous and complex to maintain.

Java provides a very useful class for this purpose. It is the Math class (java.lang.Math).

This class provides methods for performing the operations like exponential, logarithm, roots and trigonometric equations too.

Let us have a look at the methods provided by the Math class.

The 2 most fundamental elements in Math are the ‘e’ (base of the natural logarithm) and ‘pi’ (ratio of the circumference of a circle to its diameter). These 2 constants are often required in the above calculations/operations.

Hence the Math class provides these 2 constants as double fields.

Math.E  – having a value as 2.718281828459045

Math.PI – having a value as 3.141592653589793

A) Let us have a look at the table below that shows us the Basic methods and its description

Below is the code implementation for the above methods:

Note: There is no  need to explicitly import java.lang.Math as its imported implicitly. All its methods are static

//Simple integer variables

int i1 = 27;
int i2 = -45;

//Simple double(decimal) variables

double d1 = 84.6;
double d2 = 0.45;

/*****      ABSOLUTE VALUES ******/

System.out.println("Absolute value of i1: " + Math.abs(i1));
Absolute value of i1: 27

System.out.println("Absolute value of i2: " + Math.abs(i2));
Absolute value of i2: 45

System.out.println("Absolute value of d1: " + Math.abs(d1));
Absolute value of d1: 84.6

System.out.println("Absolute value of d2: " + Math.abs(d2));
Absolute value of d2: 0.45

/*****  ROUND OFF  ******/

System.out.println("Round off for d1: " + Math.round(d1));
Round off for d1: 85

System.out.println("Round off for d2: " + Math.round(d2));
Round off for d2: 0

/***** CEIL AND FLOOR *****/

System.out.println("Ceiling of '"+ d1 + "' = " + Math.ceil(d1));
Ceiling of '84.6' = 85.0

System.out.println("Floor of '"+ d1 + "' = " + Math.floor(d1));
Floor of '84.6' = 84.0

System.out.println("Ceiling of '"+ d2 + "' = " + Math.ceil(d2));
Ceiling of '0.45' = 1.0

System.out.println("Floor of '"+ d2 + "' = " + Math.floor(d2));
Floor of '0.45' = 0.0

/*****  MIN AND MAX *****/

System.out.println("Minimum out of '"+ i1 +"' and '" + i2+"' = "+ Math.min(i1, i2));
Minimum out of '27' and '-45' = -45

System.out.println("Maximum out of '"+ i1 +"' and '" + i2+"' = "+ Math.max(i1, i2));
Maximum out of '27' and '-45' = 27

System.out.println("Minimum out of '"+ d1 +"' and '" + d2+"' = "+ Math.min(d1, d2));
Minimum out of '84.6' and '0.45' = 0.45

System.out.println("Maximum out of '"+ d1 +"' and '" + d2+"' = "+ Math.max(d1, d2));
Maximum out of '84.6' and '0.45' = 84.6

B)      Let us have a look at the table below that shows us the Exponential and Logarithmic methods and its description-

Below is the code implementation for the above methods: (The same variables are used as above)

System.out.println("exp(" + d2 + ") = " + Math.exp(d2));
exp(0.45) = 1.5683121854901687

System.out.println("log(" + d2 + ") = " + Math.log(d2));
log(0.45) = -0.7985076962177716

System.out.println("pow(5, 3) = " + Math.pow(5.0, 3.0));
pow(5, 3) = 125.0

System.out.println("sqrt(16) = " + Math.sqrt(16));
sqrt(16) = 4.0

C) Let us have a look at the table below that shows us the Trigonometric methods and its description-

Below is the code implementation:

double angle_30 = 30.0;
double radian_30 = Math.toRadians(angle_30);

System.out.println("sin(30) = " + Math.sin(radian_30));
sin(30) = 0.49999999999999994

System.out.println("cos(30) = " + Math.cos(radian_30));
cos(30) = 0.8660254037844387

System.out.println("tan(30) = " + Math.tan(radian_30));
tan(30) = 0.5773502691896257

System.out.println("Theta = " + Math.atan2(4, 2));
Theta = 1.1071487177940904

Now, with the above, you can also design your own scientific calculator in java.

Ever wondered how these Random numbers get generated. Who sits behind this and punches in all the numbers?

Well, Java does provide some interesting ways to generate random numbers, not only for gambling but also several other applications esp. related to gaming, security, math’s etc.

Let’s see how it’s done!!

There are basically two ways to do it-

• Using Randomclass (in package java.util).
• Using Math.random class (however this will generate double in the range of 0.0 to 1.0 and not integers).

Lets look at them one by one -

Using Random Class

First we will see the implementation using java.util.Random-

Assume we need to generate 10 random numbers between 0 to 100.

import java.util.Random;

public class RandomNumbers{

       public static void main(String[] args) {

              Random objGenerator = new Random();

              for (intiCount = 0; iCount< 10; iCount++){

                  intrandomNumber = objGenerator.nextInt(100);

                  System.out.println("Random No : " + randomNumber);

             }
     }
}

The above code will generate some random numbers like-

Random No : 48
Random No : 22
Random No : 72
Random No : 28
Random No : 48
Random No : 81
Random No : 24
Random No : 14
Random No : 98
Random No : 1

An object of Random class is initialized as objGenerator. The Random class has a method as nextInt. This will provide a random number based on the argument specified as the upper limit, whereas it takes lower limit is 0.Thus, we get 10 random numbers displayed.

Using Math.Random

Now, if we want 10random numbers but in the range of 0.0 to 1.0, then we should make use of math.random()

You can use the following loop to generate them-

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

      System.out.println(Math.random());

}

The output of this will be 10 random numbers between 0.0 and 1.0

0.9644527856979734
0.09997966059020202
0.5537801448715082
0.6781655016328573
0.5951250412997393
0.4863822453592379
0.38608567647631464
0.4520340091060806
0.7167327389890008
0.9767837414574334

Now, you know how those strange numbers are generated!!!

Using the Java timer for your programs

In Java, we have several ways of Timer implementation or rather its uses, a few of them are-

• To set up a specific amount of delay until a task is executed.
• To find the time difference between two specific events.

Before jumping into the Timer implementation, we need to understand a few concepts like –

• It can only be a future event that can be timed.
• Will the event occur once or repeatedly?
• How long is the Timer required?
• There may be several Timers required in parallel.
• The timers should have the facility to stop or even cancel at any given point.

The Timer in java is provided within the java.util package.

Let us have a look at using Timer for 2 tasks that we need to schedule-

Step 1) But before that lets create the class that will contain some task that we need to do-

importjava.util.TimerTask;

importjava.util.Timer;

public class TaskMaster extends TimerTask{

       String strObject;

       publicTaskMaster(String strObject){

           this.strObject = strObject;

       }

       public void run(){

           System.out.println("Inside Run task-" + strObject);

       }
}

This is a simple class that uses the run() method of Threads when the task is invoked. The String strObject will help us identify which task is running.

Step 2) Create 2 timers as follows in a class called Timers:

Timer timer_1;

Timer timer_2;

Step 3) Create a constructor of this class having 2 integer parameters as input-

public Timers(int t1,int t2) {
}

This constructor will have the code to invoke the 2 timers declared earlier to use for the tasks we created in TaskMaster class.

Step 4) Initiate the timers as follows –

timer_1 = new Timer();

Similarly do this for timer_2.

Step 5) Now if you use this timer object, you will see several methods in it.

We will first make use of the schedule method that takes in arguments as –

task – task to be scheduled.

delay – delay in milliseconds before task is to be executed.

period – time in milliseconds between successive task executions.

The delay and period will be the 2 integer arguments that we have passed in the constructor (created in step 3).

So the constructor now has the code as

timer_1 = new Timer();

timer_1.schedule(new TaskMaster("Alpha"), t1 * 1000, t1 * 1000);

Step 6) Repeat step 5 for timer_2 and pass some different string say “Delta”.

Your constructor should now be looking something like-

public Timers(int t1,int t2) {

       timer_1 = new Timer();

       timer_1.schedule(new TaskMaster("Alpha"), t1 * 1000, t1 * 1000);

       //timer_1.scheduleAtFixedRate(new TaskMaster("Alpha"), t1 * 1000, t1 * 1000);

       timer_2 = new Timer();

       timer_2.schedule(new TaskMaster("Delta"), t2 * 1000, t2 * 1000);

       //timer_2.scheduleAtFixedRate(new TaskMaster("Delta"), t2 * 1000, t2 * 1000);

}

Ignore the commented lines for now. We shall see that after executing this code in step 8.

Step 7) Now create the main method and call the Timersclass with 2 arguments as integers.

public static void main(String args[]) {

new Timers(1,5);

}

  Step 8) On executing this main method, the result will appear something like this-

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Delta

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Delta

Inside Run task-Alpha

Inside Run task-Alpha

Inside Run task-Alpha

…… This will continue until you don’t terminate the program.

This was the Schedule method of timer that schedules the specified task for repeated fixed-delay execution, beginning after the specified delay. Subsequent executions take place at approximately regular intervals separated by the specified period.

In fixed-delay execution, each execution is scheduled relative to the actual execution time of the previous execution

Step 9) Now comment the line with schedule method and uncomment the scheduleAtFixedRate.

The output will be quite similar.

This method too schedules the specified task for repeated fixed-rate execution, beginning after the specified delay. Subsequent executions take place at approximately regular intervals, separated by the specified period.

In fixed-rate execution, each execution is scheduled relative to the scheduled execution time of the initial execution.

Oh yes!! You can programmatically stop the timers by calling the cancel() method of the timer.

We all use switches regularly in our lives. Yes, I am talking about electrical switches we use for our lights and fans.

As you see from the above picture, each switch is assigned to operate for particular electrical equipment.

For example, in the picture, the first switch is for fan, next for light and so on.

Thus, we can see that each switch can activate/deactivate only 1 item.

Similarly, switch in java is a type of conditional statement that activates only the matching condition out of the given input.

Let us consider the example of a program where the user gives input as a numeric value (only 1 digit in this example) and the output should be the number in words.

The integer variable iSwitch ,is the input for the switch to work.

The various available options (read cases) are then written as case <value>alongwith a colon “:”

This will then have the statement to be executed if the case and the input to the switch match.

public class SwitchBoard {

   public static void main(String[] args) {

        intiSwitch = 4;

        switch (iSwitch){

               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("Not in list");

                      break;

        }

    }

}

The output of the following code will be :

FOUR

Now what are those 2 words break and default lying out there do?

• The first one “break” – will simply break out from the switch block once a condition is satisfied.
• “Default” – This will be executed in case none of the conditions match the given input.

What if you do not provide a break?

In case the break is not provided, it will execute the matching conditions as well as the default condition. Your logic will go haywire if that occurs.

I will leave it to the users to experiment without using break.

Points to Note

• There is no limit on the number of cases you can have.
• Switch can take input only as integers or characters.
• The latest version of Java8, also introduces the much awaited support for strings in switch statement.

So now go ahead and wire your own switch board!!

Let us take the example using a String array that you want to iterate over without using any counters.

Consider a String array arrData initialized as follows:

String[] arrData = {"Alpha", "Beta", "Gamma", "Delta", "Sigma"};

Although, you might know methods like finding the size of the array and then iterating through each element of the array using the traditional for loop (counter, condition and increment), we need to find a more optimized approach that will not use any such counter.

This is the conventional approach of the “for” loop:

for(int i=0; i<arrData.length; i++){

System.out.println(arrData[i]);

}

You can see the use of the counter and then using it as the index for the array.

Java provides a way to use the “for” loop that will iterate through each element of the array as shown below.

Following will be the syntactical template:

For(<DataType of array/List><Temp variable name>   : <Array/List to be iterated>){
    System.out.println();
//Any other operation can be done with this temp variable.
}

Here is the code for the array that we had declared earlier-

for (String strTemp : arrData){

System.out.println(strTemp);

}

You can see the difference between the loops. The code has reduced significantly. Also there is no use of the index or rather the counter in the loop.

Do ensure that, the data type declared in the foreach loop must match the data type of the array/list that you are iterating.
Here we have the entire class showing the above explanation-

public class UsingForEach {

public static void main(String[] args) {

String[] arrData = {"Alpha", "Beta", "Gamma", "Delta", "Sigma"};

//The conventional approach of using the for loop

System.out.println("Using conventional For Loop:");

for(int i=0; i<arrData.length; i++){

System.out.println(arrData[i]);

}

System.out.println("\nUsing Foreach loop:");

//The optimized method of using the for loop - also called the foreach loop

for (String strTemp : arrData){

System.out.println(strTemp);

}

}

}

Following will be output that you will get on executing this code:

Using conventional For Loop:

Alpha

Beta

Gamma

Delta

Sigma

Using Foreach loop:

Alpha

Beta

Gamma

Delta

Sigma

Let’s say you have a string – strTest – that contains a numeric value.

String strTest = “100”;

Try to perform some arithmetic operation like divide by 4 – This immediately shows you a compilation error.

Now make use of ParseInt method as follows:

int <IntVariableName> = Integer.parseInt(<StringVariableName>);

Pass the string variable as the argument.

This will convert the String to Integer and store it into the specified integer variable

Check the below code snippet-

String strTest = "100";

		//This statement results in a compilation error as you
		//cannot do arithmetic operation on Strings
		//System.out.println("Using String:" + (strTest/4));

		//Convert the String to Integer
		int iTest = Integer.parseInt(strTest);

		System.out.println("Actual String:"+ strTest);

		System.out.println("Converted to Int:" + iTest);

		//This will now execute some arithmetic operation
		System.out.println("Arithmetic Operation on Int:" + (iTest/4));

Output of the above code snippet- Actual String:100 Converted to Int:100 Arithmetic Operation on Int:25

In  earlier topics, we have seen how we joined/concatenated strings, similarly we may also need to break some string based on some attributes. Mainly this attribute will be something like a separator or a common pattern with which you want to break or split the string.

Let’s consider an example here:

Suppose we have a string variable named strMain formed of a few words like Alpha, Beta, Gamma, Delta, Sigma – all separated by comma (,).

Here if we want all individual strings, the best possible pattern would be to split it based on comma. So we will get 5 separate strings as follows:

• Alpha
• Beta
• Gamma
• Delta
• Sigma

Use the split method against the string that needs to be divided and provide the separator as argument.

In this case, the separator is comma (,) and the result of the split operation will give you an array of the split strings.

String strMain = "Alpha, Beta, Delta, Gamma, Sigma";

String[] arrSplit = strMain.split(", ");

for (int i=0; i<arrSplit.length; i++)
{
	System.out.println(arrSplit[i]);
}

The loop in the code just prints each string (element of array) after the split operation, as shown below-

Alpha

Beta

Delta

Gamma

Sigma

Consider a situation, wherein you require only the first ‘n’ elements after the split operation but want the rest of the string remain as it is. An output something like this-

• Alpha
• Beta
• Delta, Gamma, Sigma

This can be achieved by passing another argument along with the split operation and that will be the limit of strings required. Actually, it is the 1 greater than the number of times the string will be split into.

See the following code –

String strMain = "Alpha, Beta, Delta, Gamma, Sigma";

String[] arrSplit_2 = strMain.split(", ", 3);
for (int i=0; i<arrSplit_2.length; i++)
{
	System.out.println(arrSplit_2[i]);
}

Output on console: 

Alpha

Beta

Delta, Gamma, Sigma