UNIT-III (BCS-403)
IT1- 4th Sem (2nd year),
Monalisa Panigrahi
1. Herbert Schildt, "Java The complete reference", McGraw Hill
Education
2. Steven Holzner, “Java Black Book”, Dreamtech.
3. Balagurusamy E, “Programming in Java”, McGraw Hill
4. Java: A Beginner’s Guide by Herbert Schildt, Oracle Press
Topics (Syllabus)
Java New Features
Functional Interfaces,
Lambda Expression,
Method References,
Stream API,
Default Methods,
Static Method,
Base64 Encode and Decode,
ForEach Method,
Try-with-resources,
Type Annotations, Repeating Annotations,
Java Module System,
Diamond Syntax with Inner Anonymous Class,
Local Variable Type Inference, Switch Expressions, Yield Keyword, Text Blocks,
Records, Sealed Classes
Lambda Expression
Lambda expression is a new and important feature of Java
which was included in Java SE 8.
It provides a clear and concise way to represent one method
interface using an expression.
The Lambda expression is used to provide the implementation
of an interface which has functional interface.
It saves a lot of code.
Why use Lambda Expression
To provide the implementation of Functional interface.
Less coding.
Java Lambda Expression
Syntax
(argument-list) -> {body}
Java lambda expression consists of three components.
1) Argument-list: It can be empty or non-empty as well.
2) Arrow-token: It is used to link arguments-list and
body of expression.
3) Body: It contains expressions and statements for
lambda expression.
No Parameter Syntax
1. () -> {
2. //Body of no parameter lambda
3. }
One Parameter Syntax
1. (p1) -> {
2. //Body of single parameter lambda
3. }
Two Parameter Syntax
1. (p1,p2) -> {
2. //Body of multiple parameter lambda
3. }
Lambda Expression Example:
No Parameter Syntax
public static void main()
{
System.out.print(“Hello”);
}
Lambda Expression :
() -> { System.out.print(“Hello”); }
() -> System.out.print(“Hello”);
Lambda Expression Example:
One Parameter Syntax
public int m1(String s)
{
return s.length ();
}
Lambda Expression :
(String s) -> { return s.length(); }
(String s) -> return s.length();
s -> s.length();
Lambda Expression Example:
Two Parameter Syntax
public void sum (int a, int b)
{
System.out.print (a+b);
}
Lambda Expression :
(int a, int b) -> { System.out.print(a+b); }
(int a, int b) -> System.out.print(a+b);
(a,b) -> System.out.print(a+b);
Functional Interfaces
Lambda expression provides implementation of functional
interface.
An interface which has only one abstract method is called
functional interface.
Java provides an anotation @FunctionalInterface, which is used to
declare an interface as functional interface.
A functional interface can have any number of default methods.
Functional interfaces are included in Java SE 8 with Lambda
expressions and Method references in order to make code more
readable, clean, and straightforward.
Functional Interfaces
Functional Interface is additionally recognized as Single
Abstract Method Interfaces.
In short, they are also known as SAM interfaces.
Functional interfaces in Java are the new feature that
provides users with the approach of fundamental
programming.
Without Lambda Expression
using only interface
1. interface Drawable{
2. public void draw();
3. }
4. public class LambdaExpressionExample {
5. public static void main(String[] args) {
6. int width=10;
7. //without lambda, Drawable implementation using anonymous class
8. Drawable d=new Drawable(){
9. public void draw(){System.out.println("Drawing "+width);}
10. };
11. d.draw();
12. }
13. }
With Lambda Expression and
Functional Interface
1. @FunctionalInterface //It is optional
2. interface Drawable{
3. public void draw();
4. }
5.
6. public class LambdaExpressionExample2 {
7. public static void main(String[] args) {
8. int width=10;
9.
10. //with lambda
11. Drawable d2=()->{
12. System.out.println("Drawing "+width);
13. };
14. d2.draw();
15. }
16. }
Java Method References
Method reference is used to refer method of functional
interface.
It is compact and easy form of lambda expression.
Each time when you are using lambda expression to just
referring a method, you can replace your lambda
expression with method reference.
Types of Method References
Reference to a static method.
Reference to an instance method.
Reference to a constructor.
Reference to a static method
ContainingClass::staticMethodName
@FunctionalInterface
interface Sayable{
void say();
}
public class MethodReference {
public static void saySomething(){
System.out.println("Hello, this is
static method.");
}
public static void main(String[] args) {
// Referring static method
Sayable sayable =
MethodReference::saySomething;
// Calling interface method
sayable.say();
}
}
Reference to an Instance
Method containingObject::instanceMethodName
@FunctionalInterface
interface Sayable{
void say();
public class MethodRef1 {
public void saySomething(){
System.out.println("Hello, this is non-static method.");
public static void main(String[] args) {
MethodRef1 methodReference = new MethodRef1(); // Creating object
// Referring non-static method using reference
Sayable sayable = methodReference::saySomething;
// Calling interface method
sayable.say();
// Referring non-static method using anonymous object
Sayable sayable2 = new MethodRef1()::saySomething; // You can use anonymous object also
// Calling interface method
sayable2.say();
Reference to a Constructor
interface Messageable{
Message getMessage(String msg);
}
class Message{
Message(String msg){
System.out.print(msg);
}
}
public class ConstructorReference {
public static void main(String[] args) {
Messageable hello = Message::new;
hello.getMessage("Hello");
}
}
ClassName::new
Stream API
Java provides a new additional package in Java 8 called
java.util.stream.
This package consists of classes, interfaces to allows
functional-style operations on the elements.
You can use stream by importing java.util.stream
package.
You can use stream to filter, collect, print, and convert from
one data structure to other etc.
Default Method
Java provides a facility to create default methods inside
the interface.
Methods which are defined inside the interface and
tagged with default are known as default methods.
These methods are non-abstract methods.
Static Methods
Static methods are used to define
utility methods and can be
accessed in the program by only
using the class name.
Base64 Encode and Decode
Java provides a class Base64 to deal with encryption.
You can encrypt and decrypt your data by using
provided methods.
Basic Encoding and Decoding
It uses the Base64 alphabet specified by Java in RFC
4648 and RFC 2045 for encoding and decoding
operations.
The encoder does not add any line separator character.
The decoder rejects data that contains characters
outside the base64 alphabet.
URL and Filename Encoding
and Decoding
It uses the Base64 alphabet specified by Java in RFC
4648 for encoding and decoding operations.
The encoder does not add any line separator character.
The decoder rejects data that contains characters
outside the base64 alphabet.
MIME
It uses the Base64 alphabet as specified in RFC 2045 for
encoding and decoding operations.
The encoded output must be represented in lines of no
more than 76 characters each and uses a carriage return
'\r' followed immediately by a linefeed '\n' as the line
separator.
No line separator is added to the end of the encoded
output.
All line separators or other characters not found in the
base64 alphabet table are ignored in decoding
operation.
ForEach Method
Java provides a new method forEach() to iterate the
elements.
It is defined in Iterable and Stream interface.
It is a default method defined in the Iterable interface.
Collection classes which extends Iterable interface can
use forEach loop to iterate elements.
This method takes a single parameter which is a
functional interface. So, you can pass lambda
expression as an argument.
Java Module System
Java Module System is a major change in Java 9 version.
Java added this feature to collect Java packages and
code into a single unit called module.
Module is a collection of Java programs or softwares. To
describe a module, a Java file module-info.java is
required. This file also known as module descriptor and
defines the following
Module name
What does it export
What does it require
How to create Java module
Creating Java module required the following steps.
Create a directory structure
Create a module declarator
Java source code
Diamond Syntax with Inner
Anonymous Class
Diamond Syntax
Inner Anonymous Class
Diamond Operator : < >
Diamond operator was introduced in Java 7 as
a new feature.
List<String> Address = new ArrayList<>();
This line declares and initializes a variable for
storing a list of strings.
Anonymous Inner Class
It is an inner class without a name and for which only a
single object is created.
// Java program to demonstrate Need for
// Anonymous Inner class
// Interface
interface Age {
// Defining variables and methods
int x = 21;
void getAge();
}
// Class 1
// Helper class implementing methods of Age Interface
class MyClass implements Age {
// Overriding getAge() method
@Override public void getAge()
{
// Print statement
System.out.print("Age is " + x);
}
}
// Class 2
// Main class
// AnonymousDemo
class Example {
// Main driver method
public static void main(String[] args)
{
// Class 1 is implementation class of Age interface
MyClass obj = new MyClass();
obj.getAge();
}
}
Local Variable Type Inference
Local Variable Type Inference is one of the most
evident change to language available from Java
10 onwards.
It allows to define a variable using var and
without specifying the type of it.
The compiler infers the type of the variable using
the value provided.
Old style
String name = "Welcome to tutorialspoint.com";
New Style
var name = "Welcome to tutorialspoint.com";
Switch Expressions
Yield Keyword
A new keyword yield has been
introduced in Java 13.
It returns values from a switch
branch only.
Text Blocks
Introduced in Java 15 to declare
multi-line strings easily.
Text blocks begin with a “”” (3
double-quote marks) observed
through whitespaces and a newline.
Records
Records are known as the data structure to store the
fixed number of elements. (Java 14)
Without Records
public class Person {
private final String name;
private final int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
With Records
public record Person(String name, int age)
{ }
Sealed Classes
Java 15 introduced the concept of sealed classes.
It is a preview feature, not a permanent feature.
Java sealed classes and interfaces restrict that which
classes and interfaces may extend or implement them.
Define the class that you want to make a seal.
Add the “sealed” keyword to the class and specify
which classes are permitted to inherit it by using the
“permits” keyword.
Annotations
Annotation is type of comment which is used to provide meta
data to the compiler and JVM about the program.
annotation is used to provide meta data to the compiler and JVM
about the program but comment is used to provide information
to the programmer.
Annotations are used to provide supplemental information about
a program.
Annotations start with ‘@’.
Annotations do not change the action of a compiled program.
Type and Repeating Annotations
Introduced as new features in Java 8.
Type Annotations means that annotations can be used
anywhere you use a type.
Ex: if you want to avoid NullPointerException in your code,
you can declare a string variable
@NonNull String str;
Repeating Annotations
It is helpful when you want to reuse annotation for the same
class.
Try-with-resources
In Java, the try-with-resources statement is a try
statement that declares one or more resources.
The resource is as an object that must be closed after
finishing the program.
The try-with-resources statement ensures that each
resource is closed at the end of the statement
execution.
Features HashSet LinkedHashSet TreeSet
LinkedHashSet
HashSet
uses TreeSet uses TreeMap
Internal internally uses
LinkedHashMap internally to store
Working HashMap for
internally to store objects
storing objects
objects
If you don’t
If you want to
want to
maintain the If you want to sort the
maintain
When To insertion order of elements according to
insertion order
Use elements then you some Comparator then
but want to
can use use TreeSet
store unique
LinkedHashSet
objects
While TreeSet orders
the elements according
LinkedHashSet to supplied
HashSet does
maintains the Comparator. By
Order not maintain
insertion order of default, objects will be
insertion order
objects placed according to
their natural ascending
order.
LinkedHashSet
HashSet gives While TreeSet gives
gives insertion,
O(1) complexity the performance of
Complexity removing, and
for insertion, order O(log(n)) for
of retrieving
removing, and insertion, removing,
Operations operations
retrieving and retrieving
performance in
objects operations.
order O(1).
The The performance of TreeSet performance is
performance of LinkedHashSet is better than
HashSet is slower than LinkedHashSet except
Performance better when TreeSet. It is for insertion and
compared to almost similar to removal operations
LinkedHashSet HashSet but slower because it has to sort
and TreeSet. because the elements after each
LinkedHashSet insertion and removal
