InstanceOfJava

Program Check even or odd without using modulus and division operators

Posted by: Instanceofjava Posted date: 2:49 PM / comment : 9 Java Programs

write a progrma to check number is even or odd without using modulus or divition

Checking the number even or odd program is very easy. Anybody can solve this but there is a condition we need to see.
When we get this question in interview "write a program to check given number is even or odd" always continues with "without using modulus and division operators".
Before going to actual program lets see how to check a number is even or odd by using modulus and division operators.

Program to check number is even or odd by using modulus "%" operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
public static void main(String []args ) {
int number;
Scanner in= new Scanner(System.in);
System.out.println("Enter a number to check even or odd");
number=in.nextInt();
if((number % 2)==0){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
37
37 is Odd Number

Program to check number is even or odd by using division "/" operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
public static void main(String []args ) {
int number;
Scanner in= new Scanner(System.in);
System.out.println("Enter a number to check even or odd");
number=in.nextInt();
if((number / 2)*2==number){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
46
46 is Even Number

Without using modulus and division operators:

The above two programs will check number is even or odd and displays result.
Now we need to write a program to check even or odd without using modulus and division operators.
It is very simple if you know about operators including "BIT WISE".
Yes using Bit Wise AND "&" operator we can check a number is even or odd.
Before starting our program lets see how this bit wise AND "&" operator will work.

Bitwise Operators :

Bit wise operators will work on bits at a time.
AND : 1 & 1=1
OR : 0 | 1= 1 , 1 | 0=1 , 1| 1= 1
XOR: 0 ^ 1= 1 , 1^ 0=1
NOT : !0=1

Take two number 2 and 3
010 : 2
011 : 3
------
010 : 2
------
Take two numbers 2 and 1
010 :2
001 :1
-----
000 :0
-----

From above example we can say that on every even number & 1 gives 0.
So this is our logic to be implemented in our program if "Number & 1==0" then its even number.

Program to check number is even or odd by using "&" operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
public static void main(String []args ) {
int number;
Scanner in= new Scanner(System.in);
System.out.println("Enter a number to check even or odd");
number=in.nextInt();
if((number & 1)==0){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
9
9 is Odd Number

Using Shift Operators:

We can check even or odd by using shift operators also may be it is not a better solution but trying to cover alternative.
Lets see how shift operators will work
Lets do this 2 >> 1
2 means 010 so now we need to shift right side by 1 place
010
-----
001
Here we added one "0" to the left side to shift right
So the value became 1
Now will try left shift 001 >> 1
001
----
010
010<<1=001(1) and 001 >> 001=010(2)
By this we can say if a (number >>1)<<1 gives same then that is even number. result=input
Lets check for odd number 3
011>>1=001 which is 1 and 001<<1=010 which is 2 so (3>>1)>>1=2 so result!=input

Program to check number is even or odd by using Shift operator

package instanceofjava;
import java.util.Scanner;
public class EvenorOdd {
public static void main(String []args ) {
int number;
Scanner in= new Scanner(System.in);
System.out.println("Enter a number to check even or odd");
number=in.nextInt();
if( ( number >> 1) <<1==number){
System.out.println(+number+" is Even number");
}else{
System.out.println(+number+" is Odd Number");
}
}
}

Output:

Enter a number to check even or odd
64
64 is Even Number

Here is the another solution for this.

package instanceofjava;
import java.util.Scanner;
class EvenOrOddDemo
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number to check whether it is even or odd without using Modulus
and Division: ");
int n=Integer.parseInt(sc.next());
float f=(float)n/(float)2;
int d=(int)f*2;
if(d==n)
System.out.println(n+" is a even number");
else
System.out.println(n+" is a odd number");
}
}

Output:

Enter a number to check whether it is even or odd without using Modulus and Division
4
4 is Even Number

ObjectInputStream and ObjectOutputStream

Posted by: Instanceofjava Posted date: 6:13 PM / comment : 0 Java SE

ObjectInputStream and ObjectOutputStream classes are used to store objects state permanently in files or to send to remote computer via network.
ObjectOutputStream class is subclass of ObjectOutput interface. It implements below method to write object to underline output stream.

public void writeObject(Object ob)throws IOException

ObjectInputStream class is a subclass of ObjectInput interface. It implements below method to read object to underline output stream.

public Object readObject() throws IOException

Rule:

To write or send object to external world it must be java.io.Serializable interface type.
It means this objects class must be a sub class of java.io.Serializable interface, else write() method throws java.io.NotSerializableException.

Constructors to create above two classes objects:

Like DataInputStream and DataOutputStream , ObjectInputStream and ObjectOutputStream are also can not connect to source and destination directly. So their constructors take other input and output stream class objects.

public ObjectInputStream(InputStream in)
public ObjectOutputStream(OutputStream out)

package instanceofjava;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class SerDemo implements Serializable {
String name;
String phonum;
String address;
int pin;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhonum() {
return phonum;
}
public void setPhonum(String phonum) {
this.phonum = phonum;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getPin() {
return pin;
}
public void setPin(int pin) {
this.pin = pin;
}
public static void main(String[] args)throws Exception{
SerDemo empobj= new SerDemo();
empobj.setName("sai");
empobj.setAddress("xxx, xxxstreet ");
empobj.setPhonum("040-9999999");
empobj.setPin(500072);
ObjectOutputStream oos= new ObjectOutputStream(new
FileOutputStream("E:\\employee.ser"));
oos.writeObject(empobj);
}
}

package instanceofjava;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class DeserDemo {
public static void main(String[] args)throws Exception{
ObjectInputStream ois= new ObjectInputStream(new FileInputStream("E:\\employee.ser"));
SerDemo obj= (SerDemo)ois.readObject();
System.out.println(obj.getAddress()):
}
}

Output:

sai
xxx, xxxstreet
500072
040-9999999

This is the actual functionality of ObjectOutputStream and ObjectInputStream: Serialization and deserialization

Serialization:

Serialization is the process of converting objects into stream of bytes and sending them to underlying output stream.
Using serialization we can store object state permanently in a destination , for example on remote computer.
Serialization operation performed by the writeObject() method of ObjectOutputStream.

Deserialization:

Deserialization is the process of converting stream of bytes into original object.
Deserialization operation is performed by readObject() of ObjectInputStream.

Rule:

Only java.io.serializable type objects are serialized. Serializable is a marker interface, it does not have any methods.
It provides special permission or identity to JVM to serialize Object.
If the given object is not of type serializable interface then writeObject() will throw an unchecked exception called java.io.NotSerializableException.

DataInputStream and DataOutPutStream

Posted by: Instanceofjava Posted date: 1:22 PM / comment : 0 Java SE

These classes are used to read and write data as primitive type from the underlying InputStreams and Output Streams.
DataInputStream and DataOutputStream classes have special methods to perform reading and writing operations as primitive data.

DataInputStream:

DataInputStream is a sub class of FilterInputStream and DataInput Interface.
It implements below methods from the DataInput interface for reading bytes from a binary stream and convert them in to corresponding java primitive type.

DataInputStream methods:

public byte readByte()
public short readShort()
public int readInt()
public long readLong()
public float readFloat()
public double readDouble()
public char readChar()
public boolean readBoolean()
public String readUTF()
public String readLine()

DataOutPutStream:

DataOutputStream class is a subclass of FilterOutputStream and DataOutput interface.
It implements below methods from DataOutput interface for converting data of any java primitive types to a stream of bytes and writing these bytes to a binary stream.

DataOutPutStream Methods:

public void writeByte(byte b)
public void writeShort(short s)
public void writeInt(int i)
public void writeLong(long l)
public void writeFloat(float f)
public void writeDouble(double d)
public void writeChar(char ch)
public void writeBoolean(boolean b)
public void writeUTF(String s)
public void writeBytes(String s)

To read data as primitive types using above readXxx() methods , the data must be written to the file as primitive types using writeXxx() methods.
readXxx() methods must be called in the same order in which the writeXxx() methods are called otherwise wrong value will be returned or EOFException will occur.

Program to Write data as primitive type using DataInputStream

package instanceofjava;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
public class DOSDemo {
public static void main(String [] args) throws Exception{
FileOutputStream fos= new FileOutputStream("data.txt");
DataOutputStream dos = new DataOutputStream(fos);
dos.writeInt(37);
dos.writeFloat(2.15f);
dos.writeChar('c');
dos.writeBoolean(true);
dos.writeUTF("instance of java");
}
}

After compilation and execution in current working directory you can find the "data.txt".
Check data.txt file size.
To check file size "right click on the file"-> click on properties
You will get size = size of all primitive data types mentioned in program check it.
From this program we can prove boolean takes 1 byte, the minimum memory location size in java is 1 byte.
For string data including double quotes JVM provides 1 byte for each character.

Program to Read data as primitive type using DataOutputStream

package instanceofjava;
import java.io.DataInputStream;
import java.io.FileInputStream;
public class DISDemo {
public static void main(String [] args) throws Exception{
FileInputStream fis= new FileInputStream("D:\\data.txt");
DataInputStream dis = new DataInputStream(fis);
int i= dis.readInt();
float f=dis.readFloat();
char ch=dis.readChar();
boolean b=dis.readBoolean();
String str= dis.readUTF();
System.out.println(i);
System.out.println(f);
System.out.println(ch);
System.out.println(b);
System.out.println(str);
}
}

Execute the above application by changing readXxx() methods calling order.
Then check you will get right value or not.
Actually readXxx() method read number of bytes from the file based on the data type.
For example if we call readInt() method it read 4 bytes from file.
So if our bytes are available in file program executed fine, execution terminates with EOFException.

Limitations in DataInputStream and DataOutputStream:

Using DataInputStream and DataOutputstream we can not read and write objects from persistence media.
They have only capability to read data up to only primitive data types.

Solution:

To read and write objects we must use ObjectInputStream and ObjectOutputStream.

JSP Implicit Objects

Posted by: Instanceofjava Posted date: 6:17 PM / comment : 0 Java EE , Jsp

Implicit objects in jsp are the objects that are created by the container automatically and the container makes all these 9 implicit objects to the developer.
We do not need to create them explicitly, since these objects are created and automatically by container and are accessed using standard variables(objects) are called implicit objects.
The following are of implicit variables available in the JSP.

1.out
2.request
3.response
4.config
5.application
6.session
7.pagecontext
8.page
9.exception

1.out:

out is one the implicit object to write the data to the buffer and send output to the client in response.
out object allows us to access the servlets output stream and has a pagescope.
out.print("");
out is the object of javax.servlet.jsp.JspWriter class.
While working with servlet we need printWriter object
PrintWriter out=response.getWriter();
In servlet we are used PrintWriter to send the output to the client. In JSP we use JSPWriter.

Difference between JspWriter and PrintWriter:

Every JSPWriter is associated with 8KB of internal Buffer. Where as PrintWriter doesn’t associated with any Buffer.
The methods of the JspWriter class are designed to throw java.io.IOException where as the methods of PrintWriter class are not throw Exception.
JspWriter is an abstract class present in javax.servlet package.
PrintWriter is a class defined in java.io package.

public class PrintWriter extends Writer {
// .....
}
public abstract class JspWriter extends Writer {
//....
}

JspWriter out object in jsp:

<html>
<body>
<%
int a = 10;
int b = 20;
out.print(“A value is:”+a);
out.write(“B value is:”+b);
%>
</body>
</html>

Printwriter object in servlet:

PrintWriter out=response.getWriter();

2.request:

request implicit object is the object of type HttpServletRequest.
request object will be created by the container for every request.
It will be used to get request information like parameter , header information ,server name server port etc.
By using request object we can able to set ,get and remove attributes from request scope.
It uses the getPareameter() method to access request parameter.
The container passes this object to the _jspService() method.

<form action="welcome.jsp">
<input type="text" name="username">
<input type="submit" value="submit"><br/>
</form>

<%
String name=request.getParameter("userid");
out.print("welcome "+name);
%>

out.println(request.getMethod()+”<br>”);
out.println(request.getRequestURI()+”<br>”);
out.println(request.getProtocol()+”<br>”);
out.println(request.getHeader(“User Agent”)+”<br>”);
out.println(request.getHeader(“Accept-language”)+”<br>”);

3.response:

response is an instance of class which implements the HttpServletResponse interface.
Container generates this object and passes to the _jspService() method as parameter.
response object will be created by the container for each request.
It represents the response that to be given to the client.
The response implicit object is used to content type, add cookie and redirect the response to another resource.

1.set content type.

response.setContextType(“text/xml”);
out.println(“<employee>”);
out.println(“<eno>|</eno>”);
out.println(“</employee>”);

2.Redirect response:

<%
response.sendRedirect("http://www.instanceofjava.com");
%>

3. To send the error message directly to the client:

<% response.sendError(537,”xyz”); %>

4.config

config is one of the implicit object of type javax.servlet.ServletConfig.
config object is created by the web container for each jsp page.
config object used to get initialization parameters from web.xml file.

<web-app>
<servlet>
<servlet-name>instanceofjava</servlet-name>
<jsp-file>/welcome.jsp</jsp-file>
<init-param>
<param-name>dname</param-name>
<param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>instanceofjava</servlet-name>
<url-pattern>/welcome</url-pattern>
</servlet-mapping>
</web-app>

<%
String driver=config.getInitParameter("dname");
out.print("driver name="+driver);
%>

servletConfig is an object used by servlet container to pass the information during initialization.
Once if we get the ServletConfig object, we can find the name of the servlet which is configured in web.xml file by using a method getServletName() method.

<%
String name = config.getServletName();
oput.println(name);
%>

5.application:

application is one of the implicit object of type javax.servlet.ServletContext.
application object is created by the web container one per application when the application gets deployed.
application object used to get context parameters from web.xml file.
ServletContext object contains set of methods which are used to interact with ServletContainer. By using these methods we can find the information about ServletContainer.
When ever sun micro system releases a new version of API. It is the responsibility of server vender to provide the implementation to the latest API.
For example when servlet 2.5 is released Tomcat guys has provided the implementation and integrated it in Tomcat 6.0 the latest version of servlet API is 3.0 this version is integrated in Tomcat 7.0.

<web-app>
<servlet>
<servlet-name>instanceofjava</servlet-name>
<jsp-file>/index.jsp</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>instanceofjava</servlet-name>
<url-pattern>/index</url-pattern>
</servlet-mapping>
<context-param>
<param-name>dname</param-name>
<param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>
</context-param>
</web-app>

<%
String driver=application.getInitParameter("dname");
out.print("driver name="+driver);
%>

6.session

session implicit object is holding HttpSession object.
session object used to set, get, and remove attributes to the session scope and also used to get session information.

index.html

<html>
<body>
<form action="/welcome">
<input type="text" name="uname">
<input type="submit" value="submit"><br/>
</form>
</body>
</html>

welcome.jsp

<html>
<body>
<%
String name=request.getParameter("uname");
out.print("Welcome "+name);
session.setAttribute("user",name);
<a href="showuserinfo.jsp">showuser details</a>
%>
</body>
</html>

showuserinfo.jsp

<html>
<body>
<%
String name=(String)session.getAttribute("user");
out.print("Hello "+name);
%>
</body>
</html>
%>

7.pagecontext:

pagecontext implicit object is type of PageContext.
pagecontext object used to set , get and remove attributes in particular scope

page scope
request scope
session scope
application scope

pageContext.setAttribute("user",name,PageContext.SESSION_SCOPE);
String name=(String)pageContext.getAttribute("user",PageContext.SESSION_SCOPE);

8.page

Page implicit variable hold the currently executes Servlet object for the corresponding JSP.
Acts as this object for current jsp page

<%=page.getClass().getName() %>
<%=page.getServlestInfo()%>

9.exception

The implicit variable can be used only in Error pages. When we try to use this variable in a JSP which is not an Error page we get an Error message.

<%@ page isErrorPage="true" %>
<html>
<body>
<%= exception %>
</body>
</html>

Java 8 Interface Static and Default Methods

Posted by: Instanceofjava Posted date: 6:05 PM / comment : 2 Java 8 , Java SE

Java 8 introduced two new methods in interface they are
1.default methods
2.static methods
By this interfaces and abstract class are same but still having lot differences like abstract class can have a constructor etc will discuss more before that we need to know about these Java 8 features of interfaces.
Defaults methods are also called as defender methods can be implemented inside the interface
Like normal class now with java 8 we can declare static methods in side a interface.
Lets jump deep into Java 8 default and static methods

1.Interface Default Methods in Java 8

Before Java 8 in interfaces we can and able to declare only abstract methods only.
If we declare a method without abstract that will be treated as abstract by default.
As we know all methods in interfaces are by default abstract methods.
These methods wont have body means implementations
The class which is implementing this interface need to provide body / implementation for this abstract methods.
Now with java 8 default methods we can add methods to interface without disturbing existing functionality.
So instead of overriding now we can inherit these default methods from interfaces

Defaults methods are also known as defender methods or virtual extension methods
Default methods will help us to avoid utility classes.
We can define utility methods inside the interface and use it in all classes which is implementing.
One of the major reason to introduce this default methods in java 8 is to support lambda expressions in collections API and to enhance.

package com.instanceofjava;
interface Java8Interface{
abstract void show();
default void display(){
System.out.println("default method of interface");
}
}

package com.instanceofjava;
class Sample implements Java8Interface {
void show(){
System.out.print("overridden method ")
}
public static void main(String[] args){
Sample obj= new Sample();
obj.show(); // calling implemented method
obj.display(); // calling inherited method
Java8Interface.display(); calling using interface name
}
}

Output:

overridden method
default method of interface
default method of interface

How to call default methods:

We can all these default methods by using interface name and also by using object of the class which is implementing.
From above example
obj.show(); // calling implemented method
obj.display(); // calling inherited method
Java8Interface.display(); calling using interface name

Can we override java 8 default method

As we discussed above default methods in interfaces are implemented methods with bodies
Yes we can override same method in class which is implementing this interface.
Lets see one sample program how to override and what happens if we override

package com.instanceofjava;
interface InterfaceWithDefault{
default void defMethod(){
System.out.println("default method of interface");
}
}

package com.instanceofjava;
class Demo implements InterfaceWithDefault{
void defMethod(){
System.out.print("overridden method in class Demo ")
}
public static void main(String[] args){
Demo obj= new Demo();
obj.defMethod(); // calling overridden method
Java8Interface.defMethod(); calling using interface name : interface defMethod will be called
}
}

Output:

overridden method in class Demo
default method of interface

What happens if we implement two interfaces having same default methods

Now lets see if a class implementing two interfaces which are having same default methods
Whatever the implementation in the two interfaces defined if we implementing two interfaces which are having a default method in both then compilation error will come if two methods have same signature. works fine if two methods have same name with different arguments.
Check the below example programs to understand more.

package com.instanceofjava;
interface A{
default void defMethod(){
System.out.println("default method of interface: A");
}
}

package com.instanceofjava;
interface B{
default void defMethod(){
System.out.println("default method of interface: B");
}
}

package com.instanceofjava;
class Demo implements A, B{ // compilation error will come
public static void main(String[] args){
Demo obj= new Demo();
}
}

If we implement two interfaces which are having same method with same parameters then compilation error will occur.
Duplicate default methods named "defMethod" with the parameters () and () are inherited from the types A and B.
If we define two methods with different type of parameters then we can work with both interfaces.

package com.instanceofjava;
interface A{
default void defMethod(){
System.out.println("Default method of interface: A");
}
}

package com.instanceofjava;
interface B{
default void defMethod(String str){
System.out.println("Default method of interface: B");
System.out.println(str);
}
}

package com.instanceofjava;
class Demo implements A, B{ // compilation error will come
public static void main(String[] args){
Demo obj= new Demo();
obj.defMethod();
obj.defMethod("Java 8")
}
}

Output:

Default method of interface: A
Default method of interface: B
Java 8

1.Interface Static Methods in Java 8

Another Java 8 interface method is static method.
Now we can define static methods inside interface but we can not override these static methods.
These static method will act as helper methods.
These methods are the parts of interface not belongs to implementation class objects.

package com.instanceofjava;
interface StaticInterface{
Static void print(String str){
System.out.println("Static method of interface:"+str);
}
}

package com.instanceofjava;
class Demo implements StaticInterface{
public static void main(String[] args){
StaticInterface.print("Java 8")
}
}

Output:

Static method of interface: Java 8

8 New Java 8 Features

Posted by: Instanceofjava Posted date: 3:49 PM / comment : 1 Java 8 , Java SE

Default and Static methods in Interface
Lambda Expressions
Optional
Streams
Method References
Data Time API
Nashorn Javascript Engine
Parallel Arrays

1.Default and Static methods in Interface :

Java 8 introduces new features to interfaces.
Before java 8 interface having only abstract methods but now java 8 added two more type of methods to interface !.
First one is default method. A method which is having a default keyword with method body.
Actually interfaces wont have any implemented methods but now with java 8 default method we can add a method with default implementation by using "default " keyword.
The classes which are implementing this interface can use these default method and same time it can override the existing method. But its not mandatory to override.

package com.instanceofjava;
interface Java8InterfaceDemo{
abstract void add();
default void display(){
System.out.println("default method of interface");
}
}

The second new method introduced in java 8 is static method.
Yes like in classes now we can define a static methods inside interface by using "static".
Basically static methods which are defined in interface are interface level only. if we want to call these static methods which are defined in interfaces we need to use interface name so that we can access these methods.

package com.instanceofjava;
interface Java8InterfaceDemo{
abstract void add();
default void display(){
System.out.println("default method of interface");
}
public static void show(){
System.out.println("static method of interface");
}
}

2.Lambda Expressions

One of the most awaited and biggest release in java 8 is lamda expressions.
Ability to pass functionality/ behavior to methods as arguments.
Allows us to write a method in the same place we are going to use it.

package com.instanceofjava;
interface JavalamdaExpression{
public static void main(String[] args){
Arrays.asList( "j", "a", "v" ,"a","8").forEach( e -> System.out.print( e ) );
// java8
}
}

3.java.util.Optional:

One of the best and cool feature of java 8 is Optional class. Which is a final calls from java.util package.
The major repeating statement in every project is checking "NullPointerException". Before using any object we need to check whether it is null or not if its not null then only we need to proceed.
Optional is just like a container which holds a value of type <T> or "null". By using isPresent() method of Optional class we can check particular object is null not not.

package com.instanceofjava;
import java.util.Optional:
class Java8OptionalDemo{
public static void main(String[] args ){
Optional< String > str = Optional.ofNullable( null );
System.out.println( "str having value ? " + str.isPresent() ); // output : str having value ? false
}
}

4.Streams:

One of the excellent feature from java 8 as java.util.stream.
Stream API introduces real-world functional-style programming into the Java.
Provides functional operations on stream of elements such as list , set and map
Supports filtering, mapping and removal of duplicates of elements in collections, are implemented lazily.
Now we can get Streams from collections, arrays and bufferedReaders etc.

package com.instanceofjava;
import java.util.Arrays;
class Java8StreamsDemo{
public static void main(String[] args ){
Arrays.stream(new int[] {1, 2, 3,4,5})
.map(n -> 2 * n + 1)
.average()
.ifPresent(System.out::println); // output: 7.0
}
}

5.Method Reference:

We can use lambda expressions to create anonymous methods.
Sometimes, however, a lambda expression does nothing but call an existing method.
In those cases, it's often clearer to refer to the existing method by name.
Using Method references refer to the existing method by name, they are compact, easy-to-read lambda expressions for methods that already have a name

package com.instanceofjava;
import java.util.Arrays;
class Java8MethodRef{
public void show(String str){
System.out.println(str);
}
public static void main(String[] args ){
Arrays.asList("a", "b", "c").forEach(new A()::show); // a b c
}
}

6.Data Time API

The next cool feature from java 8 is new date time API(jsr 310) added within java.time package.
Before java 8 if we want to format dates we use SimpleDateFormatter class in java 8 while declaring date itself it has constructor to pass format of date.
Some of the new classes introduced in java 8 date time are as follows.

LocalTime
LocalDate
LocalDateTime
OffsetDate
OffsetTime
OffsetDateTime

package com.instanceofjava;
import java.util.Arrays;
class Java8DateTimeAPI{
public static void main(String[] args ){
LocalDate currentDate = LocalDate.now();
System.out.println(currentDate);
LocalDate twentyMarch2015 = LocalDate.of(2015, Month.MARCH, 06);
System.out.println(twentyMarch2015); //2015-03-06
LocalDate firstApril2015 = LocalDate.of(2015, 4, 1);
System.out.println(firstApril2015);//2015-04-01
}
}

7.Nashorn Javascript Engine

Java 8 come with new Nashorn Javascript Engine which is allowing us to develop and run JavaScript applications.

package com.instanceofjava;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.Arrays;
class Java8JavaScript{
public static void main(String[] args ){
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName( "JavaScript" );
System.out.println( engine.getClass().getName() );
System.out.println( "output:" + engine.eval( "function show() { return 10; }; show();" ) );
}
}

jdk.nashorn.api.scripting.NashornScriptEngine
output:10

8.Parallel Array Sorting

As of now java 7 we already having Arrays.sort() method to sort objects now java 8 introduced parallel sorting which has more speed than arrays.sort() and follows Fork/Join framework introduced in Java 7 to assign the sorting tasks to multiple threads that are available in the thread pool.
Java 8 added parallel sorting functionalities to java.util.Arrays to take advantage of multithread machines

package com.instanceofjava;
import java.util.Arrays;
class Java8JavaScript{
public static void main(String[] args ){
int arr[]={1,4,2,8,5};
Arrays.parallelSort(arr);
for(int i:arr){
System.out.println(i);
}
}
}