JAVA New Features

New Features in JAVA 8

Java 8 release is the greatest thing in the Java world since Java 5 (released quite a while ago, back in 2004). It brings tons of new features to the Java as a language, its compiler, libraries, tools and the JVM (Java virtual machine) itself.

There are dozens of features added to Java 8, the most significant ones are mentioned below 🔻.

📌Lambda Expressions

Functional Programming

 Lambda expressions provide anonymous function types to Java
    – Replace use of anonymous inner classes
    – Provide more functional style of programming in Java


doSomething(new DoStuff(){
   public boolean isGood(int value){
      return value == 42;
   }
});


doSomething(answer -> answer == 42);

📌Extension Methods

Bringing Multiple Inheritance (of Functionality) to Java
 Provide a mechanism to add new methods to existing interfaces
    – Without breaking backwards compatibility 
    – Gives Java multiple inheritance of behaviour, as well as types (but not state!)

   public interface Set<T> extends Collection<T> {
      public int size();
      ... // The rest of the existing Set methods
      public T reduce(Reducer<T> r)
         default Collections.<T>setReducer;
   }

📌Static Methods In Interfaces 

 Previously it was not possible to include static methods in an interface
 Static methods, by definition, are not abstract
    – @FunctionalInterface can have zero or more static methods 

   static <T> Predicate<T> isEqual(Object target) {
      return (null == target)
         Objects::isNull
         object -> target.equals(object);
   }

📌Functional Interface 

 Single Abstract Method (SAM) type 
 A functional interface is an interface that has one abstract method 
    – Represents a single function contract
    – Doesn’t mean it only has one method
 @FunctionalInterface annotation
    – Helps ensure the functional interface contract is honoured
    – Compiler error if not a SAM

📌Method References

 Method references let us reuse a method as a lambda expression
   FileFilter x = File f -> f.canRead();
                      ⇩
   FileFilter x = File::canRead;


📌Constructor References

Same concept as a method reference
    – For the constructor
   Factory<List<String>> f = () -> return new ArrayList<String>();
                      ⇩
   Factory<List<String>> f = ArrayList<String>::new;


📌Annotations On Java Types 

 Annotations can currently only be used on type declarations
  – Classes, methods, variable definitions
 Extension for places where types are used
    – e.g. parameters
 Permits error detection by pluggable type checkers
    – e.g. null pointer errors, race conditions, etc


      public void process(@notnull List data) {…};

📌Access To Parameter Names At Runtime 

 Mechanism to retrieve parameter names of methods and constructors
  – At runtime via core reflection
 Improved code readability
    – Eliminate redundant annotations
 Improve IDE capabilities
    – Auto-generate template code
 Method and Constructor now inherit from new Executable class
    – generategetParameters() returns array of Parameter objects
    – generateName, type, annotations for each parameter

📌Parallel Array Sorting

 Additional utility methods in java.util.Arrays
  – parallelSort (multiple signatures for different primitives)
 Anticipated minimum improvement of 30% over sequential sort
    – For dual core system with appropriate sized data set
 Built on top of the fork-join framework
    – ses Doug Lea’s ParallelArray implementation
    – Requires working space the same size as the array being sorted

📌Date And Time APIs

 A new date, time, and calendar API for the Java SE platform
 Supports standard time concepts 
    – Partial, duration, period, intervals
    – time, instant, and time-zone
 Provides a limited set of calendar systems and be extensible to others
 Uses relevant standards, including ISO-8601, CLDR, and BCP47 
 Based on an explicit time-scale with a connection to UTC

Tip: Understand the concept well. Then you will be able to develop better applications.:octocat::zap:

Comments

Post a Comment

Popular posts from this blog

Preventing CSRF Using Double Submit Cookie Pattern

Image
In  previous blog post, what CSRF is and how to preventing CSRF using  Synchronizer Token Pattern are discussed.  This blog post will discuss how to use Double Submit Cookie Pattern to prevent from CSRF attacks.   How Double Submit Cookie Pattern works? When a user authenticates to a site, the site should generate a (cryptographically strong) pseudo-random value and set it as a cookie on the user’s machine separate from the session ID. The server does not have to save this value in any way, that's why this pattern is also called Stateless CSRF Defense . The site then requires that every transaction request include this random value as a hidden form value (or other request parameter). A cross origin attacker cannot read any data sent from the server or modify cookie values, per the same-origin policy.     Let's modify the previously built NodeJS application to demonstrate this 1. Handle /login POST Request. Once the u...
Read more

Preventing CSRF Using Synchronizer Token Pattern

Image
What is CSRF?  Cross-Site Request Forgery  (CSRF) is an  attack occurs when an attacker is able to create forged HTTP requests and trick the victim into making those requests via image tags, XSS, and many other ways. When the user makes these malicious requests and is authenticated with the application, the attack can be even more devastating. The attacker is able to get the user to perform state changing operations that the user is authorized to do in the application such as updating account details, making purchases, transferring money, and even deleting the account. Essentially, the attacker takes advantage of the website’s trust in the user. How CSRF works? CSRF will only work if the potential victim is authenticated.Using a CSRF attack an attacker can bypass the authentication process to enter a web application. When a victim with additional privileges performs actions that are not accessible to everyone, which is when CSRF attacks are utilized. Such as onli...
Read more

Code Coverage Using Clover

Image
What is Code Coverage? Code Coverage is the percentage of code which is covered by automated tests. Let's Get Started Code Coverage with Clover Clover is an industry-leading code coverage tool which allows us to easily measure the coverage of the unit tests, enabling targeted work in unit testing — resulting in stability and enhanced quality code with maximal efficiency of effort. It is an open source product from Atlassian. It has the server edition as well as desktop edition which is available as plugins for Eclipse and IDEA. Clover's Ant and Maven integrations allow coverage measurement to be performed in Automated Build and Continuous Integration systems, and reports generated to be shared by the team. Download and Configure Clover-for-Eclipse Download Clover-for-Eclipse from the Clover downloads page. Select from the menu " Help > Install New Software ... " Click " Add... ", next click " Archive... " and point to the...
Read more