Java Version and New Features 8 - 13

• Introduction

  • Introduction

    Java is widely used staticly typed programming language which is founded over 25 years back. It's almost everywhere from home appliances, mobile devices to industry scale systems. Java is evolving over the time and from Java 8 onwards there were major changes introduced to the language. Below are the list of all the changes on each version.

  • Imperative vs Declarative Programming

    Imperative approach is defining step by step on HOW we are going to achieve the end result. Declarative approach is describing WHAT we want as the output. Simple example would be a classical for loop in Java which we can call as imperative programming and a select query in sql as declarative programming. Still didn't get it? Following examples will help you to understand more
    
    

    Imperative Style in Java

    int sum = 0;

    for(int i=0; i<5; i++){

    sum +=i;

    System.out.print("sum is: "+sum);

    }

    
    

    Declarative Style in Java

    int sum = IntStream.of(1,2,3,4,5).sum();

    Declarative Style in SQL

    select * from table1 where a=1;

    
    
    
    Now you get the idea!
  • Course Breakdown

    [TO BE UPDATED]
  • Windows/Mac - Java Install

    [TO BE UPDATED]
  • Intelij Install

    [TO BE UPDATED]
  • Configurations

    [TO BE UPDATED]
  • Git repo link

    [TO BE UPDATED]
  • Dev Env Setup

    [TO BE UPDATED]
• Java 8 Features

  • Lambda Expressions

    • What is Lambda?

      A lambda expression is an anonymous function. It's a function without a name and does not belong to any class

      Lambda vs java method

      method in Java has three main parts
      -Name
      -Parameter List
      -Body
      -return type
      

      lambda expression in Java has three main parts
      -No name (since lambda is anonymous function)
      -Parameter List
      -Body
      -No return type (no return type required)

    • Lambda Expressions

      [TO BE UPDATED]
    • Runnable Example with Lambda

      [TO BE UPDATED]
    • Callable Example with Lambda

      [TO BE UPDATED]
  • Functional Interfaces and Lambdas

    • Functional Interfaces

      [TO BE UPDATED]
    • Consumer Functional Interfaces

      [TO BE UPDATED]
    • IntConsumer, LongConsumer, DoubleConsumer

      [TO BE UPDATED]
    • BiConsumer Functional Interface

      [TO BE UPDATED]
    • Predicate Functional Interface

      [TO BE UPDATED]
    • IntPredicate, LongPredicate, DoublePredicate

      [TO BE UPDATED]
    • Predicate & BiConsumer

      [TO BE UPDATED]
    • Function

      [TO BE UPDATED]
    • BiFunction

      [TO BE UPDATED]
    • Unary Operator

      [TO BE UPDATED]
    • Binary Operator

      [TO BE UPDATED]
    • Supplier

      [TO BE UPDATED]
    • Method Reference

      [TO BE UPDATED]
    • Constructor Reference

      [TO BE UPDATED]
  • Lambda Variable Scope

    • Variable scope, Final & Effectively Final

      [TO BE UPDATED]
  • Realworld Example Using Lambda

    • Bank Transfer Example

      [TO BE UPDATED]
  • Streams

    • Introduction

      [TO BE UPDATED]
    • Inside Streams

      [TO BE UPDATED]
    • Collections vs Streams

      [TO BE UPDATED]
    • Debugging Stream

      [TO BE UPDATED]
  • Stream Operations

    • map()

      [TO BE UPDATED]
    • flatMap()

      [TO BE UPDATED]
    • distinct(), count(), sorted(), allMatch(), anyMatch(), nonMatch()

      [TO BE UPDATED]
    • Customized sort using comparator

      [TO BE UPDATED]
    • filter()

      [TO BE UPDATED]
    • reduce()

      [TO BE UPDATED]
    • map() + filter() + reduce()

      [TO BE UPDATED]
    • min() with stream and reduce

      [TO BE UPDATED]
    • limit() and skip()

      [TO BE UPDATED]
    • findAny() and findfirst()

      [TO BE UPDATED]
  • Stream Generators

    • Generating Stream with of(), iterate(), generate()

      [TO BE UPDATED]
  • Numeric Streams

    • Introduction

      [TO BE UPDATED]
    • IntStream, LongStream, DoubleStream

      [TO BE UPDATED]
    • sum(), max(), min(), average()

      [TO BE UPDATED]
    • Boxing, Unboxing

      [TO BE UPDATED]
    • mapToObj(), mapToLong(), mapToDouble()

      [TO BE UPDATED]
  • Collectors Operations

    • joining()

      [TO BE UPDATED]
    • counting()

      [TO BE UPDATED]
    • mapping()

      [TO BE UPDATED]
    • minBy(), maxBy()

      [TO BE UPDATED]
    • summingint(), averageint()

      [TO BE UPDATED]
    • groupingBy

      [TO BE UPDATED]
    • maxBy(), minBy(), collectingAndThen(), summarizingint()

      [TO BE UPDATED]
    • partitioningBy()

      [TO BE UPDATED]
  • Parallel Streams

    • Introduction

      [TO BE UPDATED]
    • Sequential vs Parallel

      [TO BE UPDATED]
  • Optional

    • Introduction

      [TO BE UPDATED]
    • empty(), ofNullable(), of()

      [TO BE UPDATED]
    • orElse(), orElseGet(), orElseThrow()

      [TO BE UPDATED]
    • ifPresent(), isPresent()

      [TO BE UPDATED]
  • Default & State Methods of Interfaces

    • Introduction

      [TO BE UPDATED]
    • Default Methods

      [TO BE UPDATED]
    • Creating an Interface with Default/Static Methods

      [TO BE UPDATED]
    • Multiple Inheritance

      [TO BE UPDATED]
    • Conflicts in Multiple Inheritance

      [TO BE UPDATED]
  • New DateTime API

    • Introduction

      [TO BE UPDATED]
    • LocalDate - get and create

      [TO BE UPDATED]
    • LocalDate - modify

      [TO BE UPDATED]
    • LocalTime - get and create

      [TO BE UPDATED]
    • LocalTime - modify

      [TO BE UPDATED]
    • LocalDateTime - get, create and modify

      [TO BE UPDATED]
    • LocalDate and LocalTime from LocalDateTime

      [TO BE UPDATED]
    • Duration

      [TO BE UPDATED]
    • Instant

      [TO BE UPDATED]
    • TimeZones - ZonedDateTime, ZonedId

      [TO BE UPDATED]
    • LocalDateTime to ZonedDateTime

      [TO BE UPDATED]
    • Convert java.util.date & java.sql.date to LocalDateTime/LocalDate

      [TO BE UPDATED]
• Java 9 Features

  • Java Shell(REPL)

    • Introduction

      [TO BE UPDATED]
    • Java Environment Variable Setup

      [TO BE UPDATED]
    • Getting Started with JShell

      [TO BE UPDATED]
    • Snippet, List and Drop

      [TO BE UPDATED]
    • JShell Shortcuts

      [TO BE UPDATED]
    • Creating Classes

      [TO BE UPDATED]
    • InteliJ ID Shell

      [TO BE UPDATED]
  • Module System

    • Introduction

      [TO BE UPDATED]
    • Example

      [TO BE UPDATED]
    • Creating Module

      [TO BE UPDATED]
    • Modular Application and Maven

      [TO BE UPDATED]
  • Factory Methods for Collection

    • Collections Factory Methods

      [TO BE UPDATED]
  • Try-with-resources

    • Try-with-resources

      [TO BE UPDATED]
• Java 10 Features

  • Type Interferences with var

    • var type with Examples

      [TO BE UPDATED]
  • GCI Improvements

    • GC first algorithm Improvements

      [TO BE UPDATED]
• Java 11 Features

  • var with Lambda

    • Adding var to Lambda

      [TO BE UPDATED]
  • Epsilon GC

    • Epsilon GC

      [TO BE UPDATED]
  • New HttpClient

    • HttpClient API

      [TO BE UPDATED]
• Java 12 Features

  • Switch Expression

    • Switch Expression intro with Example

      [TO BE UPDATED]
    • Switch Expression with action in cases

      [TO BE UPDATED]
• Java 13 Features

  • Switch Expression Enhancements

    • Switch Expression with Yield

      [TO BE UPDATED]
  • TextBlocks

    • Multiline TextBlocks

      [TO BE UPDATED]

Java 5

Java 5 is known as the “Tiger” release since it released many of the key features many of the developers used today. Many interview questions are based on this version. Following are the key features introduced in Java 5

• Generics
• Annotations
• Autoboxing / Unboxing
• Typesafe Enums
• Varargs
• Foreach Loop
• Static Imports
• Scanner Class
• Assertions
• StringBuilder

Generics

What are Generics?
Java Generics are a language feature that allows for definition and use of generic types and methods. Didn’t get it?

Then Why Generics?
“In layman,s term, generics force type safety in java language and therefore add stability to your code by making more of your bugs detectable at compile time.” Thats the definition. Still not clear?

Ok Let’s see How it works!
Let’s assume you create an ArrayList that only works with Integers and you execute it with following values. As of following example it will give an error at runtime which is late to identify and error in a highly scaled dynamic application(I mean later when you are an expert ;))

List list = new ArrayList(); 
list.add(1000);     //works fine 
list.add("Gothama"); //run time error;

Let’s see how Generics solves the problem at compile time with following example.

List<Integer> list = new ArrayList<Integer>(); 
list.add(1000);     //works fine 
list.add("Gothama"); //compile time error;

What we do?
We simply add a type safety (i.e Generics) which will give and error at compile time which will save you lot of time. Ok, now you are clear.

Is it applicable for methods too?
Yes, methods can use Generics too. See following example.

public class GenericsMethodTest{

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }

   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }
}

Output:
Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

Wow isn’t it amazing? Now you know what are Generics and when to use them right?

So how about Classes? Does Generics apply to classes too?
Yes, It applies to classes too. Check following example

public class Box<T> {
   private T t;

   public void add(T t) {
      this.t = t;
   }

   public T get() {
      return t;
   }

   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
    
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d\n\n", integerBox.get());
      System.out.printf("String Value :%s\n", stringBox.get());
   }
}

Output:
Integer Value :10
String Value :Hello World

Now you know the basics of Generics…. Yay!

Annotations

What are annotations?
Annotations are meta data in Java.

What is meta data?
A metadata is data about data. Metadata adds some additional flags on your actual data, and in runtime either you or JVM who understand these flags, can utilize this metadata information to make appropriate decisions based on context.

How it looks like?
Basic annotation is look like following.
@MyAnnotation
It starts with @ sign followed by the Annotation name.
Annotations are defined as following.
@interface MyAnnotation { }

I didn’t get it…
Ok, Annotations do basically three things in Java. It provides….

1. Embed instructions to Java Compiler
2. Embed instructions to Source Code Processing Tools such as IDEs
3. Embed metadata which can be read at runtime by your Java Application or Third Party Tools

Lets look at some simple example
Below example shows how @Override annotation checks that the annotated method is overridden method.

public class DemoClass
{
   //some code
    
   @Override
   public String toString()
   {
      return super.toString();
   }
    
   @Override
   public int hashCode()
   {
      return super.hashCode();
   }
}

It causes a compile time “error” if the annotated method toString() is not found in one of the parent classes or implemented interfaces.
If someone deleted the method from parent class we now know in compilation instead of runtime.
Cool right?

Only this?
Noo, Implementations of Annotations are countless. Frameworks like Spring/Strut uses annotations to make sure we get a clean and quality output.
Java has built in Annotations which fulfills different instructions
@Override
@Deprecated
@SuppressWarnings
@SafeVarargs
@FunctionalInterface
You can always get the latest predefined Java annotations here.

So how to defined our own Custom Annotations?All Annotations must be defined with @interface keyword.
public @interface DemoAnnotation {}
And usage be as follows
@DemoAnnotation
public void toggle() {}

It’s complicated to me…
Ok, Let’s get a real world example from Spring framework.
Spring has an Annotation named @Lazy.

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Lazy {

 /**
  * Whether lazy initialization should occur.
  */
 boolean value() default true;

}

@Lazy
class VehicleFactoryConfig {
 
    @Lazy(false)
    Engine engine() {
        return new Engine();
    }
}

We can use the @Lazy when we want to initialize our bean lazily.
By default, Spring creates all singleton beans eagerly at the startup of the application context.
However, there are cases when we need to create a bean when we request it, but not at application startup.
In this case we can use @Lazy annotation to mark the fields that should/ should not initialize at startup.
By default @Lazy is marked as true. But if wanted we can make it false for specific method or a bean.
Easy as that….

Now you have a basic understanding of Annotations.
Let me know below if any questions. Cheers!

Autoboxing / Unboxing

What it is?
Even though the name includes boxing, this is all about wrapping and unwrapping primitive types with its corresponding wrapper class.

No Idea…
Ok, Following example will explain all.

// Java program to illustrate the concept 
// of Autoboxing and Unboxing 
import java.io.*; 
  
class Independor 
{ 
    public static void main (String[] args) 
    { 
        // creating an Integer Object (wrapper class of int)
        // with value 10. 
        Integer i = new Integer(10); 
  
        // unboxing the Object 
        int i1 = i; 
  
        System.out.println("Value of i: " + i); 
        System.out.println("Value of i1: " + i1); 
  
        //Autoboxing of char 
        Character gfg = 'a'; 
  
        // Auto-unboxing of Character (wrapper class of char)
        char ch = gfg; 
        System.out.println("Value of ch: " + ch); 
        System.out.println("Value of gfg: " + gfg); 
  
    } 
}

Following are the primitive types and its corresponding wrapper classes.

Why Autoboxing/Unboxing?

• Autoboxing and unboxing lets developers write cleaner code, making it easier to read.
• The technique let us use primitive types and Wrapper class objects interchangeably and we do not need to perform any typecasting explicitly.

That’s it… You got the idea right? It’s not a complicate subject to understand, but if you have any questions let me know below. Cheers!

Java Versions and New Features

What are new java features in java version 7 or 8? These are pretty much frequently asked questions in java interviews.

In this page, I listing down all JDK changes from JDK 1.x to Java SE 12, sequentially. Though I have tried to cover as much as information I can gather, though if you know something which I missed below, please let me know and I will add that information.

Java 12 Features

Java 12 (released on March 19, 2019) is latest version available for JDK. Let’s see the new features and improvements, it brings for developers and architects.

• Collectors.teeing() in Stream API
• String API Changes
• Files.mismatch(Path, Path)
• Compact Number Formatting
• Support for Unicode 11
• Switch Expressions (Preview)

Java 11 Features

Java 11 (released on September 2018) includes many important and useful updates. Let’s see the new features and improvements, it brings for developers and architects.

• HTTP Client API
• Launch Single-File Programs Without Compilation
• String API Changes
• Collection.toArray(IntFunction)
• Files.readString() and Files.writeString()
• Optional.isEmpty()

Java 10 Features

After Java 9 release, Java 10 came very quickly. Unlike it’s previous release, Java 10 does not have that many exciting features, still it has few important updates which will change the way you code, and other future Java versions.

• JEP 286: Local Variable Type Inference
• JEP 322: Time-Based Release Versioning
• JEP 304: Garbage-Collector Interface
• JEP 307: Parallel Full GC for G1
• JEP 316: Heap Allocation on Alternative Memory Devices
• JEP 296: Consolidate the JDK Forest into a Single Repository
• JEP 310: Application Class-Data Sharing
• JEP 314: Additional Unicode Language-Tag Extensions
• JEP 319: Root Certificates
• JEP 317: Experimental Java-Based JIT Compiler
• JEP 312: Thread-Local Handshakes
• JEP 313: Remove the Native-Header Generation Tool
• New Added APIs and Options
• Removed APIs and Options

Java 9 Features

Java 9 was made available on September, 2017. The biggest change is the modularization i.e. Java modules.

Some important features/changes in Java 9 are:

• Java platform module system
• Interface Private Methods
• HTTP 2 Client
• JShell – REPL Tool
• Platform and JVM Logging
• Process API Updates
• Collection API Updates
• Improvements in Stream API
• Multi-Release JAR Files
• @Deprecated Tag Changes
• Stack Walking
• Java Docs Updates
• Miscellaneous Other Features

Please see the updated release info here.

Java 8 Features

Release Date : March 18, 2014

Code name culture is dropped. Included features were:

• Lambda expression support in APIs
• Stream API
• Functional interface and default methods
• Optionals
• Nashorn – JavaScript runtime which allows developers to embed JavaScript code within applications
• Annotation on Java Types
• Unsigned Integer Arithmetic
• Repeating annotations
• New Date and Time API
• Statically-linked JNI libraries
• Launch JavaFX applications from jar files
• Remove the permanent generation from GC

Java SE 7 Features

Release Date : July 28, 2011

This release was called “Dolphin”. Included features were:

• JVM support for dynamic languages
• Compressed 64-bit pointers
• Strings in switch
• Automatic resource management in try-statement
• The diamond operator
• Simplified varargs method declaration
• Binary integer literals
• Underscores in numeric literals
• Improved exception handling
• ForkJoin Framework
• NIO 2.0 having support for multiple file systems, file metadata and symbolic links
• WatchService
• Timsort is used to sort collections and arrays of objects instead of merge sort
• APIs for the graphics features
• Support for new network protocols, including SCTP and Sockets Direct Protocol

Java SE 6 Features

Release Date : December 11, 2006

This release was called “Mustang”. Sun dropped the “.0” from the version number and version became Java SE 6. Included features were:

• Scripting Language Support
• Performance improvements
• JAX-WS
• JDBC 4.0
• Java Compiler API
• JAXB 2.0 and StAX parser
• Pluggable annotations
• New GC algorithms

J2SE 5.0 Features

Release Date : September 30, 2004

This release was called “Tiger”. Most of the features, which are asked in java interviews, were added in this release.

Version was also called 5.0 rather than 1.5. Included features are listed down below:

• Generics
• Annotations
• Autoboxing/unboxing
• Enumerations
• Varargs
• Enhanced for each loop
• Static imports
• New concurrency utilities in java.util.concurrent
• Scanner class for parsing data from various input streams and buffers.

J2SE 1.4 Features

Release Date : February 6, 2002

This release was called “Merlin”. Included features were:

• assert keyword
• Regular expressions
• Exception chaining
• Internet Protocol version 6 (IPv6) support
• New I/O; NIO
• Logging API
• Image I/O API
• Integrated XML parser and XSLT processor (JAXP)
• Integrated security and cryptography extensions (JCE, JSSE, JAAS)
• Java Web Start
• Preferences API (java.util.prefs)

J2SE 1.3 Features

Release Date : May 8, 2000

This release was called “Kestrel”. Included features were:

• HotSpot JVM
• Java Naming and Directory Interface (JNDI)
• Java Platform Debugger Architecture (JPDA)
• JavaSound
• Synthetic proxy classes

J2SE 1.2 Features

Release Date : December 8, 1998

This release was called “Playground”. This was a major release in terms of number of classes added (almost trippled the size). “J2SE” term was introduced to distinguish the code platform from J2EE and J2ME. Included features were:

• strictfp keyword
• Swing graphical API
• Sun’s JVM was equipped with a JIT compiler for the first time
• Java plug-in
• Collections framework

JDK 1 Features

Release Date : January 23, 1996

This was the initial release and was originally called Oak. This had very unstable APIs and one java web browser named WebRunner.

The first stable version, JDK 1.0.2, was called Java 1.

On February 19, 1997, JDK 1.1 was released havind a list of big features such as:

• AWT event model
• Inner classes
• JavaBeans
• JDBC
• RMI
• Reflection which supported Introspection only, no modification at runtime was possible.
• JIT (Just In Time) compiler for Windows

5 Things every front end developer must be aware about - short & sweet

Introduction

With advancement of technologies only knowing HTML, CSS, JQuery is not enough for a front end developer.

We have lot of tools and frameworks introduced to developers world that ease developers life as well as help to help make more reliable and bug free web applications.

Following are 10 things that every front-end developer should consider.


1. Frameworks

Frameworks are there to make developers life easy and to avoid some common problems developers face to start and continue a project.

Through a framework you can easily forget some common problems like browser compatibility, performance issues, since it is already addressed through the framework.
Level of already addressed problems may depend on framework to framework.

We have listed below best frameworks for front-end development which address most of the issues that front-end developers face.

React.js
Vue.js


2. GraphQL

While REST has long been consider the de facto standard for designing web APIs by offering great concepts like stateless servers, RESTful APIs are more and more considered inflexible when it comes to keeping up with the rapidly changing clients accessing them.
GraphQL was developed by Facebook to tackle the exact issues developers are facing when dealing with Restful APIs.
With REST APIs, developers would gather data by fetching it from multiple endpoints that have been created with a specific purpose — like, for example, a /users/<id> endpoint or a /tours/<id>/location endpoint.
Using GraphQL, this would work differently. Developers would send a query to a GraphQL server with their data requirements. The server would then return a JSON object with all the corresponding data.
Another benefit of using GraphQL is it uses a strong type system. Everything on the GraphQL server is defined via a schema using the GraphQL schema definition language (SDL). Once the schema has been created, both front-end and back-end developers can work quite independently from one another because they're aware of the defined data structure.
If you want to learn more about GraphQL, check out these great resources:
GraphQL


3. Code Editors/IDEs

Microsoft's VS Code will be the number one editor for most front-end engineers.
It offers almost IDE-like features, like code completion and highlighting, and can be extended almost infinitely via its extension marketplace.

The marketplace, in particular, is what makes VS Code so awesome. Here are some great extensions for you as a front-end developer:
JavaScript (ES6) code snippets
npm
Prettier
CSS Peek
Vetur
ESLint
Live Sass Compiler
Debugger for Chrome
Live Server
Beautify

Give it a try if you haven't used it already.


4. Testing

Testing is crucial.
Testing the app is the main thing when deliver to end user.
In real world applications money drives everything. Thus the untested code means the lose of money on the project.

Following flow of testing needs to be done before any project goes live

Unit tests

Testing a single component or function in isolation.

Integration tests

Testing interactions between components.

End-to-end test

Testing full-blown user flows in the browser.

There are more ways of testing, such as manual testing, snapshot testing, etc. If you want to move to a senior developer position or aim for a job with a large corporation that has some development standards, you should try to work on your testing skills.


5. Soft Skills

Even though soft skills are ignored much, following qualities needs to be in a front-end developer if a project needs to be success.
Even you are seasoned developer following qualities will make the project and every ones life easier.

Empathy
Communication
Teamwork
Easy approach and helpfulness
Patience
Open-mindedness
Problem-solving
Accountability
Creativity

Time management

Always remember: The most important deliverable for a senior developer is more senior developers :)