Handling Weeks in Java 7

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 the isWeekDateSupported 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_YEAR as 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 (|).

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;