Expand all100 lectures21:26:22
1 lecture21:43
Preview21:43
Java 8 New Features Introduction. Java 8 New Features Introduction Session-1 Java 8 New Features with Examples Mr. Hari Krishna. Overview on Java 8 Features Java 8 New Features with.
10 lectures02:38:58
Preview08:54
13:38
15:00
16:44
17:53
11:41
Invoking Lambda Expression By using Functional Interface example-1
Invoking Lambda Expression By using Functional Interface examples-2,3,4
Invoking Lambda Expression By using Functional Interface example-5
21:02
Review This section videos thoroughly and then take this Practice Test. After completing this Practice Test it is highly recommended to view explanations so that you will get much clarity on the subject.
10 questions
8 lectures01:34:17
Preview17:00
Preview08:40
09:07
Sorting Elements of List without Lambda Expression
Sorting Elements of ArrayList with Lambda Expression
Sorting Elements of TreeSet with Lambda Expression
Sorting Elements of TreeMap with Lambda Expression
Sorting of Our own class objects with Lambda Expression
Review This section videos thoroughly and then take this Quiz. After completing this Quiz it is highly recommended to view explanations so that you will get much clarity on the subject.
9 questions
4 lectures01:15:13
19:07
10:58
18:54
Review This section videos thoroughly and then take this Practice Test. After completing this Practice Test it is highly recommended to view explanations so that you will get much clarity on the subject.
7 questions
+–Default Methods and Static Methods in Interfaces
12:59
15:27
Review This section videos thoroughly and then take this Practice Test. After completing this Practice Test it is highly recommended to view explanations so that you will get much clarity on the subject.
11 questions
13 lectures02:48:26
12:40
17:16
09:12
Predefined Functional Interfaces-Predicate Joining
Program to display names starts with 'K' by using Predicate
Predicate Example to Remove null values and Empty String from the given List?
Program for User Authentication by using Predicate
Program to Check Whether Software Engineer is allowed into Pub or not?
Employee Management Application by using Predicate Part-1
Employee Management Application by using Predicate Part-2
Employee Management Application by using Predicate Part-3
11:43
Review This section videos thoroughly and then take this Quiz. After completing this Quiz it is highly recommended to view explanations so that you will get much clarity on the subject.
8 questions
Practice Question and Explanation For Java Certification
9 lectures01:46:16
20:47
Program to remove spaces present in the given String by using Function
19:12
Progarm to find Total Monthly Salary of All Employees by using Function
Progarm to perform Salary Increment for Employees by using Predicate & Function
11:54
Demo program to Demonstrate the difference between andThen() and compose()
Demo Program for User Authentication by using Function Chaining
04:49
Review This section videos thoroughly and then take this Quiz. After completing this Quiz it is highly recommended to view explanations so that you will get much clarity on the subject.
7 questions
4 lectures47:46
08:16
Program to display Movie Information by using Consumer
Program to display Student Information by using Predicate,Function and Consumer
10:56
6 lectures53:09
09:34
04:18
07:17
08:56
15:48
+–Two-Argument (Bi) Functional Interfaces- BiPredicate, BiFunction & BiConsumer
10:29
07:19
06:06
Creation of Student object by taking name and rollno as input with BiFunction
Calculate Monthly Salary With Employee and TimeSheet By using BiFunction
07:04
Demo Program to Increment Employee Salary by using BiFunction & BiConsumer
Comparison Table between One-Argument & Two-Argument Functional Interfaces
Java 8 was released in 18th March 2014, so it’s high time to look into Java 8 Features. In this tutorial, we will look into Java 8 features with examples.
Java 8 Features
![Javatpoint Javatpoint](/uploads/1/2/5/6/125623228/360476150.jpg)
Some of the important Java 8 features are;
Let’s have a brief look on these Java 8 features. I will provide some code snippets for better understanding, so if you want to run programs in Java 8, you will have to setup Java 8 environment by following steps.
- Download JDK8 and install it. Installation is simple like other java versions. JDK installation is required to write, compile and run the program in Java.
- Download latest Eclipse IDE, it provides support for java 8 now. Make sure your projects build path is using Java 8 library.
Learning Java? Nothing better than a video course trusted by over 1,70,000 students (yes, that many students). Follow this link to get heavy discount on the course.
forEach() method in Iterable interface
Whenever we need to traverse through a Collection, we need to create anIterator
whose whole purpose is to iterate over and then we have business logic in a loop for each of the elements in the Collection. We might get ConcurrentModificationException if iterator is not used properly.Java 8 has introduced forEach method injava.lang.Iterable
interface so that while writing code we focus on business logic only. forEach method takesjava.util.function.Consumer
object as argument, so it helps in having our business logic at a separate location that we can reuse. Let’s see forEach usage with simple example.The number of lines might increase but forEach method helps in having the logic for iteration and business logic at separate place resulting in higher separation of concern and cleaner code.default and static methods in Interfaces
If you read forEach method details carefully, you will notice that it’s defined in Iterable interface but we know that interfaces can’t have method body. From Java 8, interfaces are enhanced to have method with implementation. We can usedefault
andstatic
keyword to create interfaces with method implementation. forEach method implementation in Iterable interface is:We know that Java doesn’t provide multiple inheritance in Classes because it leads to Diamond Problem. So how it will be handled with interfaces now, since interfaces are now similar to abstract classes. The solution is that compiler will throw exception in this scenario and we will have to provide implementation logic in the class implementing the interfaces.Notice that both the interfaces have a common method log() with implementation logic.As you can see thatInterface1
has static method implementation that is used inMyClass.log()
method implementation. Java 8 uses default and static methods heavily in Collection API and default methods are added so that our code remains backward compatible.If any class in the hierarchy has a method with same signature, then default methods become irrelevant. Since any class implementing an interface already has Object as superclass, if we have equals(), hashCode() default methods in interface, it will become irrelevant. Thats why for better clarity, interfaces are not allowed to have Object class default methods.For complete details of interface changes in Java 8, please read Java 8 interface changes.Functional Interfaces and Lambda Expressions
If you notice above interfaces code, you will notice @FunctionalInterface annotation. Functional interfaces are new concept introduced in Java 8. An interface with exactly one abstract method becomes Functional Interface. We don’t need to use @FunctionalInterface annotation to mark an interface as Functional Interface. @FunctionalInterface annotation is a facility to avoid accidental addition of abstract methods in the functional interfaces. You can think of it like @Override annotation and it’s best practice to use it.java.lang.Runnable
with single abstract method run() is a great example of functional interface.One of the major benefits of functional interface is the possibility to use lambda expressions to instantiate them. We can instantiate an interface with anonymous class but the code looks bulky.Since functional interfaces have only one method, lambda expressions can easily provide the method implementation. We just need to provide method arguments and business logic. For example, we can write above implementation using lambda expression as:If you have single statement in method implementation, we don’t need curly braces also. For example above Interface1 anonymous class can be instantiated using lambda as follows:So lambda expressions are means to create anonymous classes of functional interfaces easily. There are no runtime benefits of using lambda expressions, so I will use it cautiously because I don’t mind writing few extra lines of code.A new packagejava.util.function
has been added with bunch of functional interfaces to provide target types for lambda expressions and method references. Lambda expressions are a huge topic, I will write a separate article on that in future.You can read complete tutorial at Java 8 Lambda Expressions Tutorial.Java Stream API for Bulk Data Operations on Collections
A newjava.util.stream
has been added in Java 8 to perform filter/map/reduce like operations with the collection. Stream API will allow sequential as well as parallel execution. This is one of the best feature for me because I work a lot with Collections and usually with Big Data, we need to filter out them based on some conditions.Collection interface has been extended with stream() and parallelStream() default methods to get the Stream for sequential and parallel execution. Let’s see their usage with simple example.If you will run above example code, you will get output like this:Notice that parallel processing values are not in order, so parallel processing will be very helpful while working with huge collections.
Covering everything about Stream API is not possible in this post, you can read everything about Stream API at Java 8 Stream API Example Tutorial.Java Time API
It has always been hard to work with Date, Time and Time Zones in java. There was no standard approach or API in java for date and time in Java. One of the nice addition in Java 8 is thejava.time
package that will streamline the process of working with time in java.Just by looking at Java Time API packages, I can sense that it will be very easy to use. It has some sub-packagesjava.time.format
that provides classes to print and parse dates and times andjava.time.zone
provides support for time-zones and their rules.The new Time API prefers enums over integer constants for months and days of the week. One of the useful class isDateTimeFormatter
for converting datetime objects to strings.For complete tutorial, head over to Java Date Time API Example Tutorial.Collection API improvements
We have already seen forEach() method and Stream API for collections. Some new methods added in Collection API are:Iterator
default methodforEachRemaining(Consumer action)
to perform the given action for each remaining element until all elements have been processed or the action throws an exception.Collection
default methodremoveIf(Predicate filter)
to remove all of the elements of this collection that satisfy the given predicate.Collection
spliterator()
method returning Spliterator instance that can be used to traverse elements sequentially or parallel.- Map
replaceAll()
,compute()
,merge()
methods. - Performance Improvement for HashMap class with Key Collisions
Concurrency API improvements
Some important concurrent API enhancements are:ConcurrentHashMap
compute(), forEach(), forEachEntry(), forEachKey(), forEachValue(), merge(), reduce() and search() methods.CompletableFuture
that may be explicitly completed (setting its value and status).Executors
newWorkStealingPool()
method to create a work-stealing thread pool using all available processors as its target parallelism level.
Java IO improvements
Some IO improvements known to me are:Files.list(Path dir)
that returns a lazily populated Stream, the elements of which are the entries in the directory.Files.lines(Path path)
that reads all lines from a file as a Stream.Files.find()
that returns a Stream that is lazily populated with Path by searching for files in a file tree rooted at a given starting file.BufferedReader.lines()
that return a Stream, the elements of which are lines read from this BufferedReader.
Miscellaneous Core API improvements
Some misc API improvements that might come handy are:- ThreadLocal static method withInitial(Supplier supplier) to create instance easily.
- Comparator interface has been extended with a lot of default and static methods for natural ordering, reverse order etc.
- min(), max() and sum() methods in Integer, Long and Double wrapper classes.
- logicalAnd(), logicalOr() and logicalXor() methods in Boolean class.
- ZipFile.stream() method to get an ordered Stream over the ZIP file entries. Entries appear in the Stream in the order they appear in the central directory of the ZIP file.
- Several utility methods in Math class.
jjs
command is added to invoke Nashorn Engine.jdeps
command is added to analyze class files- JDBC-ODBC Bridge has been removed.
- PermGen memory space has been removed
That’s all for Java 8 features with example programs. If I have missed some important features of Java 8, please let me know through comments.