Description
Refactoring course in Streams 2.1. Java celebrated its 25th anniversary in 2020. Code written in Java in 1995 can still run today, even without recompilation. This is one of the most important reasons for the success of Java in organizations. Over the years, we’ve seen many improvements to make working with Java code easier. Inner classes were introduced in Java 1.1. A suitable framework for working with collections (Collection Framework) appeared in Java 1.2. Java 5 brought us better type safety with Generics.
But the biggest improvement for Java programmers came with the introduction of Streams and Lambdas in Java 8. We can now write Java code in a declarative style, emphasizing the “what” of program logic instead of focusing on the “how.” Since Java 8, we have seen a steady stream of improvements in the Java programming language. Records, sealed classes, pattern matching, local variable type determination, and much more. All of this contributes to writing great Java code.
Unfortunately, most of the Java code is still stuck in the dark ages of Java 6. These codes need refactoring. Refactoring is a systematic method of reconstructing an existing block of code by changing its internal structure without affecting its external behavior. – Martin Fowler In this one-day course, we’ll learn how and when to “rewrite,” with a special focus on the biggest breakthrough yet—Java Streams. However, we will also show you what’s new in the Java programming language. This is a very practical course. Each section has exercises in which we rewrite the existing code of a large enterprise resource planning (ERP) system with 330,000 lines of code (LOC).
What will you learn
- What is a functional interface?
- The four main types of functional user interfaces are found in the java.util.function package.
- How to Markup Lambda Expressions are a shorthand for an anonymous inner class based on a functional user interface.
- There can be short and long forms of lambdas depending on their complexity.
- Method reference as a further simplification of some forms of lambda expressions.
- How default methods and static methods in interfaces can use lambda expressions to improve generality, correctness, and readability.
- When might it be unsafe to use methods like Map.computeIfAbsent?
- The concept of a stream and its connection with iterable collections.
- Why coding with streams follows algorithm logic more naturally than using for/while loops
- Create, transform, and terminate streams using filters, mappers, mappers, collectors, transformers, and more.
- Why should we use collectors instead of forEach to create collections from a stream?
- Using the Optional class to avoid null checks, and using Optional with streams.
- How to handle exceptions in lambda expressions using hidden throws (without Lombok)
- How functional user interfaces, streams, and advanced parameters are optimized for int, long, and double primitives
This course is suitable for people who
- These are Java programmers with basic and intermediate knowledge.
- They want to make their Java code cleaner, more readable, and more maintainable.
- They want the latest features
Course Specifications: Refactoring to Threads 2.1
Course headings for 4/2024
Prerequisites for the Refactoring in Streams 2.1 course
- Basic understanding of Kubernetes and containerization
- Basic understanding of Git, version control and GitOps practices
- Basic Linux/Unix command line skills
- Basic YAML syntax
- Desire to learn and experiment with Kubernetes
Images from the Refactoring in Streams 2.1 course
Example video course
installation instructions
Once extracted, watch using your favorite player.
Subtitles: No
Quality: 1080p
Download link
Password for file(s): www.downloadly.ir
size
9.9 GB