
Learn how lambda expressions convert methods into anonymous functions under a functional interface, reducing code and boosting readability while enabling collection operations like filtering, mapping, and working with streams.
Explore sorting a collection in Java 8 by comparing the pre-lambda approach using a comparator with the post-lambda technique, using an ArrayList and ascending order.
Explore predicate-based filtering in Java 8 by streaming a list of employee names and extracting those starting with specific letters, then applying negate to obtain opposite results.
Apply and chain multiple predicates on a data set using streams in Java 8, learning how to filter and combine conditions with predicate logic.
Explore the BiPredicate concept in Java: a two-argument predicate with test, and, or, negate methods, applying on two objects and returning a boolean, with hands-on implementation steps.
Introduce the consumer interface in the Java function package, showing how a consumer consumes input data with no return value, using the accept method and console output.
Learn to implement and apply functions via the function interface, build a string-to-length function, create a half-length operation, and prepare to compose with identity in Java 8.
Explore the bi-function concept in Java 8, noting that BiFunction takes two input parameters and one output parameter, with examples related to hash map use.
Explore streams as a declarative way to process collections in java, focusing on what to achieve rather than how to achieve it. Illustrate a simple example with a list of menu items and calories, showing how to filter low calorie options and collect them, with a comparison to java 7.
Explore how to filter items with calories under 200, map to their names, and collect results using Java 8 streams, anonymous implementations, and method references.
Understand the difference between streams and collections: streams perform data operations like mapping and collecting lazily, while collections store data and support add or remove.
Explore stream debugging in Java 8 by loading data points, filtering numbers greater than the available, and reviewing the elements available in this particular stream.
Explore creating streams in Java 8, using empty streams to avoid nulls, optional usage, suppliers for finite data, and controlled generation with random numbers and limits.
Learn how to convert streams to collections in Java 8 using collectors, handle boxed data and map results to objects for collection outcomes.
Learn how map and flatMap transform a stream of programmer objects into names and skill lists, flattening results and collecting them to illustrate map, flatMap, and mapreduce ideas.
Sort data by natural order or reverse order using a comparator in streams, and apply these techniques to organize lists efficiently.
Learn how to use stream intermediate operations and peek to log data between steps without altering the stream, while mapping, filtering, and debugging with a start-end range example.
Explore how stream operations findFirst and findAny select elements under different conditions, with optional handling and parallel execution considerations for performance.
Explore stream reduce in Java 8, using an identity and an accumulator lambda to fold multiple elements into a single object, with examples like longest word or string concatenation.
Learn how to use Java 8 collectors with lambda expressions to compute min and max, and to partition data by conditions, mapping results into collections.
Explore interfaces, default methods, and static methods in Java 8; learn how default methods add new behavior without breaking implementations and how static methods work in interfaces.
use Java 8 optional to check presence, execute a consumer when present, and return a default value when empty to simplify code.
Learn to create and format date and time values in Java 8 using LocalDate and LocalDateTime, compute month length, detect leap years, and obtain the current date with now.
Explore working with local time and local date in Java 8 by creating time and date instances, obtaining the current time, and performing basic hour, minute, and second calculations.
Learn how the java 8 LocalDateTime class combines local date and time, constructs and formats instances, and performs arithmetic such as adding days or hours, including the day of month.
Explore how the ZonedDateTime class manages current date and time, time zones and offsets, and demonstrate formatting and converting times across zones.
Learn to calculate differences between two dates and times in Java 8 using Period for date components and Duration for time components with hands-on examples.
Explore Java 8 CompletableFuture, an extension of Future for asynchronous, non-blocking tasks; learn manual completion, callbacks, chaining actions, and built-in exception handling to improve parallelism.
Some ratings and reviews-
**************#########*****************
Dmitry L.
*****
Rating: 5.0 out of 5
The course is quite concise and straight to the point. I managed to learn major new concepts of Java 8, which previously was somehow familiar to me, but not very clear. Thank you for your hard work, Ravi!
---------------------------------------***********************-------------------------------------------------------------
Manvendra Pratap S.
*****
Rating: 5.0 out of 5
Awesome ? Course, all concepts are taught in a step-wise manner and taught with an example. This is the course if anyone want to cover all concepts of Java 8.
Thanks for wonderful course.
--------------------------------------***********************--------------------------------------------------------------
Shahab H.
*****
Rating: 5.0 out of 5
Great Course Content and Teaching Skills!
This course helped in getting hands-on experience with Java 8. Especially the Lambda and Stream API part of the course is outstanding.
--------------------------------------************************------------------------------------------------------------
This course is intended to learn the features of Java 8 with the live coding. This will cover all the concepts with the practical approach. This is completely based on the writing code way of learning. You are about to feel like a class room learning .
Why Java 8:
This course will help the Java developers to build their knowledge on the new Java 8 features.
All the new features such as Lambdas, Streams , Optionals, Functional Interfaces and Parallel Programming will be explained with live coding.
This course will give you the confidence on implementing new Java 8 features in real Java projects.
By the end of this course you will have a complete understanding of new Java 8 functional features.
This course is touching below features along with some minor.
1. Lambda Expressions
2. Functional Interfaces
3. Default methods in Interface
4. Static Methods in Interfaces.
5. Predicate
6. Function
7. Consumer
8. Supplier
9. Method Reference & Constructor Reference by Double Colon(::) Operator.
10. Stream API
11. Date & Time API ( Joda API)
This course is a concise, no-nonsense guide to Java 8 which explains just enough detail so that you can absorb and understand the core concepts and get you up and running, quickly and effectively with coding in Java 8.
After completing this video course, we are sure, you will be in a position to handle any king of Java projects and feel confidence while writing codes.
I can not wait to see you in the course :)
Happy learning :)