DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports Events Over 2 million developers have joined DZone. Join Today! Thanks for visiting DZone today,
Edit Profile Manage Email Subscriptions Moderation Admin Console How to Post to DZone Article Submission Guidelines
View Profile
Sign Out
Refcards
Trend Reports
Events
Zones
Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
  1. DZone
  2. Coding
  3. Java
  4. SKP's Java / Java EE Gotchas : Revisiting Java SE 8 Features!

SKP's Java / Java EE Gotchas : Revisiting Java SE 8 Features!

As the Revisiting Java SE series closes, and with Java 9 around the corner, let's take a look at the boons Java 8 offered, particularly for functional programming.

Sumith Puri user avatar by
Sumith Puri
·
Apr. 18, 19 · Tutorial
Like (7)
Save
Tweet
Share
13.43K Views

Join the DZone community and get the full member experience.

Join For Free

Preparing for an interview? Want to just revisit Java SE 8 features? Trying to recollect or revise a Java SE programming construct? Let me take you back in time to what was introduced first in Java SE 8? Join me for this tutorial series on Java as we all eagerly await the official release of Java SE 9!

Java SE 8 Release Date: 18-03-2014

Java SE 8 Code Name: [Not Available]


Java SE 8 Highlights

  • Lambda expressions

  • Parallel array operations

  • Method parameter reflection

  • Repeating annotations

  • Method references

I have provided some of the most important core language enhancements for JDK 8.0, along with code samples. The examples provided below can be directly pasted into your IDE, and you may name the class as provided.


Lambda Expressions

Lambda expressions provide a newer way to refer to anonymous methods. It is more like a method interface providing the accepted parameters along with a method body. In a way, it solves the vertical problem — which leads to more maintainable code or fewer lines of code to achieve the same functionality.

 public class jdk8_LambdaExpressions {  
      public static void main(String[] args) {  
           Runnable r2 = () -> System.out.println("Son of God");  
           r2.run(); // note that this is not starting a thread  
      }  
 }  


Parallel Array Operations

Another powerful feature of JDK 8 is that parallel operations are allowed on the same set of data. This is through creating stream out of the data. It is guaranteed to be faster if you have multiple processor cores on your system.

 import java.util.ArrayList;  
 import java.util.List;  
 import java.util.Random;  
 public class jdk8_ParallelArrayOperations {  
      static List<Project> projects = new ArrayList<Project>();  
      public static void main(String[] args) {  
           Project project = new Project();  
           project.setName("development");  
           projects.add(project);  
           project = new Project();  
           project.setName("testing");  
           projects.add(project);  
           project = new Project();  
           project.setName("build");  
           projects.add(project);  
           projects.stream().parallel().forEach(a->action(a));  
           for(Project p: projects) {  
                System.out.println(p.getName()+":"+p.getManager());  
           }  
      }  
      public static void action(Project x) {            
           int pmR=new Random().nextInt(1000);  
           x.setManager("john"+pmR);  
      }  
 }  

 class Project {  
      String name;  
      String manager;  
      public String getName() {  
           return name;  
      }  
      public void setName(String name) {  
           this.name = name;  
      }  
      public String getManager() {  
           return manager;  
      }  
      public void setManager(String manager) {  
           this.manager = manager;  
      }  
 }  


Method Parameter Reflection

Another nice feature, particularly useful when you are using reflection and debugging large amounts of code, is additional introspection on the real parameter names. By compiling the code with JDK 8 using the following command, we enable this feature. Note that it will lead to the use of additional memory/bytecode size.

 javac -parameters jdk8_MethodParameterReflection.java   


The following method illustrates the use of method parameter reflection in a Java program.

 import java.lang.reflect.Method;  
 import java.lang.reflect.Parameter;  

 public class jdk8_MethodParameterReflection {  
      public static void main(String[] args) {            
           Class<BlackHat> clazz = BlackHat.class;  
           for(Method m: clazz.getDeclaredMethods()) {  
                for(Parameter p: m.getParameters()) {  
                     System.out.println(p.getName());  
                }  
           }  
      }  
 }  
 class BlackHat {       
      public void payload(String hostName, int hostPort, boolean howdy) {            
           System.out.println("i can do something");  
      }  
 }  


Repeating Annotations

Prior to JDK 8, there was no easy way to manage repeating annotations other than the user or the developer providing custom ways to handle them. With JDK 8, your is allowed to define the same annotation more than once. You may place the following code under the package 'jdk8.features'.

 package jdk8.features;  
 import java.lang.annotation.Repeatable;  
 import java.lang.annotation.Retention;  
 import java.lang.annotation.RetentionPolicy;  
 @Retention( RetentionPolicy.RUNTIME )  
 @Repeatable(value = jdk8_RepeatableAnnotationsSources.class)  
 public @interface jdk8_RepeatableAnnotationsSource {  
      String version() default "";       
 }  


Now, you can define the annotation that you had mentioned as the value for the '@Repeatable' Annotation. You may place the following code under the package 'jdk8.features'.

 package jdk8.features;  
 import java.lang.annotation.Retention;  
 import java.lang.annotation.RetentionPolicy;  
 @Retention(RetentionPolicy.RUNTIME)  
 public @interface jdk8_RepeatableAnnotationsSources {  
      jdk8_RepeatableAnnotationsSource[] value();  
 }  


You can use Repeatable Annotations as follows. Also, you can use any of the methods getAnnotation() or getAnnotationsByType() to parse the annotation and process them.

 import jdk8.features.jdk8_RepeatableAnnotationsSource;  
 import jdk8.features.jdk8_RepeatableAnnotationsSources;  

 @jdk8_RepeatableAnnotationsSource(version = "jdk5")  
 @jdk8_RepeatableAnnotationsSource(version = "jdk6")  
 @jdk8_RepeatableAnnotationsSource(version = "jdk7")  
 public class jdk8_RepeatableAnnotations {  
      public static void main(String[] args) {  
           Class<jdk8_RepeatableAnnotations> clazz = jdk8_RepeatableAnnotations.class;  
           jdk8_RepeatableAnnotationsSources sources1 = clazz.  
                     getAnnotation(jdk8_RepeatableAnnotationsSources.class);            
           jdk8_RepeatableAnnotationsSource[] sources2 = clazz.  
                     getAnnotationsByType(jdk8_RepeatableAnnotationsSource.class);  
           for(jdk8_RepeatableAnnotationsSource source: sources1.value()) {  
                System.out.println(source.version());  
           }  
           for(jdk8_RepeatableAnnotationsSource source: sources2) {  
                System.out.println(source.version());  
           }  
      }  
 }  


Method References

Method references are like lambda expressions, except that they allow to us specify or refer to the existing method by name. The operator to refer to an existing method name is "::".You may place the following code under the package 'jdk8.features'.

 package jdk8.features;  
 public class jdk8_MethodReferencesVO {  
      Integer age;  
      String name;  
      public Integer getAge() {  
           return age;  
      }  
      public void setAge(Integer age) {  
           this.age = age;  
      }  
      public String getName() {  
           return name;  
      }  
      public void setName(String name) {  
           this.name = name;  
      }  
 }  


Note the usage below of method references. There can be four types of references to methods, including:

  • Reference to a static method [ContainingClass::staticMethodName]
  • Reference to an instance method [containingObject::instanceMethodName]
  • Reference to a constructor [ClassName::new]
  • Reference to an instance method [ContainingType::methodName {Arbitary Object}]
 import java.util.Arrays;  
 import jdk8.features.jdk8_MethodReferencesVO;  

 public class jdk8_MethodReferences {  
   public int compareByName(jdk8_MethodReferencesVO a, jdk8_MethodReferencesVO b) {  
     return a.getName().compareTo(b.getName());  
   } 

   public int compareByAge(jdk8_MethodReferencesVO a, jdk8_MethodReferencesVO b) {  
     return a.getAge().compareTo(b.getAge());  
   }

   public static void main(String[] args) {  
           jdk8_MethodReferencesVO[] refs = new jdk8_MethodReferencesVO[5];  
           jdk8_MethodReferencesVO vo1=new jdk8_MethodReferencesVO();  
           vo1.setAge(21);  
           vo1.setName("Frank");  
           refs[0]=vo1;  
           vo1=new jdk8_MethodReferencesVO();  
           vo1.setAge(22);  
           vo1.setName("Ibrahim");  
           refs[1]=vo1;  
           vo1=new jdk8_MethodReferencesVO();  
           vo1.setAge(24);  
           vo1.setName("Vinod");  
           refs[2]=vo1;  
           vo1=new jdk8_MethodReferencesVO();  
           vo1.setAge(19);  
           vo1.setName("Gurdeep");  
           refs[3]=vo1;  
           vo1=new jdk8_MethodReferencesVO();  
           vo1.setAge(25);  
           vo1.setName("Maxovitch");  
           refs[4]=vo1;  
           jdk8_MethodReferences refC = new jdk8_MethodReferences();  
           Arrays.sort(refs, refC::compareByAge);  
           for(jdk8_MethodReferencesVO rvo: refs) {  
                System.out.println(rvo.getAge()+":"+rvo.getName());  
           }  
      }  
 }  


Happy JDK 8ing!

Check out my GitHub page for the full code and more.

Ready Reference on DZone

  • Java SE 5

  • Java SE 6

  • Java SE 7

Java (programming language) Java EE Annotation

Published at DZone with permission of Sumith Puri. See the original article here.

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • Key Considerations When Implementing Virtual Kubernetes Clusters
  • How To Use Terraform to Provision an AWS EC2 Instance
  • Kotlin Is More Fun Than Java And This Is a Big Deal
  • The Future of Cloud Engineering Evolves

Comments

Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends: