Essential Software Tools for Java Development: JDK 17 and IntelliJ IDEA

Step-by-Step Guide to Installing JDK 17 on Windows 10 and Windows 11

Installing JDK 17 on macOS: A Comprehensive Guide for Intel and M1/M2 Macs

Installing OpenJDK 17 on Ubuntu Linux: A Step-by-Step Terminal Guide

Verify Java Installation and Explore Java Interactively with JShell

Your First Java Program: Displaying "Hello World" and Basic Error Handling

Introduction to Variables, Keywords, and the Integer (int) Data Type

Using Variables in Java Expressions: A Comprehensive Introduction

Exploring Java Primitive Types: Integer Ranges and Wrapper Classes

Understanding Byte, Short, and Long Data Types and Their Width in Java

Understanding and Using Casting with Numeric Primitive Types in Java

Primitive Types Challenge: Applying Your Knowledge of Integer Variables

Working with Float and Double: Precision in Floating Point Numbers

Understanding Floating-Point Precision: A Practical Challenge in Java

Exploring Character (char) and Boolean Primitive Data Types in Java

Recap of Primitive Types and Introduction to the String Class in Java

Mastering Operators, Operands, and Expressions in Java Programming

Simplifying Java Code: Using Abbreviated Operators for Concise Operations

Embracing the Power of an Integrated Development Environment

What is an IDE?

Installing Intellij IDEA for Windows

Installing Intellij IDEA for Mac

Installing Intellij IDEA for Linux

Configuring IntelliJ IDEA for Windows

Configuring IntelliJ IDEA for Mac

Configuring IntelliJ IDEA for Linux

Creating Your First IntelliJ Project: "Hello World" Java Code Implementation

Understanding IntelliJ Code Structure: Classes, Methods, and Basic Java Syntax

Mastering Java's if-then Statement: Conditional Logic for Program Flow Control

Advanced Conditional Logic: Implementing the Logical AND Operator in Java Code

Java's Logical OR Operator: Enhancing Conditional Statements for Flexible Code

Assignment vs. Equality: Avoiding Common Java Operator Errors in IntelliJ

Streamlining Code: Implementing Java's Ternary Operator for Concise Conditionals

Java Operator Precedence: Mastering Expression Evaluation and Challenge

Introduction To The Fundamentals Of Java Workflow

Exploring Java Keywords And Understanding Expressions

Mastering Java Statements, Whitespace, And Code Organization

Harnessing Code Blocks And The If-Then-Else Statement In Java

Practical If-Then-Else Challenge For Java Flow Control

Deep Overview Of Methods In Java For Reusable Code

Enhancing Skills With Additional Java Method Techniques

Comprehensive Recap Of Java Methods

Hands-On Java Method Challenge For Deeper Practice

Comparing And Reviewing Code In IntelliJ For Better Development

Introduction To Java Coding Exercises For Skill Development

Delving Into Method Overloading In Java

Practical Method Overloading Challenge To Strengthen Java Expertise

Comprehensive Seconds-And-Minutes Challenge For Time-Based Calculations

Detailed Bonus Challenge Solution And Key Insights

Introduction To The Foundations Of Program Flow In Java

Exploring The Traditional And Enhanced Switch Statements

Delving Deeper Into Advanced Switch Statement Features

Traditional Switch Statement Challenge And Practical Exercises

Embracing Switch Expressions With A Hands-On Coding Challenge

Mastering The for Statement For Repetitive Task Automation

Comprehensive for Loop Challenge To Strengthen Iteration Skills

Sum 3 And 5 Challenge With IntelliJ Debugger Insights

For Loop Recap And Key Takeaways For Iteration In Java

The while And do-while Statements For Conditional Looping

Practical while Loop Exercises And Challenges

Digit Sum Challenge And Further Looping Techniques

Revisiting The while And do-while Loops: A Complete Recap

Exploring Local Variables And Scope In Java Blocks

Understanding Classes, Objects, And Static Versus Instance Members

Parsing Values And Reading Console Input – system.console() Overview

Handling Exceptions And Introducing The Scanner Class

Reading Input With The Scanner For Seamless User Interaction

Hands-On Reading User Input Challenge For Practical Mastery

Identifying Min And Max Values – A Final Control Flow Challenge

Welcome to Java OOP Inheritance

Deep Dive into Classes and Objects

Getters, Encapsulation, and Object Access

Setters, Object Creation, and OOP Practice

Classes Challenge: Building a Bank Account

Constructors Part 1: Object Initialization

Constructors Part 2: Overloading and Chaining

Constructor Challenge: Building Customer Data

Understanding References, Objects, and Instances

Static vs. Instance Variables in Java

Static vs. Instance Methods Explained

POJOs: Plain Old Java Objects

Java Records: The Modern POJO Approach

Inheritance - Part 1: The Basics

Inheritance - Part 2: Extending Animal Class

Inheritance - Part 3: Unique Dog & Fish Classes

Unveiling java.lang.Object in Java

Inheritance Challenge - Designing a Worker Hierarchy

Inheritance Challenge Part 2: Specialized Employees

Using this and super for Constructors

Method Overloading vs. Overriding Explained

Text Blocks & Advanced Output Formatting

Revisiting the String: Methods and Best Practices

Mastering String Manipulation Methods

The StringBuilder: Efficient Mutable Strings

Embarking on OOP Part 2: Composition, Encapsulation, and Polymorphism Essentials

Building a Computer with Composition: Understanding Has-A vs. Is-A in Java

Assembling a Personal Computer: Real-World Composition and Object Management

Hands-On Smart Kitchen Challenge: Modeling IoT Appliances with Composition

Encapsulation Essentials, Part 1: Data Hiding and Simplifying Interfaces

Encapsulation Deep Dive, Part 2: Enhancing Classes and Securing Data

Encapsulation Challenge: Building a Printer with Toner and Duplex Functionality

Polymorphism Foundations, Part 1: Introducing Movie Subclasses for Runtime Varia

Polymorphism in Practice, Part 2: Factory Methods, Runtime Types, and Movie Scen

Advanced Casting and var Usage: Navigating Compile-Time vs. Runtime Types in Jav

Runtime Type Inspection: Mastering instanceof and Pattern Matching in Java

Polymorphism Challenge: Building Gas, Electric, and Hybrid Car Classes in Java

Polymorphism Challenge, Part 2: Finalizing Car Inheritance and Overridden Method

OOP Master Challenge, Part 1: Crafting a Burger Restaurant App with OOP Concepts

OOP Master Challenge, Part 2: Implementing Meal Orders and Pricing Strategies

OOP Master Challenge: Deluxe Burger Bonus Adding Specialized Topping and Pricing

Project Structure and Modular Design: Harnessing Packages and Import Statements

Arrays Introduction: Handling Multiple Values Efficiently in Java

Declaring, Initializing, and Accessing Arrays: Foundational Principles

Populating, Looping, and Searching: Deeper into Java Arrays

Sorting, Filling, and Copying: Mastering the java.util.Arrays Helper Class

Binary Search & Equality Checks: Speedy Lookups and Comparisons in Arrays

Descending Sort Challenge: Building Your Array Skills with Real Data

Common Pitfalls & Best Practices: A Comprehensive Arrays Recap

Reference vs. Value Types: Understanding Array Memory and Method Calls

Embracing varargs: Flexible Method Parameters and Array Conversions

Finding the Smallest Value: A Hands-On Minimum Element Challenge

Reversing Arrays In-Place: Hands-On Practice with Swapping Elements

Navigating 2D Arrays: Matrix Representation and Nested Loop Traversals

Expanding to Multi-dimensional Arrays: Jagged Structures and Complex Data

Introduction to Java Collections: Beyond Basic Arrays

Meet the List Interface & ArrayList (Part 1)

ArrayList Methods (Part 2): Add, Remove, and More

ArrayList Methods (Part 3): Sorting, Copying & Searching

Arrays vs. ArrayLists: A Practical Comparison

ArrayList Challenge Part 1: Building an Interactive Grocery List

LinkedList Overview: Memory, Big O, and Why LinkedList Exists

LinkedList Essentials (Part 1): Adding & Removing Elements

LinkedList Essentials (Part 2): Retrieving & Itinerary Example

Iterators Explained: Navigating Lists with Forward & Reverse

LinkedList Challenge: Ordered Travel Itinerary (Part 1)

LinkedList Challenge Continued: Interactive Navigation

Introduction to Autoboxing & Unboxing: Moving Between Primitives & Wrappers

Autoboxing & Unboxing for Arrays & Lists: Working with Wrapper Classes

Autoboxing & Unboxing Challenge: Simple Banking App (Part 1)

Autoboxing & Unboxing Challenge: Bank & Customer Implementation (Part 2)

Enums Demystified: Declaring & Using Predefined Constants

Enums (Part 2): Switch Expressions & Custom Methods in Enums

Abstraction & Generalization: Less Code, More Extensibility

Exploring Abstract & Interface Modifiers: Real-World Modeling in Java

Diving into Abstract Classes (Part 1): Creating Flexible Hierarchies

Diving into Abstract Classes (Part 2): Polymorphic Behavior & Implementation

Diving into Abstract Classes (Part 3): Advanced Hierarchies & Use Cases

Abstract Class Challenge (Part 1): Building a Storefront & Product Hierarchy

Abstract Class Challenge (Part 2): Finalizing the Store & Order System

Interfaces (Part 1): Harnessing Contracts & Polymorphic Behavior in Java

Interfaces (Part 2): Multiple Implementations & Real-World Examples

Interfaces (Part 3): Constants, Conversion & Flexible Abstractions

Interfaces & JDK 8 Enhancements: Default/Static Methods for Compatibility

Interfaces & JDK 9 Enhancements: Private & Static Methods in Action

Interface vs. Abstract Class: Key Differences & Best Use Cases

Interface Challenge (Part 1): Creating Mappable Classes & GeoJSON-Like Output

Interface Challenge (Part 2): Finalizing Mapping Logic & Extended Features

Generics Overview: Why Type Parameters & Where They Excel

Creating Your First Generic Class: From Basics to Implementation

Refining Generic Classes: Polymorphism & Type Safety

Advanced Generics: Multiple Type Parameters & Bounded Types

Generic Class Challenge (Part 1): Building Reusable Structures

Generic Class Challenge (Part 2): Finalizing Maps & Overviews

Comparable Revisited: Sorting Objects by Natural Order

Comparable vs. Comparator: Distinctions & Sorting Strategies

Generic Classes as Reference Types: Wildcards & Method Parameters

Generic Methods, Wildcards & Type Erasure: Handling Advanced Cases

Static Methods in Generics & Multiple Upper Bounds Explained

Final Generics Challenge: Integrating Bounded Types & Comparators

Understanding Nested Classes: Overview & Types

Static Nested Classes: Encapsulation & Access Rules

Inner Classes: Non-Static Nesting & Syntax

Applying Inner Classes: Bill’s Burger Revisited

Inner Classes Challenge: Practical Enhancements

Local Classes: Scoping & Effective-Final Variables

Anonymous Classes: Inline Instantiation & Use Cases

Local & Anonymous Classes Challenge

Introduction to Lambda Expressions: Revolutionizing Java Code with Conciseness

Deep Dive into Lambda Expressions and Functional Interfaces: Practical Examples

Exploring Lambda Expression Syntax: Variations, Rules, and Advanced Examples

Custom Functional Interfaces: Building Reusable Lambda Expressions in Java

Exploring Java's Built-In Functional Interfaces: Consumer and Predicate

Exploring Java's Built-In Functional Interfaces: Function and Supplier

Hands-On Practice: Lambda Mini-Challenges for Skill Reinforcement and Mastery

Lambda Expression Challenge: Applying Skills with Arrays, Lists, and Operations

Demystifying Method References: Simplifying Lambda Expressions in Java Code

Understanding the Most Complex Method References: Unbounded Receiver Explained

Hands-On Practice: Method Reference Challenge for Practical Skill Development

Chaining Lambdas: Leveraging Convenience Methods on Functional Interfaces

Advanced Comparator Usage: Leveraging Convenience Methods for Enhanced Sorting

Java Collections Framework: An In-Depth Introduction for Beginners

Deep Dive into Java Collections: Core Interfaces and Big Picture

Creating a Versatile Deck of Cards in Java: Code Setup & Best Practices

Exploring java.util.Collections: Essential Methods and List Operations

Advanced java.util.Collections: Shuffle, Reverse, Sort, indexOfSubList

Mastering java.util.Collections: binarySearch, frequency, min, max, rotate

Challenge: Building a Custom Card Game with java.util.Collections

Completing the Collections Challenge: Five Card Draw (Poker)

Java Hash Codes Explained: Mastering the Basics for Effective Collections

Preparing for Sets and Maps: Setting Up Phone and Email Contacts in Java

Introduction to Java Sets and HashSet: Mastering Unordered Collections

Java Set Operations Explained: Mastering Union, Intersection, & Difference

Java Set Operations Challenge: Setting Up Task and TaskData Classes

Java Set Operations Challenge: Real-World Application with Task Management

Exploring LinkedHashSet and TreeSet: Ordered Sets in Java

Java TreeSet Mastery: Navigating with Closest Match and Subset Methods

Challenge: Building a Robust Theatre Seat Booking System with TreeSet

Completing the Theatre Seat Booking System Challenge

Comprehensive Guide to the Java Map Interface and Its Functionality

Advanced Map Operations: compute, replace, and remove Methods Explained

Mastering Map View Collections: keySet, values, and entrySet in Java

Challenge: Build a Text-Based Adventure Game with Java HashMap

Completing the Text Adventure Game Challenge

Exploring LinkedHashMap and TreeMap: Ordered Maps in Java

Mastering TreeMap: NavigableMap Methods for Efficient Data Handling

EnumSet and EnumMap: Optimizing Collections for Enum Types in Java

Collection Framework Final Challenge Part 1

Building a Complete Store Inventory Management System (Part 1)

Building a Complete Store Inventory Management System (Part 2)

Mutable vs Immutable Objects in Java: Advantages, Disadvantages, and Design

Deep Dive into the Final Modifier: Methods, Fields, Classes, Variables

Final Modifier: Static Methods, Hiding vs. Overriding, Final Variables

Understanding Side Effects of Mutability: Defensive Coding Techniques

Designing Immutable Classes: Private Final Fields, Defensive Copies - Part 1

Creating Truly Immutable Java Classes: Preventing Subclass Modification

Implement Immutable BankAccount and BankCustomer Classes in Java

Shallow vs. Deep Copies: Protecting Data Integrity in Java Applications

Immutable Collections, Unmodifiable Views: Limitations and Best Practices

Implementing Unmodifiable Collections in a Banking Application

Building a Secure Banking Application: Implementing Transaction Handling

Java Constructors: No-args, Initializers, Final Fields, and Inheritance

Demystifying Record Constructors: Canonical, Custom, and Compact Forms

Mastering Enum Constructors and Static Initializers in Java

Building a Game Console Framework with Player Input

Building a Generic Game Console: Implementing Game and Player Interactions

Java Coding Challenge: Design a Pirate Adventure with Constructors & Initializer

Pirate Game Development in Java: Implementing Game Logic and Data Loading

Enhancing Code Security: Final Classes & Constructor Access Modifiers

Restricting Class Extension in Java with the Sealed Classes and Interfaces

Building a Complete Pirate Game: Loot, Combat, and Town Features in Java

Final Java Game Enhancements: Implementing Town Features and Combat Interactions

Understanding Java Streams: Core Concepts and Key Differences from Collections

Practical Java Stream Example: Manipulating and Transforming Bingo Ball Data

Deep Dive into Java Stream Pipelines: Sources, Intermediate, and Terminal Ops

Exploring Java Stream Sources: Collections, Arrays, and Infinite Data Streams

Challenge: Mastering Stream Sources and Data Concatenation in Java

Filtering and Transforming Data: distinct, filter, limit, skip, takeWhile, dropW

Map, Peek and Sorted Operations, using Comparator interface

Mastering Terminal Ops: Find Statistics, Match Elements

Building a Student Engagement System: Code Setup - Part 1

Student Class Construction: Code Setup - Part 2 for Stream Processing

Terminal Operations Challenge Part 1 - Student Data Analysis

Enhancing Data Analysis: Advanced Terminal Operation Challenge Solution

Collecting Data in Java Streams, the Collect and Reduce operations

Advanced Stream Processing: Practical Applications of Collect and Reduce

Terminal Operations Part 2 - Advanced Data Aggregation Challenge

Java Optionals: Preventing NullPointerExceptions and Handling Missing Values

Mastering Stream Terminal Operations Find, Min, Max, Average, and Reduce in Java

Challenge: Advanced Stream Operations and Data Analysis on Student Engagement

Transforming Data Structures: Using flatMap to Stream Map Elements in Java

Comprehensive Streams Challenge: Applying Advanced Techniques in Java

Revisiting Essential Java Core API Functionalities: Math and java.time

Mastering the Java Math Class: Preventing Overflow and Underflow Errors

Comprehensive Guide to Random Number Generation: Math.random and Random

Java Dice Rolling Game: Implementing Randomization and User Input Challenge

Advanced Dice Game: Implementing Scoring and Game Logic with Java Enums

Mastering BigDecimal for Financial Applications: Precision and Scale in Java

Advanced BigDecimal Operations: Controlling Rounding and Precision in Java

Comprehensive Introduction to Java Date and Time API (java.time package)

Working with LocalDate in Java: Creation, Manipulation, and Comparison

Mastering LocalTime and LocalDateTime in Java: A Comprehensive Guide

Understanding Instance, Period, Duration, and Time Zones in Java's Time API

Exploring Java Time Zones: ZoneId, Zone Offset, and Daylight Savings Time

Mastering Java Time: Instant, ZonedDateTime, Duration, Period, ChronoUnit

Introduction to Java Localization and the Locale Class: Concepts and Usage

Applying Localization in Java: Formatting Dates, Numbers, and Currencies

DateTime & Localization: Cross-Timezone Meeting Scheduler Challenge (10 Days)

Java Internationalization: Using ResourceBundle for Multi-Language Support

ResourceBundle in Java: Creating Multi-Language Applications (Part 2)

Introduction to Regular Expressions: Practical Uses and Applications in Java

Demystifying Regular Expressions: Understanding Syntax, Usage, and Benefits

Decoding Regular Expressions: Literals, Character Classes, Quantifiers, Anchors

Using Regular Expressions with String and Scanner: split(), replaceAll(), etc.

Regular Expression Challenges: Applying Concepts through Practical Exercises

Advanced Regular Expressions with Pattern and Matcher: Compilation and Matching

Extracting Data with Matcher: find(), group(), Grouping, and Capturing in Java

Replacing Text Efficiently: Exploring Matcher's Replacement Methods in Java

In-Depth Review: Dissecting Complex Regular Expressions for Phone/HTML Tags

Crafting a Robust Email Validator: A Comprehensive Regular Expression Challenge

Java I/O Fundamentals: Resources, Operations, and Exception Handling Intro

Mastering Java Exceptions: Checked vs. Unchecked, Finally, and Best Practices

Efficient Resource Management: Mastering Try-with-Resources in Java I/O

Java I/O Essentials: File, Path, Files, and Paths - A Practical Guide

Practical File Operations in Java: Create, Delete, Write with File/Path

Exploring Path Methods and File System Interactions in Java NIO.2

Directory Listing Mastery: Exploring Files with list, walk, and find

Advanced File Tree Traversal: Implementing walkFileTree in Java

File Tree Navigation Challenge: Mastering Practical File System Tasks

Classic Java I/O: Reading Text Files Using FileReader and BufferedReader

Mastering the Scanner Class for Flexible Text Input Processing in Java

Character Sets, Encodings (UTF-8, ASCII), and NIO.2 Text File Reading

Challenge: Text Processing and Word Frequency Analysis in Java

Java Output: Writing Text Data to Files (Files.write, BufferedWriter)

Java Writers: BufferedWriter, FileWriter, PrintWriter - Features and Usage

Comprehensive File Writing in Java: Creating a JSON Data File Challenge

Mastering Java File Operations: Rename, Copy, Delete, and Move Files

Advanced File Copy and Delete: Recursive Directory Handling in Java

Practical Directory Navigation: Building and Indexing a File System

Deep Dive into Java's RandomAccessFile for Efficient Binary Data Handling

Implementing Advanced Data Retrieval: RandomAccessFile Indexing in Java

Random File Operations: Design a Program for Employee Data Management

Mastering Binary Data I/O: Utilizing DataOutputStream and DataInputStream

Introduction to Java Object Serialization: Persisting Objects to Files

Advanced Serialization: Version Control, Transient Fields and Customisation

Understanding Processes and Threads in Java: An Introductory Overview

Deep Dive into Java Thread States and Concurrent Thread Execution

Implementing Multithreading: Concurrent Thread Creation Best Practices

Managing and Manipulating Running Threads in Java: Sleep and Interrupt

Applying Thread Concepts: Build a Multi-Threaded Application in Java

Exploring Java's Memory Model: Heap vs. Thread Stack in Multithreading

Advanced Concurrency: Interleaving, Atomicity, Memory Consistency Explained

Implementing Synchronization: Mastering Synchronized Methods in Java

Advanced Synchronization: Deep Dive into Synchronized Blocks in Java

Building a Producer-Consumer Application in Java, Deadlock Exploration

Preventing Deadlocks in Java: Practical Techniques Using Wait and Notify

Producer Consumer Challenge: Build a Java Shoe Warehouse Fulfillment Center

Explicit Locking in Java Concurrency: Exploring java.util.concurrent.locks

Advanced Locking: Exploring the Benefits and Uses of ReentrantLock in Java

Thread Management with ExecutorService: SingleThreadExecutorService in Java

Efficient Thread Management: Exploring FixedThreadPool ExecutorService in Java

Advanced Thread Pools: Exploring Callable, Submit, and Future in Java

Practical Concurrency: ExecutorService Challenge in Java Development

Java Concurrency: Mastering ScheduledExecutorService for Task Scheduling

Java Concurrency: Exploring WorkStealingPool and ForkJoinPool Explained

Parallel Streams in Java: Enhancing Performance with Concurrent Data Processing

Deep Dive into Parallel Streams: Ordering, Reducing, and Collecting in Java

Mastering Thread Safety: Synchronized and Concurrent Collections in Java

Building Robust Applications: Thread-Safe Lists, Queues, and ArrayBlockingQueue

Implementing Consumer Tasks: Mastering ArrayBlockingQueue in Java Concurrency

Thread Contention: Understanding and Avoiding Deadlock, Livelock, Starvation

Concurrency Challenges: Understanding and Avoiding Livelock in Java

Preventing Thread Starvation: Implementing Fair Locks in Java Concurrency

Exploring Advanced Java Concurrency: Atomic Variables and WatchService

Implementing a File Watcher with Java's WatchService for Real-Time Monitoring

Introduction to Java Database Connectivity (JDBC) and Relational Databases

Step-by-Step MySQL Server and Workbench Installation Guide for Windows OS

Installing MySQL Server & Workbench: A Comprehensive Guide for Mac Users

Installing MySQL Server and Workbench on Linux: A Step-by-Step Guide

Understanding Databases: RDBMS, Schema, Tables, SQL, DDL, and DML Explained

Hands-On with MySQL Workbench: Creating, Importing, and Querying Databases

JDBC Fundamentals: Connecting Java Applications to Databases with Drivers

Establishing Database Connections in Java: DriverManager vs DataSource

Retrieving Data with JDBC: Crafting and Executing SQL SELECT Queries

Secure Coding with JDBC: Preventing SQL Injection and Using ANSI SQL Standards

Mastering Statement.execute vs. Statement.executeQuery for Database Operations

Comprehensive SQL Operations in Java: Updating, Deleting, & Inserting Data

Efficient Database Updates: executeUpdate, Transactions, Commits, Rollback, and

Creating the 'Store Front' Database: DDL Operations and SQL Exception Handling i

Hands-On JDBC: Building a Database Application with Transactions & Data Operatio

Preventing SQL Injection with Parameterized JDBC PreparedStatement Objects

Enhancing Database Efficiency: Batch Processing with PreparedStatements

Comprehensive JDBC Challenge: Transactions, Alter, Batch Processing Operations

Leveraging Stored Procedures in Databases Through JDBC CallableStatement

Mastering OUT and INOUT Parameters in JDBC with CallableStatement Objects

Executing Database Functions Using CallableStatement and JDBC Escape Sequences

Advanced JDBC Challenge: Calling Stored Procedures with IN and OUT Parameters

An Overview of Object-Relational Mapping, JPA Providers, and Jakarta Persistence

Implementing CRUD Database Operations in Java: Entity Lifecycle Management

Establishing Table Relationships and Managing Related Data with JPA Entities

Mastering Dynamic Data Retrieval with JPQL: Select, From, Where, and Joins

Mastering Advanced JPQL Queries: Joins, Named Parameters, and Tuple Results

Building Dynamic and Type-Safe JPA Queries: A Comprehensive CriteriaBuilder Guid

Comprehensive JPA Challenge: Build Entities, Relationships, JPQL Queries

Mastering JPA: Advanced CriteriaBuilder Queries with Dynamic Joins (Bonus)

Java Networking Fundamentals: Internet, Networks, and Core Java API Overview

Essential Network Terminology: Hosts, Client-Server, Protocols, Ports & IP

Building a Basic Java Client-Server Application with ServerSocket (TCP/IP)

Enhancing Server Scalability: Implementing a Multi-Threaded Java Server

Comparing ServerSocket and ServerSocketChannel: Blocking vs. Non-Blocking IO

Deep Dive into Java NIO: Understanding Channels and Buffers for Networking

Practical Java NIO: ByteBuffer Operations, Capacity, Limit, and Position

Implementing Efficient Network Polling with Custom Java Channel Management

Java Networking: Building Scalable Servers using Event-Driven Selectors

Creating UDP Client and Server in Java using Datagram Sockets

Streaming Audio over UDP: Building a Datagram Client-Server Application in Java

Building an Asynchronous UDP Server in Java using DatagramChannel

Navigating Java's High-Level APIs: Understanding URIs, URLs and Connections

Decoding Relative vs. Absolute URIs and Converting to URLs in Java

Getting Started with HttpURLConnection for Making HTTP Requests in Java

Rapid Web Server Development: Setting Up a Simple Java HTTP Server

Sending Data with HTTP POST Requests Using Java's HttpURLConnection

Modern Java Networking: Transitioning to HttpClient for HTTP/2 and Beyond

Streamlining HTTP POST Requests and Responses with Java's HttpClient

Java Asynchronous HTTP Requests: Leveraging CompletableFuture with HttpClient

Exploring CompletableFuture: thenAccept, thenApply and thenRun methods

Executing Multiple Concurrent HTTP Requests Using Java's HttpClient

Challenge: Submitting multiple concurrent POST HTTP requests using HttpClient

Creating a Custom Thread Safe Body Handler for Java HttpClient Responses

Understanding WebSockets: Real-Time, Bidirectional Communication in Java

Build a Java WebSocket Chat Application: Client and Server Implementation

Mastering the IntelliJ Debugger: A Practical Introduction

Advanced Debugging Techniques: Stepping, Watches & Control

Field Watchpoints, Debugging: Track Variable Changes

Mastering Smart Step Into, Set Value & Third-Party Source

Mastering Unit Testing Essentials & JUnit Framework in Java

Mastering Assertions: Essential Techniques for JUnit Testing

JUnit Assertions: Beyond the Basics & Exception Handling

Parameterized Tests: Efficient Data-Driven Testing in JUnit

Hands-On JUnit: Challenges to Hone Your Testing Skills - 1&2

Completing JUnit Challenges 3 to 7: Advanced Techniques

JUnit Final Challenges : Mastering Scenarios 8,9 and 10

Configuring JavaFX with JDK 11+: Setting Up Global Libraries

Step-by-Step Guide to Creating Your First JavaFX Application

JavaFX Fundamentals: MVC, Application Lifecycle, and Stages

Building a JavaFX "Hello World" Program: FXML vs. Code

Mastering JavaFX GridPane Layout: Positioning and Sizing Controls

Maximising space with the JavaFX Hbox layout

Mastering the JavaFX BorderPane Layout for Application Design

Exploring JavaFX Layouts: FlowPane, TilePane, and StackPane

Exploring JavaFX Controls: Buttons, Labels, and User Interaction

Implementing Radio Buttons & Checkboxes in JavaFX Applications

JavaFX User Input: Combo Box and Choice Box Controls Deep Dive

JavaFX Interactive Controls: Slider, Spinner, ColorPicker, DatePicker

JavaFX TitledPane and Accordion: Organizing UI Elements

Mastering JavaFX Event Handling: Responding to User Actions

Advanced JavaFX Event Handling: Parameters and Best Practices

Optimizing JavaFX Applications: Mastering the UI Thread and Event Handling

Concurrency in JavaFX: Implementing Background Tasks with Threads & Runnable

JavaFX Project: Creating a To-Do List Application & Data Model Setup

JavaFX ListView: Populating, Single Selection Mode & Event Handling Basics

JavaFX Event Handling: Adding a Change Listener for Dynamic UI Updates

JavaFX Date Formatting: Enhancing the User Interface with Date Formatting

Implementing Singletons: Best Practices for Java Application Development

JavaFX Disk Operations: Loading and Saving Data using the File System

JavaFX Dialogs: Building User Input Forms with DialogPane and GridPane

JavaFX Dialogs, Handling User Input and Displaying Program Output

Bug Fixing, Data Binding, and UI Updates in JavaFX ToDo List App

Data Binding Mastery: Implementing Observable Lists for Dynamic UI in JavaFX

JavaFX Cell Factories: Customizing ListView Display and Highlighting Items

JavaFX Context Menus: Implementing Right-Click Functionality for ListViews

Implementing Key Events and Toolbars for Enhanced Functionality

Enhancing JavaFX Applications Implementing Sorted Lists for Dynamic Data Display

Filtering Data in JavaFX: Utilizing FilteredList for Dynamic Content Management

Elevating Visuals: Enhancing Appearance with CSS Styling

JavaFX Transformations: Mastering Node Rotation, Scaling, and Visual Effects

Implementing File and Directory Choosers in JavaFX for Enhanced File Access

Leveraging SceneBuilder: A Visual Approach to JavaFX UI Design within IntelliJ

Installing and Setting up Scenebuilder on Windows

Installing SceneBuilder for macOS: Step-by-Step Setup and IntelliJ Integration

SceneBuilder Deep Dive: Exploring the Interface, Layouts, and Control Properties

Constructing a Basic UI Layout, using SceneBuilder for JavaFX Development

Deep Dive Into SceneBuilder's Code Section and CSS

Contacts Manager Project, Part One, Setting up Project

Contacts Manager Project, Part Two, Design and Layout

Contacts Manager Project, Part Three, Show Dialog, Button Press and Contact

Contacts Application: Enhancing Functionality with Edit and Delete Features

JavaFX Contact Deletion, Confirmation, and Table Resizing Implementation

Comprehensive Introduction to Java Modules: Concepts, Goals, and Structure

Mastering Java Module Declarations and Statements: Requires, Exports, and Opens

Exploring Java Module Types: Named, Unnamed, Automatic, Open, and Aggregator

Project Setup and Initial JDK 8 & 9 Compatibility Testing for Migration

Strategically Structuring a Java Project for Modularization in JDK 9

Creating the First Module (Common): Package Migration and Dependency Resolution

Module Descriptor File Creation and Resolution of JavaFX Runtime Errors

Creating the Second Module (Database): Dependency Management and Code Migration

Challenge: Create and Configure the UI Module, Resolving Dependencies

Understanding and Implementing Transitive Dependencies for Simplified Module

Introduction To The Course

Remaster in Progress

Video Quality

Subtitles

How to Get Help

Important Tip - Source Code

Biggest Tip to Succeed as a Java Programmer

Software Tools Introduction

Java Development Kit Installation Overview

Install JDK 11 for Windows

Installing Intellij IDEA for Windows

Install JDK 11 for Mac

Installing Intellij IDEA for Mac

Install JDK 11 for Linux

Installing Intellij IDEA for Linux

Configuring IntelliJ IDEA - WINDOWS, MAC and LINUX

Introduction

Hello World Project

Defining the Main Method

Hello World Challenge and Common Errors

Variables

Starting out with Expressions

Primitive Types

Byte, short, long and width

Casting in Java

Primitive Types Challenge

Float and double Primitive Types

Floating Point Precision and a Challenge

The char and boolean Primitive Data Types

Primitive Types Recap and the String Data Type

Operators, Operands and Expressions

Abbreviating Operators

If-then Statement

Logical and Operator

Logical OR Operator

Assignment Operator VS Equals to Operator

Ternary Operator

Operator Precedence and Operator Challenge

First Steps Summary

End of Remaster

Introduction

Keywords And Expressions

Statements, Whitespace and Indentation (Code Organization)

Code Blocks And The If Then Else Control Statements

If then else Recap

Methods In Java

More On Methods And A Challenge

Method Challenge - Final Code Changes

DiffMerge Tool Introduction

Install DiffMerge

Using DiffMerge

Coding Exercises

Coding Exercises Example Part 1

Coding Exercises Example Part 2

Coding Exercises Example Part 3

Method Overloading

Method Overloading Recap

Seconds and Minutes Challenge

Bonus Challenge Solution

Introduction

The switch statement (+Challenge Exercise)

Day of the Week Challenge

The for Statement (+Challenge Exercise)

For Loop Recap

Sum 3 and 5 Challenge

The while and do while statements (+Challenge Exercise)

While and Do While Recap

Digit Sum Challenge

Parsing Values from a String

Reading User Input

Problems and Solutions

Reading User Input Challenge

Min and Max Challenge

Arrays

Arrays (Challenge Exercise)

Arrays Recap

References Types vs Value Types

Minimum Element Challenge

Reverse Array Challenge

List and ArrayList Part 1

ArrayList Part 2

ArrayList Part 3

ArrayList Challenge Part 1

ArrayList Challenge Part 2

ArrayList Challenge Part 3

Bug Fix for ArrayList Challenge

Autoboxing and Unboxing

Autoboxing & Unboxing (Challenge Exercise) - Part 1

Autoboxing & Unboxing (Challenge Exercise) - Part 2

Autoboxing & Unboxing (Challenge Exercise) - Part 3

LinkedList Part 1

LinkedList Part 2

LinkedList Part 3

LinkedList Challenge Part 1

Bug Fix for "Track 1" Error

LinkedList Challenge Part 2

LinkedList Challenge Part 3 (Final video)

Interfaces

Interfaces Part 2

Interfaces Challenge Part 1

Interfaces Challenge Part 2

Inner classes Part 1

Inner Classes Part 2

Inner Classes Challenge

Abstract Classes Part 1

Abstract Classes Part 2

Interface vs Abstract Class

Abstract Class Challenge Part 1

Abstract Class Challenge Part 2

Abstract Class Challenge Part 3 (includes recursion).

Generics Introduction

Our Generics Class

Our Generics Class Part 2

Our Generics Class Part 3

Generics Challenge

Lambda Expressions Introduction

Lambda Expressions Continued

Lambda Expressions Nested Blocks

Scope and Functional Programming

Functional Interfaces & Predicates

More on Predicates & Suppliers

Functions

Chaining java.util.function Functions

Lambda Challenge Part 1

Lambda Challenge Part 2

Streams

Streams - Intermediate and Terminal Operations

Streams - Flatmap & Lambda Best Practices

Naming Conventions

Packages

Packages Part 2

Packages Part 3

Packages (Challenge Exercise)

Scope

Scope Part 2 and Visibility

Scope +(Challenge Exercise)

Access Modifiers

The static statement

The final statement

Final Part 2 and Static Initializers

Collections Overview

Binary Search

Collections List Methods

Comparable and Comparator

Maps

Map Continued and Adventure Game

Adding Exits to the Adventure game

Adventure Game challenge

Immutable Classes

Immutable Class Challenge

Sets & HashSet

HashSet - equals() and hashCode()

Finish off equals() and hashcode()

Potential issue with equals() and sub-classing

Sets - Symmetric & Asymmetric

Finishing Off Sets

Sets Challenge Part 1

Sets Challenge Part 2

Sets Challenge Part 3

Sorted Collections

StockList Class With Maps

Add a Basket

TreeMap and Unmodifiable Maps

Challenge Part 1

Challenge Part 2

Challenge Part 3

Challenge Part 4 (Final)

Exceptions

Stack Trace and Call Stack

Catching and throwing Exceptions

Multi Catch Exceptions

Introduction to I/O

Writing content - FileWriter class and Finally block

Try with Resources

FileReader and Closeable

BufferedReader

Load Big Location and Exits Files

Challenge

Buffered Writer and Challenge

Byte Streams

Reading Binary Data and End of File Exceptions

Object Input Output including Serialization

Finish Object I/O and RandomAccessFile class

Create Random Access File

Update Static Initializer Block With Random File Access

Update Adventure Game to Read Random Access File

Java NIO

Writing Objects With Java NIO

Reading and Writing with Java NIO

Writing Binary Files with Java NIO

Reading Files with NIO

Absolute and Relative Reads

Chained Put Methods

Writing Sequentially

FileChannel to Copy Files and Pipes with Threads

Filesystem

More on Paths

Exists and CopyFile

Move, Rename and Delete

File Attributes

Read Existing Directory Contents

Separators Temp Files and File Stores

Walk File Tree

Copy Entire Tree

Mapping IO and NIO Methods

Regular Expressions Introduction

Character classes and Boundary Matchers

Quantifiers and the Pattern and Matcher classes

Matcher find and Group Methods

And, Or & Not

Regular Expressions Challenge Part 1

Regular Expressions Challenge Part 2

Regular Expressions Challenge Part 3

Section Introduction

Database Terminology

Install and Setup SQLite for Windows

Install and Setup SQLite for Mac

Install and Setup SQLite for Linux

Introduction to SQLite

More with SQLite

Querying Data With SQL

SQL Order by and Joins

More Complex Joins

Wildcards in Queries and Views

Housekeeping and Final SQL Challenge

JDBC and SQLite GUI Browser

Creating Databases With JDBC in Java

JDBC Insert, Update, Delete

.executeQuery() and using Constants

The Music SQLite Database

Write Java Query for Artists

Executing SQL in DB Browser

Query Albums by Artist Method

Query Artists for Song method

Result Set Meta Data

Functions and Views

Write the Method to Query View

SQL Injection Attacks and Prepared Statements

Transactions

Inserting Records With JDBC

Insert Albums, Artists, and Songs

Test Insert JDBC Code

JDBC with a GUI Program

Add Artists

Fix Artist and Preload Records

Implement Artist Query

Add ProgressBar

Handling Updates

Networking Overview

First Client and Server Apps

Multi Threaded Server

Multi-Threading and Timeouts

UDP Server and Client

High Level APIS

URL Connections and Input Stream Reader

HTTPUrlConnection

Alternatives to HTTPUrlConnection

Old JavaFX Introduction Video for JDK 8

Old JavaFX Code Vs FXml Video for JDK 8

Bonus Lecture and Information