Advanced Java Programming

via Udacity

Go to class Write review

Details

Go to class

Provider

Udacity
Pricing

Paid Course
Languages

English
Certificate

Certificate Available
Effort

5 hours
Sessions

Self-Paced
Level

Intermediate
Subtitles

German, Japanese

Found in

Overview

Dive deep into Advanced Java Programming Techniques, enhancing your skill set with modern paradigms. Explore functional programming leveraging lambda expressions and streams, and master File I/O with the NIO.2 package. Gain insights into essential design patterns and their practical implementations. Advance your knowledge in concurrent programming with thread pools and the Fork/Join framework, ensuring efficient parallel processing. Discover high-performance computing through the Vector API and optimize memory management with garbage collection tuning. Learn to dynamically modify Java behaviors using the Reflection API and develop custom annotations for meta-programming. Conclude with a comprehensive project, Loghog, to apply your newly acquired skills.

Syllabus

Course Introduction
- Get ready to master advanced Java tools—functional programming, concurrency, NIO.2, JVM tuning—culminating in building LogHog, a high-performance log analysis tool.
Functional Programming with Lambda and Streams
- Master functional programming in Java using Lambda expressions and Streams for readable, efficient data pipelines, null safety, and best practices in production-ready code.
Implement Functional Programming with Streams and Lambdas
- Master functional programming in Java by processing data with Streams and Lambdas—write declarative, resilient code using map, filter, reduce, and debug with peek.
File I/O and NIO.2
- Master safe, efficient file I/O in Java using NIO.2: separate file paths from operations, lazily stream data, enforce charsets, buffer streams, and manage resources with try-with-resources.
Implement File Operations with NIO.2
- Learn to process large files efficiently in Java using NIO.2, lazy streaming with Files.lines(), safe resource management, and build a file-based ETL pipeline for security log analysis.
Essential Design Patterns
- Understand essential design patterns (Builder, Singleton, Factory, Strategy, Observer), avoid "Patternitis," and learn to apply the right pattern only when business needs require it.
Implement Design Patterns in Java Applications
- Learn to implement thread-safe Singletons using double-checked locking and build immutable, validated objects with the Builder pattern in Java applications.
Concurrent Programming
- Master safe, efficient concurrent programming in Java: avoid manual threads, handle shared state, use thread pools, atomic variables, and build async pipelines with CompletableFuture.
Implement Concurrent Applications with Thread Pools and Synchronization
- Learn to build fast, resilient concurrent Java apps using thread pools, CompletableFuture, and scatter-gather to handle latency and failures without blocking or crashes.
Parallel Streams and Fork/Join Framework
- Understand Java's parallel streams and Fork/Join framework—how work is split, risks of the common pool, and when to use parallelism safely and efficiently.
Implement Parallel Processing with Streams and Fork/Join
- Learn when and how to use Java parallel streams and Fork/Join for performance: benchmark with JMH, avoid shared state, and understand when parallelization helps or hurts.
Vector API for SIMD Operations
- Learn how Java's Vector API enables SIMD operations for high-performance computing, optimizing data analytics, ML, and scientific tasks with portable, hardware-accelerated vector processing.
Implement High-Performance Computing with Vector API
- Unlock Java high-performance computing by using the Vector API for SIMD operations to massively accelerate array tasks and handle non-divisible data with vector and tail loops.
Memory Management and GC Tuning
- Understand JVM memory architecture, generational GC mechanics, observability techniques, and tools to tune memory usage and detect memory leaks for reliable Java microservices.
Optimize Application Performance with Memory Profiling and GC Tuning
- Learn to diagnose and fix Java memory leaks by analyzing heap dumps, profiling GC behavior, and tuning memory management for robust application performance.
Java Reflection API
- Explore Java Reflection API to inspect, instantiate, and manipulate code at runtime, powering frameworks like Spring but with major safety and performance trade-offs.
Implement Dynamic Behavior with Reflection API
- Explore Java's Reflection API to inspect, access, and manipulate class members at runtime—enabling dynamic utilities and breaking encapsulation for advanced programming tasks.
Annotations and Meta-Programming
- Learn how custom annotations and meta-annotations enable declarative meta-programming in Java, and how reflection is used to process annotations for dynamic configuration at runtime.
Create and Process Custom Annotations
- Learn to create custom Java annotations and process them at runtime using reflection to enforce validation and build reusable, metadata-driven frameworks.
Advanced Exception Handling Patterns
- Master advanced Java exception handling: translate and chain exceptions, use centralized handlers, manage async errors, and ensure robust, fail-safe system design for resilient APIs.
Implement Robust Exception Handling in Java Applications
- Master robust Java exception handling by wrapping low-level errors in custom exceptions, preserving stack traces, and maintaining clean architectural boundaries.
Course Conclusion
- Review and celebrate key skills gained: Java lambdas, streams, file I/O, design patterns, reflection, and JVM performance tuning, ready for real-world application.
Project: Loghog
- In this project, you will build LogHog—a fast, extensible CLI tool for analyzing huge server logs using streaming, Virtual Threads, hardware-acceleration, and dynamic metric extraction.