Handling Weeks in Java 7 (JNNC Technologies)

Some applications in their business logic deals with the number of weeks in a year and the current week of the year. There are 52 weeks in a year, but 52 weeks multiplied by 7 days per week equals 364 days per year, not the actual 365 days. A week number is used to refer to the week of the year.

Java 7 has introduced several methods to support determining the week of the year.

Some implementations of the abstract java.util.Calendar class do not support week calculations. To determine if the Calendar implementation supports week calculations, we need to execute theisWeekDateSupported method. It returns true if the support is provided. To return the number of weeks for the current calendar year, use the getWeeksInWeekYear method. To determine the week for the current date, use the get method with the WEEK_OF_YEARas its argument.

Below is the code to get total number of weeks and current week.

import java.util.Calendar; public class WeeksInYear {       public static void main(String[] args) {             Calendar calendar = Calendar.getInstance();             if(calendar.isWeekDateSupported()) {                   System.out.println("Number of weeks in this year: " +                              calendar.getWeeksInWeekYear());                   System.out.println("Current week number: " + calendar.                               get(Calendar.WEEK_OF_YEAR));             }       } }

The above code will give the following out put

Number of weeks in this year: 53

Current week number: 47

Explanation of Code

An instance of the Calendar class is created, which is an instance of the

GregorianCalendar class. An if statement was controlled by the isWeekDateSupported method. It returned true, which resulted in the execution of the getWeeksInWeekYear and get methods. The get method was passed in the field WEEK_OF_YEAR, which returned the current week number.

Catching multiple exception types in Java 7

In Java 7 and later, a single catch block can handle more than one type of exception. This feature helps reduce code duplication.

Consider the following example which we use prior to Java 7, which contains duplicate code in each of the catch blocks:

try{ // do some thing } catch (IOException ex) {      ex.printStackTrace(); } catch (SQLException ex) {      ex.printStackTrace(); }

The following example, which is valid in Java  7 and later, eliminates the duplicated code:

try{ // do some thing } catch (IOException | SQLException ex) {     ex.printStackTrace(); }

The catch clause specifies the types of exceptions that the block can handle, and each exception type is separated with a vertical bar (|).

---

You might also like:

• Handling Weeks in Java 7
• Using underscores in literals
• String literals in switch statements
• Using the try-with-resources block

Linkwithin

Friday, 11 November 2016

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();
  }
 }
}