Description
Refactoring to Streams course 2.1. Java celebrated its 25th anniversary in 2020. Code written in Java in 1995 can still run today, even without recompiling. This is one of the most important reasons for Java’s success in organizations. Over the years, we’ve seen many improvements to make it easier to work with Java code. Internal classes were introduced in Java 1.1. A suitable framework for working with collections (Collection Framework) joined us in Java 1.2. Java 5 brought us better type safety with Generics.
But the biggest improvement for Java programmers came with Streams and Lambdas in Java 8. Now we can write Java code in a declarative style, instead of focusing on the “how” of the program’s logic, we emphasize the “what” of it. Since Java 8, we have seen a steady stream of improvements in the Java programming language. Records, Sealed Classes, Pattern Matching, Local Variable Type Inference and many more. All of these things contribute to writing great Java code.
Unfortunately, a lot of Java code is still stuck in the dark ages of Java 6. These codes need refactoring. Refactoring is a systematic technique for reconstructing an existing body of code, changing its internal structure without affecting its external behavior. – Martin Fowler In this one-day course, we will learn how and when to “rewrite” with a focus on the biggest development, 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 you will learn
- What is functional interface?
- The four main types of functional user interfaces are found in the java.util.function package
- How to markup lambdas are shorthand for an anonymous inner class based on a functional user interface
- Short and long forms of lambdas can exist depending on their complexity
- Method Reference as a further simplification for some forms of lambdas
- How Default Methods and Static Methods in interfaces can use lambdas to improve generality, correctness, and readability.
- When might it be unsafe to use methods like Map.computeIfAbsent?
- The concept of stream and its relationship with iterable collections.
- Why coding with streams follows algorithm logic more naturally than using for/while loops
- Create, transform and terminate streams using filters, mappings, matchers, collectors, reducers, etc.
- Why should we use collectors instead of forEach to build collections from a stream?
- Using the Optional class to avoid null checks and how Optionals are used with streams
- How to handle exceptions in lambdas using sneaky throws (without Lombok)
- How Functional UIs, Streams, and Optionals are optimized for int, long, and double primitives
This course is suitable for people who
- They are Java programmers with basic to intermediate knowledge
- They want to make their Java code cleaner, more readable, and more maintainable
- They want the latest features
Specifications of the Refactoring to Streams course 2.1
- Publisher: JavaSpecialists
- teacher: Dr. Heinz M. Kabutz
- Training level: beginner to advanced
- Training duration: 4 hours and 47 minutes
- Number of courses: 62
Course headings on 4/2024
Refactoring to Streams course prerequisites 2.1
- Basic Understanding of Kubernetes and Containerization
- Basic Understanding with Git and Version Control and GitOps Practices
- Basic Linux/Unix Command Line Skills
- Basic YAML syntax
- Willingness to learn and experiment with Kubernetes
Images of Refactoring to Streams 2.1 course
Sample video of the course
Installation guide
After Extract, view with your favorite Player.
Subtitle: None
Quality: 1080p
download link
File(s) password: www.downloadly.ir
Size
9.9 GB
Be the first to comment