10 Jdk Vii Features To Revisit, Earlier You Lot Welcome Coffee 8

It's been almost a calendar month Java 8 is released as well as I am certain all of yous are exploring novel features of JDK 8. But, before yous completely delve into Java 8, it’s fourth dimension to revisit only about of the cool features introduced on Java 7. If yous remember, Java half-dozen was nada on feature, it was all virtually JVM changes as well as performance, but JDK vii did introduced only about cool features which improved developer's twenty-four lx minutes catamenia to twenty-four lx minutes catamenia task. Why I am writing this postal service now? Why I am talking virtually Java 1. 7, when everybody is talking virtually Java 8? Well I think, non all Java developers are familiar amongst changes introduced inwards JDK 7, as well as what fourth dimension tin live improve to revisit before version than before welcoming a novel version.

I don't come across automatic resources management used yesteryear developer inwards daily life, fifty-fifty subsequently IDE's has got content assist for that. Though I come across programmers using String inwards Switch as well as Diamond operator for type inference, in 1 lawsuit again at that topographic point is real trivial known virtually fork bring together framework,  catching multiple exception inwards 1 grab block or using underscore on numeric literals.

So I took this chance to write a summary variety of postal service to revise these convenient changes as well as adopt them into out daily programming life. There are brace of adept changes on NIO as well as novel File API, as well as lots of other at API level, which is also worth looking. I am certain combined amongst Java 8 lambda expression, these characteristic volition lawsuit inwards much improve as well as cleaner code.

1) Type inference

Before JDK 1.7 innovate a novel operator <<, known equally diamond operator to making type inference available for constructors equally well. Prior to Java 7, type inference is alone available for methods, as well as Joshua Bloch has rightly predicted inwards Effective Java 2d Edition, it’s right away available for constructor as well.

Prior JDK 7, yous type to a greater extent than to specify types on both left as well as correct mitt side of object creation expression, but right away it alone needed on left mitt side, equally shown inwards below example.

Prior JDK 7

Map<String, List<String>> employeeRecords =  new HashMap<String, List<String>>(); List<Integer> primes = new ArrayList<Integer>();

In JDK 7

Map<String, List<String>> employeeRecords =  new HashMap<>(); List<Integer> primes = new ArrayList<>();

So yous receive got to type less inwards Java 7, piece working amongst Collections, where nosotros heavily job Generics. See hither for to a greater extent than detailed information on diamond operator inwards Java.

2) String inwards Switch

Before JDK 7, alone integral types tin live used equally selector for switch-case statement. In JDK 7, yous tin job a String object equally the selector. For example,

String nation = "NEW";  switch (day) {    case "NEW": System.out.println("Order is inwards NEW state"); break;    case "CANCELED": System.out.println("Order is Cancelled"); break;    case "REPLACE": System.out.println("Order is replaced successfully"); break;    case "FILLED": System.out.println("Order is filled"); break;    default: System.out.println("Invalid");  }

equals() as well as hashcode() method from java.lang.String is used inwards comparison, which is case-sensitive. Benefit of using String inwards switch is that, Java compiler tin generate to a greater extent than efficient code than using nested if-then-else statement. See hither for to a greater extent than detailed information of how to job String on Switch instance statement.

3) Automatic Resource Management

Before JDK 7, nosotros demand to job a finally block, to ensure that a resources is closed regardless of whether the endeavor tilt completes usually or abruptly, for instance piece reading files as well as streams, nosotros demand to closed them into lastly block, which lawsuit inwards lots of boiler plate as well as messy code, equally shown below :

public static void main(String args[]) {         FileInputStream fin = null;         BufferedReader br = null;         try {             fin = new FileInputStream("info.xml");             br = new BufferedReader(new InputStreamReader(fin));             if (br.ready()) {                 String line1 = br.readLine();                 System.out.println(line1);             }         } catch (FileNotFoundException ex) {             System.out.println("Info.xml is non found");         } catch (IOException ex) {             System.out.println("Can't read the file");         } finally {             try {                 if (fin != null) fin.close();                 if (br != null) br.close();             } catch (IOException ie) {                 System.out.println("Failed to closed files");             }         }     }

Look at this code, how many lines of boiler codes?

Now inwards Java 7, yous tin job try-with-resource characteristic to automatically closed resources, which implements AutoClosable and Closeable interface e.g. Streams, Files, Socket handles, database connections etc. JDK vii introduces a try-with-resources statement, which ensures that each of the resources inwards try(resources) is closed at the cease of the tilt yesteryear calling close() method of AutoClosable. Now same instance inwards Java vii volition await similar below, a much concise as well as cleaner code :

public static void main(String args[]) {        try (FileInputStream fin = new FileInputStream("info.xml");   BufferedReader br = new BufferedReader(new InputStreamReader(fin));) {   if (br.ready()) {    String line1 = br.readLine();    System.out.println(line1);   }  } catch (FileNotFoundException ex) {   System.out.println("Info.xml is non found");  } catch (IOException ex) {   System.out.println("Can't read the file");  } }

Since Java is taking tending of closing opened resources including files as well as streams, may live no to a greater extent than leaking of file descriptors as well as in all likelihood an cease to file descriptor error. Even JDBC 4.1 is retrofitted equally AutoClosable too.

4) Fork Join Framework

The fork/join framework is an implementation of the ExecutorService interface that allows yous to receive got wages of multiple processors available inwards modern servers. It is designed for piece of work that tin live broken into smaller pieces recursively. The destination is to job all the available processing mightiness to heighten the functioning of your application. As amongst whatever ExecutorService implementation, the fork/join framework distributes tasks to worker threads inwards a thread pool. The fork bring together framework is distinct because it uses a work-stealing algorithm, which is real unlike than producer consumer algorithm. Worker threads that run out of things to make tin steal tasks from other threads that are all the same busy. The see of the fork/join framework is the ForkJoinPool class, an extension of the AbstractExecutorService class. ForkJoinPool implements the essence work-stealing algorithm as well as tin execute ForkJoinTask processes. You tin roll code inwards a ForkJoinTask subclass similar RecursiveTask (which tin render a result) or RecursiveAction. See here for only about to a greater extent than information on fork bring together framework inwards Java.

5) Underscore inwards Numeric literals

In JDK 7, yous could insert underscore(s) '_' inwards betwixt the digits inwards an numeric literals (integral as well as floating-point literals) to improve readability. This is specially valuable for people who uses large numbers inwards source files, may live useful inwards finance as well as computing domains. For example,

int billion = 1_000_000_000;  // 10^9 long creditCardNumber =  1234_4567_8901_2345L; //16 digit number long ssn = 777_99_8888L; double pi = 3.1415_9265; float  pif = 3.14_15_92_65f;

You tin seat underscore at convenient points to move inwards to a greater extent than readable, for examples for large amounts putting underscore betwixt 3 digits brand sense, as well as for credit carte du jour numbers, which are xvi digit long, putting underscore subsequently quaternary digit brand sense, equally they are printed inwards cards. By the agency shout upwards that yous cannot seat underscore, only subsequently decimal release or at the outset or at the cease of number. For example, next numeric literals are invalid, because of incorrect placement of underscore:

double pi = 3._1415_9265; // underscore only subsequently decimal point long creditcardNum = 1234_4567_8901_2345_L; //underscore at the cease of number long ssn = _777_99_8888L; //undersocre at the beginning

See my postal service virtually how to job underscore on numeric literals for to a greater extent than information as well as job case.

6) Catching Multiple Exception Type inwards Single Catch Block

In JDK 7, a unmarried grab block tin grip to a greater extent than than 1 exception types.

For example, before JDK 7, yous demand 2 grab blocks to grab 2 exception types although both perform identical task:

try {     ......  } catch(ClassNotFoundException ex) {    ex.printStackTrace(); } catch(SQLException ex) {    ex.printStackTrace(); }

In JDK 7, yous could job 1 unmarried grab block, amongst exception types separated yesteryear '|'.

try {     ......  } catch(ClassNotFoundException|SQLException ex) {     ex.printStackTrace();  }

By the way, only shout upwards that Alternatives inwards a multi-catch tilt cannot live related yesteryear sub classing. For instance a multi-catch tilt similar below volition throw compile fourth dimension fault :

try {     ......  } catch (FileNotFoundException | IOException ex) {     ex.printStackTrace();  }

Alternatives inwards a multi-catch tilt cannot live related yesteryear sub classing, it volition throw fault at compile fourth dimension :
java.io.FileNotFoundException is a subclass of choice java.io.IOException
        at Test.main(Test.java:18)

come across hither to larn to a greater extent than virtually improved exception treatment inwards Java SE 7.

7) Binary Literals amongst prefix "0b"

In JDK 7, yous tin limited literal values inwards binary amongst prefix '0b' (or '0B') for integral types (byte, short, int and long), similar to C/C++ language. Before JDK 7, yous tin alone job octal values (with prefix '0') or hexadecimal values (with prefix '0x' or '0X').

int mask = 0b01010000101;

or fifty-fifty better

int binary = 0B0101_0000_1010_0010_1101_0000_1010_0010;

8) Java NIO 2.0

Java SE vii introduced java.nio.file packet as well as its related package, java.nio.file.attribute, furnish comprehensive back upwards for file I/O as well as for accessing the default file system. It also introduced the Path class which allow yous to stand upwards for whatever path inwards operating system. New File arrangement API complements older 1 as well as provides several useful method checking, deleting, copying, as well as moving files. for example, right away yous tin check if a file is hidden inwards Java. You tin also create symbolic as well as difficult links from Java code.  JDK vii novel file API is also capable of searching for files using wild cards. You also acquire back upwards to sentinel a directory for changes. I would recommend to banking concern check Java MD of novel file packet to larn to a greater extent than virtually this interesting useful feature.

9) G1 Garbage Collector

JDK vii introduced a novel Garbage Collector known equally G1 Garbage Collection, which is brusque shape of garbage first. G1 garbage collector performs clean-up where at that topographic point is most garbage. To accomplish this it dissever Java heap memory into multiple regions equally opposed to 3 regions inwards the prior to Java vii version (new, one-time as well as permgen space). It's said that G1 is quite predictable as well as provides greater through seat for retention intensive applications.

10) More Precise Rethrowing of Exception

The Java SE vii compiler performs to a greater extent than precise analysis of re-thrown exceptions than before releases of Java SE. This enables yous to specify to a greater extent than specific exception types inwards the throws clause of a method declaration. before JDK 7, re-throwing an exception was treated equally throwing the type of the grab parameter. For example, if your endeavor block tin throw ParseException as good equally IOException. In lodge to grab all exceptions as well as rethrow them, yous would receive got to grab Exception as well as declare your method equally throwing an Exception. This is variety of obscure non-precise throw, because yous are throwing a full general Exception type (instead of specific ones) as well as statements calling your method demand to grab this full general Exception. This volition live to a greater extent than clear yesteryear seeing next instance of exception treatment inwards code prior to Java 1.7

public void obscure() throws Exception{     try {         new FileInputStream("abc.txt").read();         new SimpleDateFormat("ddMMyyyy").parse("12-03-2014");             } catch (Exception ex) {         System.out.println("Caught exception: " + ex.getMessage());         throw ex;     } }

From JDK vii onwards yous tin live to a greater extent than precise piece declaring type of Exception inwards throws clause of whatever method. This precision inwards determining which Exception is thrown from the fact that, If yous re-throw an exception from a grab block, yous are truly throwing an exception type which:

   1) your endeavor block tin throw,
   2) has non handled yesteryear whatever previous grab block, and
   3) is a subtype of 1 of the Exception declared equally grab parameter

This leads to improved checking for re-thrown exceptions. You tin live to a greater extent than precise virtually the exceptions beingness thrown from the method as well as yous tin grip them a lot improve at customer side, equally shown inwards next instance :

public void precise() throws ParseException, IOException {     try {         new FileInputStream("abc.txt").read();         new SimpleDateFormat("ddMMyyyy").parse("12-03-2014");             } catch (Exception ex) {         System.out.println("Caught exception: " + ex.getMessage());         throw ex;     } }

The Java SE vii compiler allows yous to specify the exception types ParseException and IOException in the throws clause inwards the preciese() method proclamation because yous tin re-throw an exception that is a super-type of whatever of the types declared inwards the throws, nosotros are throwing java.lang.Exception, which is super shape of all checked Exception. Also inwards only about places yous volition come across terminal keyword amongst grab parameter, but that is non mandatory whatever more.

That's all virtually what yous tin revise inwards JDK 7. All these novel features of Java vii are real helpful inwards your destination towards create clean code as well as developer productivity. With lambda aspect introduced inwards Java 8, this destination to cleaner code inwards Java has reached only about other milestone. Let me know, if yous intend I receive got left out whatever useful characteristic of Java 1.7, which yous intend should live here.

Further Learning
The Complete Java MasterClass
tutorial)

How to job Stream shape inwards Java 8 (tutorial)

How to job filter() method inwards Java 8 (tutorial)

How to job forEach() method inwards Java 8 (example)

How to bring together String inwards Java 8 (example)

How to convert List to Map inwards Java 8 (solution)

How to job peek() method inwards Java 8 (example)

5 Books to Learn Java 8 from Scratch (books)

How to convert current to array inwards Java 8 (tutorial)

Java 8 Certification FAQ (guide)

Java 8 Mock Exams as well as Practice Test (test)

Thanks for reading this article therefore far. If yous similar this article as well as then delight portion amongst your friends as well as colleagues. If yous receive got whatever question, doubt, or feedback as well as then delight drib a comment as well as I'll endeavor to response your question.

P.S. : If yous desire to larn to a greater extent than virtually novel features inwards Java 8 as well as then delight come across the tutorial What's New inwards Java 8. It explains virtually all of import features of Java 8 e.g. lambda expressions, streams, functional inteface, Optionals, novel appointment as well as fourth dimension API as well as other miscelleneous changes.

P.S. : If yous dearest books as well as then yous may similar Java vii New features Cookbook from Packet Publication equally well. 

Sumber https://javarevisited.blogspot.com/

Share this post