Using the try-with-resources block

The try-with-resources statement is a try statement that declares one or more resources. A resource is an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implement java.io.Closeable, can be used as a resource.

This approach enables a better programming style as it avoids nested and excessive try-catch blocks. It also ensures accurate resource management, which is referred to as

Automated Resource Management (ARM).

The following example illustrates the use of try-with-resource

    try (BufferedReader br = new BufferedReader(new FileReader(path))) 

In this example, the resource declared in the try-with-resources statement is a BufferedReader. The declaration statement appears within parentheses immediately after the try keyword. The class BufferedReader, in Java  7 and later, implements the interface java.lang.AutoCloseable. Because the BufferedReader instance is declared in a try-with-resource statement, it will be closed regardless of whether the try statement completes normally or abruptly.

Prior to Java  7, you can use a finally block to ensure that a resource is closed regardless of whether the try statement completes normally or abruptly.

You may declare one or more resources in a try-with-resources statement. 

The following code snippet illustrates one or more resources in a try-with-resources statement. 

try (

        ZipFile zf = new java.ZipFile(zipFileName);

       BufferedWriter writer = Files.newBufferedWriter(outputFilePath, charset)

    ) {

               // To – Do

               }

In the above example, the try-with-resources statement contains two declarations that are separated by a semicolon

Example :

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

public class Java7TryResource {

public static void main(String[] args) {
 try (BufferedReader br = new BufferedReader(new FileReader(
    "C:\\myfile.txt"))) {
   System.out.println(br.readLine());
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

Difference between String, StringBuffer and StringBuilder

String

The String class represents character strings. All string literals in Java programs, such as "xyz", are implemented as instances of String class.

Strings are constant, i.e. their values cannot be changed after they are created.

String objects are immutable and they can be shared.

For example:

     String str = "xyz";

is equivalent to:

     char data[] = {'x', 'y', 'z'};

     String str = new String(data);

The class String includes methods for

• Examining individual characters of the sequence
• Comparing strings
• Searching strings
• Extracting substrings
• Creating a copy of a string with all characters translated to uppercase or to lowercase.

The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings.

String concatenation is implemented through the StringBuilder(or StringBuffer) class and its append method.

String conversions are implemented through  toString method, which is defined in  Object class.

StringBuffer

StringBuffer is a thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified.

String buffers are safe for use by multiple threads. The methods of StringBuffer are synchronized.

The principal operations on a StringBuffer are the append and insert methods, which are overloaded so as to accept data of any type.

Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string buffer.

The append method always adds these characters at the end of the buffer

The insert method adds the characters at a specified point.

For example,

if str refers to a string buffer object whose current contents are "pot",

then the method call z.append("s") would cause the string buffer to contain "pots",

whereas z.insert(2, "s") would alter the string buffer to contain "post".

If sb refers to an instance of a StringBuffer, then sb.append(x) has the same effect as sb.insert(sb.length(), x).

StringBuilder

Since Java 1.5

StringBuilder is a  mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization.

This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread

Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.

Instances of StringBuilder are not safe for use by multiple threads. If such synchronization is required then it is recommended that StringBuffer be used.

Using underscores in literals

Using underscores in literals to improve code readability

In Java SE 7 and later, any number of underscore characters (_) can appear anywhere between digits in a numerical literal. This feature enables you, to separate groups of digits in numeric literals, which can improve the readability of your code.

This is intended to improve the readability of code by separating digits of a literal into significant groups at almost any arbitrary place that meets the needs of the developer. The underscore can be applied to primitive data types in any supported base (binary, octal, hexadecimal, or decimal), and to

both integer and floating-point literals.

Example to show ways you can use the underscore in numeric literals:

            long creditCardNumber = 1234_5678_9012_3456L;

            long socialSecurityNumber = 999_99_9999L;

            float pi = 3.14_15F;

            long hexBytes = 0xFF_EC_DE_5E;

            long hexWords = 0xCAFE_BABE;

            long maxLong = 0x7fff_ffff_ffff_ffffL;

            byte nybbles = 0b0010_0101;

            long bytes = 0b11010010_01101001_10010100_10010010;

You can place underscores only between digits; you cannot place underscores in the following places:

·         At the beginning or end of a number

·         Adjacent to a decimal point in a floating point literal

·         Prior to an F or L suffix

·         In positions where a string of digits is expected

The following are the examples of invalid underscore usages:

            long creditCardNumber = _12345_67890_09876_54321L;

            float pi = 3._14_15F;

long licenseNumber = 123_456_789_L;

What is JVM, JRE and JDK

Java Virtual Machine (JVM)

The Java Virtual machine (JVM) is the virtual machine that run the Java bytecodes. The JVM doesn't understand Java source code.

You compile your *.java files to obtain *.class files that contain the bytecodes understandable by the JVM.

JVM makes Java to be a "portable language" (write once, run anywhere).

There are specific implementations of the JVM for different systems (Windows, Linux, MacOS) the aim is that with the same bytecodes they all give the same results.

Java Runtime Environment (JRE)

The Java Runtime Environment (JRE) provides the libraries, the Java Virtual Machine, and other components to run applets and applications written in the Java programming language. The JRE does not contain tools and utilities such as compilers or debuggers for developing applets and applications. If we want only to execute the programs written by others, then JRE alone will be sufficient.

Java Development Kit (JDK)

The JDK is a superset of the JRE, and contains everything that is in the JRE, plus tools such as the compilers and debuggers necessary for developing applets and applications.

String literals in switch statements

Prior to Java 7, only integer values were the valid arguments in a switch statement. It is very common to make a decision based on a string value, up till now developers have been using if statements whenever there is a need to make a decision based on String values, use of String in switch statement result in more readable and efficient code.

Code Snippet to display the use of String in Switch Statement

String day;

            day= "";

            switch(day){

            case "Monday" :

                  System.out.println("1st Day");

                  break;

            case "Tuesday" :

                  System.out.println("2nd Day ");

                  break;

                  default:

                        System.out.println("Holiday ");

            }

When using strings, you need to be careful about the following two issues:

ü  Null values for strings : Using a string reference variable that is assigned a null value will result in a java.lang.NullPointerException.

ü  The case of the string : The evaluation of a case expression is case sensitive in a switch statement.

 . . . read more