← Back to Java

Java Glossary

Key terms from the Java course, linked to the lesson that introduces each one.

448 terms.

A

abstract class
An abstract class is a class marked with the abstract keyword that cannot be instantiated on its own.
Lesson 477 — What Are Abstract Classes?Lesson 478 — The abstract Keyword for Classes
abstract method
An abstract method is a method declaration with no body—just a signature followed by a semicolon.
Lesson 479 — Abstract Methods: Signature Without Body
Adding elements at the end
list.add(item) is typically quick
Lesson 980 — ArrayList vs LinkedList: Access Patterns Matter
after
Called after all entries in a directory have been visited.
Lesson 2087 — FileVisitor Interface and Its Methods
all three threads
Now all three threads are stuck in a circular dependency.
Lesson 2694 — Deadlock with Multiple Threads and Resources
allMatch returns true
Surprising! But logically sound—there are no elements that violate the condition.
Lesson 1538 — Match Operations on Empty Streams
Amazon Corretto
For beginners, Adoptium or Amazon Corretto are excellent choices.
Lesson 3 — Choosing a JDK Distribution: Oracle, OpenJDK, and Others
annotation processor
An annotation processor is a special tool that runs during compilation to examine annotations in your source code and optionally generate new files.
Lesson 2452 — What Are Annotation Processors?
anonymous array creation
This is called anonymous array creation because the array has no name—it's created and used immediately.
Lesson 239 — Anonymous Array Creation
anonymous class
An anonymous class is a one-time, unnamed implementation created right where you need it—perfect for creating custom Comparator instances inline.
Lesson 640 — What Are Anonymous Classes?Lesson 641 — Anonymous Class SyntaxLesson 1329 — Implementing Comparator with Anonymous Classes
anyMatch returns false
Makes sense—if there are no elements, there's nothing that could match.
Lesson 1538 — Match Operations on Empty Streams
APPEND
Writes are added to the end of the file rather than overwriting from the beginning. Perfect for log files or accumulating data.
Lesson 2051 — OpenOption: Controlling Write Behavior
ArrayList
Wastes space in unused capacity (~33-50% overhead after growth), but each element is just one reference
Lesson 1031 — Vector vs ArrayList: Key DifferencesLesson 1042 — Memory Overhead: ArrayList Capacity vs LinkedList Nodes
Autoboxing
Autoboxing is Java's automatic conversion of primitive types to their corresponding wrapper classes.
Lesson 904 — Autoboxing with Generic Collections
AutoCloseable
AutoCloseable is the more general parent interface for any resource that needs cleanup.
Lesson 824 — AutoCloseable vs Closeable
Automatic module
All packages like com.legacy.api, com.legacy.internal, com.legacy.util are automatically exported—no hiding internals
Lesson 2539 — Automatic Modules Export All Packages

B

Backed by an Array
Under the hood, ArrayDeque maintains a circular array. This means both head and tail operations are extremely fast—typically faster than LinkedList for the same operations.
Lesson 1202 — What is ArrayDeque? Overview and Purpose
base case
The base case is like finally reaching a box that contains something you want instead of another box.
Lesson 225 — The Base Case: Preventing Infinite Recursion
before
The secret is the setDaemon(boolean) method, which must be called before the thread starts.
Lesson 2087 — FileVisitor Interface and Its MethodsLesson 2620 — Setting a Thread as Daemon
Best-effort search
Multiple search strategies where any acceptable result is sufficient
Lesson 2767 — Use Cases: invokeAll vs invokeAny
binary classification
This is called binary classification—dividing data into two mutually exclusive categories.
Lesson 1578 — Understanding partitioningBy and Binary Classification
Binary data
Binary data consists of raw bytes that represent non-textual information: images (.jpg, .png), videos, compiled programs (.class files), ZIP archives, or serialized objects.
Lesson 1930 — Binary Data vs Text Data
block scope
This is called block scope—the variable's lifetime is limited to the block where it was declared.
Lesson 187 — Scope in if Statements
boolean expression
A boolean expression is any piece of code that evaluates to either true or false.
Lesson 54 — Boolean Expressions and Comparison Results
boolean literals
These are called boolean literals — the actual values you assign to boolean variables.
Lesson 62 — Boolean Literals: true and false
bottom-up strategy
The bottom-up strategy means you identify which libraries and components have no dependencies on other parts of your codebase (the "leaves" of your dependency tree) and modularize those first.
Lesson 2526 — The Bottom-Up Migration Strategy
bucket
Internally, it maintains an array where each position is called a bucket.
Lesson 1102 — HashMap Structure: Arrays of Buckets

C

call stack
The call stack is a data structure that Java uses to keep track of active method calls in your program.
Lesson 748 — What Is the Call Stack?
capture helper method pattern
The capture helper method pattern is a technique where you create a private generic helper method that "captures" the unknown wildcard type into a concrete type parameter.
Lesson 956 — Capture Helper Methods Pattern
chaining
HashMap uses a strategy called chaining to handle collisions.
Lesson 1107 — Collision Handling: Chaining Strategy
Changing a field's type
A String becoming an int can't be safely converted
Lesson 2126 — Compatible vs Incompatible Class Changes
Changing field types
A field that was String is now Integer
Lesson 2164 — Versioning Problems and Class Evolution
checked exception
A checked exception is an exception the compiler forces you to handle at compile-time.
Lesson 2593 — InterruptedException: A Checked Exception
Checked exceptions
Checked exceptions are exceptions the compiler actively monitors.
Lesson 783 — The Two Categories: Checked and Unchecked Exceptions
Circular references
Circular references are equally dangerous: Object X references Y, Y references X.
Lesson 2160 — The Billion Laughs Attack and Resource Exhaustion
Class-level type parameters
Class-level type parameters are declared on the class itself and are visible throughout the entire class—in all instance fields, constructors, and methods.
Lesson 862 — Type Parameter Scope: Class-Level vs Method-Level
ClassFormatError
A .class file is corrupted or has an incompatible format.
Lesson 782 — VirtualMachineError and LinkageError: System-Level Errors
classifier function
The classifier function is the heart of this operation—it's a function that examines each element and returns a key that determines which group (bucket) that element belongs to.
Lesson 1568 — Basic groupingBy Syntax and Classifier Functions
ClassNotFoundException
ClassNotFoundException is a checked exception that occurs when your code explicitly tries to load a class by name at runtime (using reflection or similar mechanisms), but Java can't find it.
Lesson 807 — ClassNotFoundException and NoClassDefFoundError
classpath
The classpath is a list of locations that tells the Java Virtual Machine (JVM) where to search for class files when your program executes.
Lesson 689 — The Classpath: Finding Classes at RuntimeLesson 2516 — Classpath Mechanics: How the JVM Finds Classes
Classpath order problems
If you have multiple versions of the same class, the wrong one might load first. Remember: classes are loaded from left to right in your classpath.
Lesson 693 — Common Classpath Issues and ClassNotFoundException
Clearer separation of concerns
Path represents locations; the Files utility class performs operations
Lesson 2025 — Introduction to NIO.2 and the Path Interface
Cloning final fields
Remember, clone() conflicts with final fields when you need to replace them with deep copies. This is a design smell suggesting better alternatives exist.
Lesson 570 — Clone Best Practices and Common Pitfalls
Closeable
Closeable is specifically designed for I/O resources like files and streams.
Lesson 824 — AutoCloseable vs Closeable
closure
This ability to "capture" and reference external variables is called variable capture, and the lambda with its captured variables forms what's known as a closure.
Lesson 1718 — What Is Variable Capture in Lambdas?
Cluttered
The ceremony obscures your actual logic
Lesson 452 — The Boilerplate Problem: Test-Cast-Use Pattern
coarse-grained locking
This is called coarse-grained locking — one big lock protecting the entire data structure.
Lesson 1154 — Synchronization Overhead in Hashtable
code point
Unicode is a universal standard that assigns a unique number (called a code point) to virtually every character from every writing system on Earth.
Lesson 1999 — Unicode: The Universal Character Set
Collections Framework
The Collections Framework is Java's standardized architecture for representing and manipulating groups of objects.
Lesson 967 — The Collections Framework: Purpose and Design
Comparator complexity
A complex compare() method (one that does expensive computations) gets called O(n log n) times. Optimize your comparators or pre-compute keys when possible.
Lesson 1364 — Sorting Performance Considerations
Comparator factory methods
Comparator factory methods are static methods that generate Comparator instances for common patterns.
Lesson 1337 — Introduction to Comparator Factory Methods
Compiler optimizations
The compiler may reorder operations or cache values in registers
Lesson 2680 — The Visibility Problem: Why volatile Exists
Completion trigger
The returned future completes when all input futures complete (successfully or exceptionally)
Lesson 2854 — CompletableFuture.allOf: Waiting for All Tasks
Connection failures
The database server is unreachable, credentials are wrong, or the database doesn't exist
Lesson 806 — SQLException: Database Access Errors
constructor
A constructor is a special method that runs automatically whenever you create a new object using the new keyword.
Lesson 310 — Constructors: Special Methods for Object Creation
Constructor initialization
Constructor initialization is best when:
Lesson 349 — Field Initialization: Declaration vs Constructor
Constructors
this refers to the object being created
Lesson 316 — What is this? The Implicit Object Reference
copy constructor
A copy constructor is a constructor that takes an instance of the same class and copies its state.
Lesson 568 — When Not to Use clone: Alternatives
Correctness
Non-ASCII characters (like emoji, accented letters, or other languages) are preserved
Lesson 2044 — Character Encoding and Charset Parameters
cost of traversing the stream twice
The cost of traversing the stream twice is significant (large data, expensive operations)
Lesson 1614 — When to Use teeing vs Separate Collectors
covariant return types
This is called covariant return types—the return type can "vary" in one direction (downward in the inheritance tree, toward more specific types).
Lesson 419 — Return Type Compatibility in OverridingLesson 470 — What Are Covariant Return Types?
CREATE
Creates the file if it doesn't exist. If the file already exists, this option alone does nothing special (the file is opened).
Lesson 2051 — OpenOption: Controlling Write Behavior
Critical
If your String or enum variable is null, the switch will throw a NullPointerException at runtime. Always ensure your variable isn't null before switching, or handle it explicitly with an if check first.
Lesson 148 — Switch with String and Enum Types
Custom load factor
Custom load factor is a space-time trade-off:
Lesson 1064 — Custom Initial Capacity and Load Factor

D

daemon thread
A daemon thread is a low-priority background thread that provides services to user threads.
Lesson 2618 — What Are Daemon Threads?
Daemon threads
Daemon threads are the background staff (janitors, HVAC systems).
Lesson 2619 — User Threads vs Daemon Threads
dayOfWeek
The target day (like DayOfWeek.MONDAY)
Lesson 1881 — dayOfWeekInMonth: Nth Occurrence of a Day
Deadlock
Threads are mutually blocked, none can proceed
Lesson 2705 — What Is Starvation?
Declaration
Declaration means you're announcing that a variable exists and what type of data it will hold.
Lesson 243 — Array Declaration vs Instantiation
Declaration initialization
Declaration initialization is best when:
Lesson 349 — Field Initialization: Declaration vs Constructor
Default
Quick throws when no details are needed
Lesson 816 — Constructors: Message, Cause, and Both
default initialization
However, it doesn't have a useful value yet—Java automatically sets it to 0 (called default initialization).
Lesson 27 — Declaring and Initializing int Variables
Default methods
Default methods are like "standard procedures" that every employee inherits and can customize if needed.
Lesson 518 — Static Methods vs Default Methods: Key Differences
defensive copying
In many object-oriented programs, defensive copying is a technique where you create a copy of a mutable object before passing it to another method or returning it from a method.
Lesson 2172 — Defensive Copying Is Unnecessary
Degraded performance
The application slows down as resources pile up.
Lesson 848 — The Problem of Resource Leaks
Design intent
Some classes represent complete, immutable concepts that shouldn't be specialized. The String class in Java is final—you cannot create a custom subclass of String.
Lesson 427 — The final Keyword on Classes
dest
the destination array (the new, larger array)
Lesson 1008 — System.arraycopy: The Reallocation Mechanism
Devirtualization
If the JIT determines only one implementation is ever used at a call site, it replaces dynamic dispatch with a direct call
Lesson 468 — Performance Implications of Dynamic Dispatch
DirectoryStream
A lazy iterator that fetches directory entries one-by-one as you loop through them. Think of it like reading a book page-by-page—you only see what you're currently reading.
Lesson 2080 — DirectoryStream vs Files.list: When to Use Which
Documentation suffers
The relationship between components isn't visible in the code structure
Lesson 2396 — Maintaining Code with Reflection
Domain-specific errors need identification
An InsufficientFundsException tells you more than a generic IllegalStateException
Lesson 821 — Best Practices: Avoiding Exception Overuse
Downcasting
Downcasting is the reverse operation: you explicitly cast a superclass reference back to a subclass type to regain access to those subclass-specific features.
Lesson 443 — What is Downcasting?
Duplicate elements appear
The set can contain what should be duplicates because different hash codes send "equal" objects to different buckets.
Lesson 558 — HashSet Breakage: The Same Root Cause
Duration
Duration represents time-based amounts: hours, minutes, seconds, and nanoseconds
Lesson 1857 — Duration vs Period: Temporal Amounts in java.time
dynamic dispatch
This mechanism is called dynamic dispatch or runtime polymorphism because Java decides which method to execute at runtime based on the actual object, not the reference type.
Lesson 442 — Dynamic Dispatch with Upcast References

E

Eases debugging
Smaller scope means fewer places where things can go wrong
Lesson 193 — Best Practices for Variable Scope
Easier reasoning
the object's state at construction is its state forever
Lesson 727 — Immutability and final: Defensive Access Control
Effectively final
A local variable is effectively final if it's never reassigned after initialization
Lesson 634 — Accessing Local Variables from Local Classes
Efficient insertions in the middle
Once you're at the right position, insertion is quick
Lesson 991 — LinkedList: Doubly-Linked Structure Basics
Efficient with expensive sources
If reading elements is costly (database queries, network calls), limit() prevents fetching more than necessary.
Lesson 1414 — Intermediate Short-Circuiting: limit Operation
Encapsulation
On the classpath, all public types are accessible to everyone. On the module path, only explicitly exported packages are accessible.
Lesson 619 — Static Nested Classes vs Top-Level ClassesLesson 2517 — Module Path Introduction: A New Way to Organize Code
Encounter order
Encounter order is the defined sequence in which a stream source produces its elements.
Lesson 1544 — Encounter Order and Its Impact on find Operations
enhanced for loop
The enhanced for loop is a control structure that works directly with any Iterable.
Lesson 1490 — forEach vs Enhanced for Loop
enum
An enum (enumeration) is a special Java type that defines a fixed set of named constants.
Lesson 578 — What Are Enums and Why They Matter
escape sequence
An escape sequence is a backslash (\) followed by a special character code.
Lesson 49 — Character Literals and Escape Sequences
Example scenario
A Shape class might have a protected method calculateArea() that all shape subclasses need to implement or call, but external code shouldn't invoke directly.
Lesson 330 — protected: Inheritance and Package Access
Exception
In the exception hierarchy, Exception represents conditions that a well-written application should anticipate and catch.
Lesson 777 — Exception as the Base for Application Problems
exception masking
This is called exception masking, and it's a common source of confusion and lost debugging information.
Lesson 737 — Exceptions Thrown from finally Blocks
Exception style
If someone asks for a table when the list is full, the host loudly announces "We're full!" (throws exception). The conversation stops; everyone must react.
Lesson 1171 — Exception-Throwing vs Returning-Special-Value Methods
exceptions
Runtime errors (also called exceptions) are problems that occur while your program is executing.
Lesson 15 — Understanding Runtime Errors
Exhaustiveness
Exhaustiveness means accounting for every possible value your variable might have.
Lesson 146 — The default Case and Exhaustiveness
Explicit versioning
Schema evolution is built-in and controlled
Lesson 2165 — Alternatives to Java Serialization
exports
the keyword that declares visibility
Lesson 2481 — Basic exports Syntax in module-info.java
Exports everything
All packages are implicitly exported
Lesson 2515 — Modular JARs vs Non-Modular JARs at Runtime
Exports everything to itself
All packages in the unnamed module are accessible to other classpath code
Lesson 2469 — Unnamed Modules and Compatibility

F

factory
A factory is a design pattern that centralizes object creation logic.
Lesson 1670 — Suppliers for Factory Patterns
fail-fast behavior
Fail-fast behavior means that when you're iterating over a collection and that collection gets modified (outside the iterator itself), the iterator immediately throws a ConcurrentModificationException rather than continuing with potentially corrupted data.
Lesson 1157 — Iterators and ConcurrentModificationExceptionLesson 1290 — ConcurrentModificationException with ListIteratorLesson 1300 — What Is Fail-Fast Behavior?
Faster startup
Less code to load means quicker initialization.
Lesson 2544 — What is jlink and Why Custom Runtime Images Matter
Favor package-private over protected
Only use protected when inheritance-based extension is truly needed
Lesson 712 — Cross-Package Access Patterns and Best Practices
Fewer Resources to Save
A thread context switch only needs to save and restore:
Lesson 2559 — Context Switching Costs
fields
Instance variables, also called fields, are variables declared inside a class but outside any method.
Lesson 306 — Fields: Instance Variables in a ClassLesson 356 — Initialization Order with Constructor Chaining
File streams
The operating system might buffer more data than available() reports
Lesson 1909 — The available() Method and Stream Availability
File tree walking
File tree walking is the process of systematically visiting every file and directory in a tree structure, starting from a root directory and recursively exploring all branches.
Lesson 2084 — Introduction to File Tree Walking
Filter before map
Filter before map means fewer transformations:
Lesson 1482 — Combining map and filter
Filter first
Reduce your dataset as soon as possible. Every element you eliminate early means less work for downstream operations.
Lesson 1487 — Operation Order and Performance
final
The value cannot be changed after initialization
Lesson 2124 — Declaring an Explicit serialVersionUID
finisher
The finisher is the fourth component of the Collector interface.
Lesson 1619 — Finisher: Transforming the Accumulator to Final Result
First parameter
The result of type T (or null if an exception occurred)
Lesson 2844 — The handle Method: Signature and Purpose
for-each
Java provides a simplified syntax called the enhanced for loop (also known as for-each) that lets you iterate over every element in an array without touching indices at all.
Lesson 171 — The Enhanced for Loop (for-each): Syntax and Purpose
forEach terminal operation
The forEach terminal operation is part of a functional pipeline.
Lesson 1490 — forEach vs Enhanced for Loop
Forgetting to clone nested objects
The shallow copy trap. Always review every field and clone mutable references.
Lesson 570 — Clone Best Practices and Common Pitfalls
format specifiers
Both accept a format string with placeholders called format specifiers, followed by values to insert at those positions.
Lesson 2019 — printf and format: Formatted Output
forRemoval
A boolean indicating whether the element is scheduled for removal in a future version
Lesson 2410 — @Deprecated with since and forRemoval (Java 9+)
Frequent iteration
Looping through all elements is very fast
Lesson 980 — ArrayList vs LinkedList: Access Patterns Matter
Frequent small operations
The lock overhead becomes significant relative to the actual work
Lesson 1251 — Performance Implications of Synchronized Wrappers
fromIndex
The starting index (inclusive) where sorting begins
Lesson 267 — Arrays.sort with Custom Range
functional interface
A functional interface is an interface with exactly one abstract method (like Comparator, Runnable, or custom interfaces you create).
Lesson 650 — Anonymous Classes as Functional Interface ImplementationsLesson 1330 — Comparator as a Functional InterfaceLesson 1624 — Definition of a Functional InterfaceLesson 2570 — Runnable as a Functional Interface
Fusion optimization
The JVM can combine multiple operations into a single pass over the data
Lesson 1406 — Why Laziness Matters for Performance

G

generic class
A generic class is like a template that can hold or operate on different types without knowing in advance what those types will be.
Lesson 856 — Declaring a Generic Class with a Single Type Parameter
generic method
A generic method is a method that declares its own type parameters, separate from any class-level generics.
Lesson 865 — What Are Generic Methods?
generic static methods
For these scenarios, generic static methods are the perfect tool.
Lesson 870 — Generic Static Methods: Utility Method Patterns
Get compile-time type safety
The compiler prevents you from putting an Integer into a Box<String>
Lesson 858 — Instantiating Generic Classes with Type Arguments
getters
By making fields private and providing public methods (often called getters and setters, or more broadly, an API), you:
Lesson 723 — Prefer private Fields with Controlled Public Methods
Glob patterns
Glob patterns are simple wildcard expressions:
Lesson 2076 — Filtering Directory Entries with Glob Patterns
Granular handling
Granular handling means catching specific exception types with targeted responses:
Lesson 764 — Granular vs General Exception Handling
Grouping operations
organizing stream elements into categories (like grouping by key)
Lesson 1522 — Why collect Is the Gateway to Advanced Collectors
groups
In regular expressions, groups are portions of a pattern enclosed in parentheses ().
Lesson 2263 — What Are Groups in Regular Expressions?

H

hash
The pre-calculated hash code (stored for efficiency)
Lesson 1106 — Bucket Contents: Linked List Nodes
hash collisions
By the pigeonhole principle, multiple different objects must share the same hash code—these are called hash collisions.
Lesson 551 — The Cantor Principle: Why the Contract Is Not Bidirectional
HashMap
HashMap is general-purpose—it works with any object as a key, computes hash codes, handles collisions, and maintains buckets.
Lesson 601 — Introduction to EnumMap: A Specialized Map for Enum Keys
HashSet
Iteration order is unpredictable and may change over time (even between runs)
Lesson 1080 — Iterating LinkedHashSetLesson 1082 — Memory Overhead Considerations
Hashtable
Hashtable is like a building constructed with built-in vault walls—security is part of the structure itself.
Lesson 1156 — Thread Safety: Hashtable vs Collections.synchronizedMap
hasNext
a predicate that continues iteration while true (like i < 10)
Lesson 1379 — Bounded iterate() with Predicate (Java 9+)
High read-to-write ratio
If 90% of operations are reads, you're unnecessarily blocking readers from each other
Lesson 1251 — Performance Implications of Synchronized Wrappers
higher load factor
A higher load factor means more entries per bucket on average, leading to longer collision chains (or more tree bins) but using memory more efficiently.
Lesson 1123 — Understanding Load Factor: Capacity vs Size
Holidays
Independence Day is July 4th, regardless of time zones
Lesson 1836 — LocalDate: Representing Dates Without Time
How to run it
The execution policy hidden behind the implementation
Lesson 2710 — The Executor Interface: Decoupling Task Submission from Execution
Human readability
JSON and XML are easy to inspect and debug
Lesson 2165 — Alternatives to Java Serialization
Human-readable
Represents dates as they appear on calendars: year-month-day (2024-03-15).
Lesson 1836 — LocalDate: Representing Dates Without Time
hysteresis
This is called hysteresis — using different thresholds for going up versus coming down.
Lesson 1120 — Untreeification: Converting Back to Linked Lists

I

If no match exists
A new node is added to the end of the chain
Lesson 1108 — put() Operation: Insertion Process
IllegalArgumentException
A method received an inappropriate argument
Lesson 793 — Understanding RuntimeException and Unchecked Exceptions
IllegalStateException
You called a method when the object wasn't ready for it. For example, trying to read from a closed connection.
Lesson 790 — When to Use Unchecked Exceptions: Programming Errors
Immediate effect
The deletion happens synchronously—when the method returns, the file is gone
Lesson 2060 — Files.delete: Deleting Files and Directories
Immutability
Immutability means the object's state truly cannot change after creation—no methods exist to modify it, and all its fields are unchangeable.
Lesson 75 — final vs ImmutabilityLesson 2167 — What Immutability Means for Strings
Immutability guarantee
String is immutable. Subclasses could add mutable fields, violating assumptions throughout the JDK.
Lesson 429 — final Classes in the JDK: String and Wrappers
Immutable
The collection itself cannot change, period—no matter who has a reference to it
Lesson 1238 — What Are Unmodifiable Collections?
implementations
The Service Provider Interface (SPI) is a design pattern where an interface (or abstract class) is defined by one module, but implementations are discovered and loaded dynamically at runtime from other modules.
Lesson 2498 — The Service Provider Interface (SPI) Pattern
import statements
For classes you use frequently in a file, import statements are the standard choice.
Lesson 678 — When to Use FQNs vs Import Statements
Important limitation
Even if you set @Retention(RetentionPolicy.RUNTIME), local variable annotations are not retained at runtime. They vanish after compilation because local variables don't exist in bytecode the same way fields or methods do. This makes them primarily useful for compiler checks and development-time tooling.
Lesson 2448 — ElementType.LOCAL_VARIABLE: Annotating Local Variables
Improves readability
the intent is immediately clear
Lesson 1337 — Introduction to Comparator Factory Methods
In-place operation
The original list is modified directly; no extra memory for a copy
Lesson 1230 — Reverse Internals: How Swapping Works
Incompatible types
You pass a String where an Integer is expected
Lesson 2349 — Type Safety and IllegalArgumentException Risks
Independence
The class has value and meaning on its own, used by multiple unrelated classes
Lesson 619 — Static Nested Classes vs Top-Level Classes
IndexOutOfBoundsException
You accessed an array or list with an invalid index. This is a logic error in your loop or calculation.
Lesson 790 — When to Use Unchecked Exceptions: Programming Errors
Infinity
Represents a positive value too large to express (like 1.0 / 0.0)
Lesson 44 — Special Values: Infinity, -Infinity, and NaN
Initialization
Initialization means giving your variable its first real value.
Lesson 27 — Declaring and Initializing int Variables
Inlining
The JIT can't inline a reflective call because it doesn't know what code to insert. Direct calls let the compiler embed small method bodies directly, eliminating call overhead entirely.
Lesson 468 — Performance Implications of Dynamic DispatchLesson 2402 — JIT Compilation Limits with Reflection
inner class
An inner class is a class declared inside another class, without the static keyword.
Lesson 622 — What Are Inner Classes?Lesson 623 — Declaring an Inner Class
Input Parameter
exceptionally takes a Function<Throwable, T> where T matches your future's result type. The parameter is the exception that occurred.
Lesson 2836 — Basic exceptionally Syntax and Return Type
InputStream
InputStream is the abstract superclass for all classes that read bytes.
Lesson 1904 — The InputStream and OutputStream Abstract Classes
instance initializer block
An instance initializer block is a block of code enclosed in curly braces { } that appears directly inside a class body (not inside any method or constructor).
Lesson 352 — Instance Initializer Blocks
Instance methods
Instance methods are overridden — the JVM uses the actual object's type at runtime to decide which version to call (dynamic dispatch)
Lesson 316 — What is this? The Implicit Object ReferenceLesson 466 — Hiding vs Overriding: Static Method Behavior
Instantiation
This is called instantiation, and it happens when you combine the new keyword with a constructor call.
Lesson 243 — Array Declaration vs InstantiationLesson 313 — Creating Objects: Using new with Constructors
instantiation with type arguments
This is called instantiation with type arguments.
Lesson 874 — Creating Instances of Generic Classes
InstantiationException
InstantiationException is thrown when you try to create an instance of a class that can't be instantiated.
Lesson 811 — ReflectiveOperationException Hierarchy
IOException
IOException is the parent class for most file operation errors.
Lesson 2053 — Exception Handling for File Read/Write Operations
iterator
An iterator is an object that lets you walk through a collection one element at a time, without needing to know how the collection stores its data internally.
Lesson 1272 — What Is an Iterator and Why Use It?

J

jagged arrays
These are called jagged arrays (or ragged arrays).
Lesson 258 — Jagged Arrays: Non-Rectangular Structures
JAR file
A JAR file (Java ARchive) is a single compressed file that bundles multiple compiled .class files, resources (like images or configuration files), and metadata into one convenient package.
Lesson 684 — What Is a JAR File?
Java Compiler
This verifies the Java Compiler is accessible.
Lesson 7 — Verifying Your Installation with java -version
jdeps
jdeps is your primary tool for detecting internal dependencies:
Lesson 2529 — Identifying Internal API Dependencies

K

Keys
Keys are like the words you look up (must be unique)
Lesson 973 — Map Interface: Key-Value Associations

L

Lazily evaluated
The stream doesn't process anything until you invoke a terminal operation
Lesson 1384 — stream() Method on Collections
Lazy
The entire pipeline remains dormant until a terminal operation appears
Lesson 1480 — Understanding the Pipeline Pattern
lazy evaluation
This is called lazy evaluation or deferred execution.
Lesson 1669 — Lazy Evaluation with Suppliers
Lazy Loading
Providers are instantiated on-demand as you iterate, not all at once.
Lesson 2504 — Loading Services with ServiceLoader.load()
LinkedHashSet
LinkedHashSet is like photos in an album with captions and page numbers—each photo needs extra space for the organizational metadata
Lesson 1082 — Memory Overhead Considerations
local class
A local class is a class you declare inside a method, constructor, or initializer block—right where you'd normally write statements.
Lesson 632 — What Are Local Classes?Lesson 633 — Declaring and Instantiating Local Classes
Lock scope
Lock scope is how much code executes while holding a lock.
Lesson 2699 — Avoiding Nested Locks and Minimizing Lock Scope
loop control variable
A loop control variable is a variable that determines when a loop starts, continues, or stops.
Lesson 158 — Loop Control Variables and Counting Patterns
lost update
This is called a lost update, and it's one of the most common and dangerous race conditions.
Lesson 2646 — Lost Updates: The Classic Problem
lower load factor
A lower load factor means more empty buckets, which reduces collision chains and maintains O(1) performance.
Lesson 1123 — Understanding Load Factor: Capacity vs Size
LRU Caches
An LRU (Least Recently Used) cache needs to track which items were accessed most recently. LinkedHashMap can maintain access order (a special mode beyond insertion order), making it perfect for cache eviction policies. You can identify the oldest-accessed items to remove when the cache fills up.
Lesson 1081 — Use Cases for Insertion Order

M

main
The specific name the JVM looks for (must be lowercase "main")
Lesson 10 — The main Method: Entry Point of Execution
Maintainability
Adding or removing a condition means adding/removing one line, not editing a complex boolean expression.
Lesson 1425 — Chaining Multiple filter Operations
Making fields transient
The field is ignored during serialization going forward
Lesson 2164 — Versioning Problems and Class Evolution
marker interface
A marker interface is an interface with no methods or constants—it exists purely to tag a type with a capability or characteristic.
Lesson 530 — Marker Interfaces vs Empty Abstract Classes
marker interfaces
Surprisingly, these marker interfaces are entirely valid and useful in Java.
Lesson 494 — Empty Interfaces: Marker Interfaces
Massive arrays
Storing millions of values where memory is tight
Lesson 46 — When to Use double Over float
Memory efficiency
No temporary collections means lower memory overhead, especially important for large datasets
Lesson 1214 — ArrayDeque as a Stack: Implementation ChoiceLesson 1409 — No Intermediate Storage
Memory matters
Timsort requires O(n) extra space for merging. If memory is extremely constrained and stability isn't required, you might need custom solutions—though this is rare in modern applications.
Lesson 1364 — Sorting Performance Considerations
meta-annotation
A meta-annotation is an annotation that annotates other annotations.
Lesson 2449 — ElementType.ANNOTATION_TYPE: Meta-Annotations
method reference
A method reference is shorthand for a lambda that simply delegates to an existing method.
Lesson 654 — Method References as Further Simplification
method references
Java provides a shorthand notation called method references that makes these predicates even more readable when the lambda simply calls a single method.
Lesson 1422 — Method References in filter
method signature
The method signature is the unique identifier Java uses for this purpose.
Lesson 206 — What Is a Method Signature?
Method-level type parameters
Method-level type parameters are declared on individual methods and exist only within that specific method's scope.
Lesson 862 — Type Parameter Scope: Class-Level vs Method-Level
Mixed workloads
Reads remain fast even while writes are happening, thanks to non-blocking read operations.
Lesson 1165 — Performance Characteristics: Read vs Write Operations
modular JAR
A modular JAR is simply a JAR file that contains a compiled module-info.class file at its root.
Lesson 2508 — What Are Modular JARs?Lesson 2509 — Creating a Modular JAR with javac and jar
module path
The module path is a new way to specify where the JVM should look for modules at compile-time and runtime.
Lesson 2517 — Module Path Introduction: A New Way to Organize Code
monitor
Every single object in Java—whether it's a String, ArrayList, your custom class instance, or even a plain Object—has an intrinsic lock (also called a monitor) built into it.
Lesson 2653 — The Implicit Lock (Monitor) of an Object
monitor lock
In Java, every single object has an intrinsic lock (also called a monitor lock or simply monitor).
Lesson 2662 — Intrinsic Locks and Monitor Objects
Monitor upstream projects
Many libraries are actively adding module support
Lesson 2543 — Migration Strategy: From Automatic to Explicit Modules
most common mistake
The most common mistake is placing super() anywhere except the very first line of a constructor:
Lesson 413 — Common Pitfalls with super in Constructors
multidimensional array
In Java, a multidimensional array is simply an array where each element is itself another array.
Lesson 253 — What Are Multidimensional Arrays?
Multiple methods needed
The interface has more than one abstract method
Lesson 649 — When to Prefer Lambdas Over Anonymous Classes
mutator
A setter (also called a mutator) is a method that allows controlled modification of a private field.
Lesson 340 — Standard Setter Method Naming and Structure

N

Natural ordering
Natural ordering is the default comparison logic built into a class that defines how its objects should be sorted.
Lesson 1309 — What Is Natural Ordering?
nested for loop
A nested for loop is simply a loop inside another loop.
Lesson 170 — Nested for Loops: Processing Multidimensional Data
nested while loop
A nested while loop is simply a while loop placed inside the body of another while loop.
Lesson 162 — Nested while Loops and Common Pitfalls
newChar
the character you want to substitute in
Lesson 2201 — The replace Method: Replacing Characters
next
A reference to the next Node in the chain (or null if this is the last)
Lesson 1106 — Bucket Contents: Linked List NodesLesson 1379 — Bounded iterate() with Predicate (Java 9+)
No compiler help
The compiler won't warn you if you forget to check
Lesson 1755 — Traditional null Checking: Verbose and Error-Prone
No ConcurrentModificationException
The iterator cannot detect modifications because it's working with its own copy
Lesson 1306 — CopyOnWriteArrayList: A Fail-Safe Example
No duplicate logic
The iteration code already exists in HashMap
Lesson 1053 — HashSet Iterator: Iterating HashMap Keys
No encapsulation
All public classes in all JARs are globally accessible
Lesson 2516 — Classpath Mechanics: How the JVM Finds Classes
No exceptions
The iterator never throws ConcurrentModificationException, even if other threads modify the map
Lesson 1307 — ConcurrentHashMap and Weakly Consistent Iterators
No explicit dependencies
The JVM doesn't know what your application needs until runtime failure occurs
Lesson 2516 — Classpath Mechanics: How the JVM Finds Classes
No hash collisions
Each enum ordinal is unique by definition
Lesson 603 — EnumMap Performance: Array-Based Implementation
No instance fields
Interfaces cannot hold state (instance variables). Any fields you declare are automatically public static final constants—shared by all, not unique to each instance.
Lesson 495 — Interfaces vs Abstract Classes: Initial Comparison
No Manual Configuration
The module system handles discovery automatically—no classpath scanning or configuration files needed.
Lesson 2504 — Loading Services with ServiceLoader.load()
No pointer chasing
Direct array access is fast
Lesson 1227 — Performance Characteristics of Sorting
No recovery
Unlike some systems with "recycle bins," this is permanent deletion
Lesson 2060 — Files.delete: Deleting Files and Directories
No runtime type information
At runtime, Box<String> and Box<Integer> are both just Box containing Object references
Lesson 893 — Type Parameters Become Object
No time zone context
LocalDate doesn't know about time zones. It's "local" in the sense that it represents a date as it would appear wherever you are, but it doesn't store where you are.
Lesson 1836 — LocalDate: Representing Dates Without Time
No unnecessary synchronization
Operations are fast in single-threaded contexts
Lesson 1211 — Why Deque Is Preferred Over Stack Class
No wasted transformations
If only 10 elements are needed from a million-element stream, only those 10 get processed
Lesson 1406 — Why Laziness Matters for Performance
NoClassDefFoundError
You checked the catalog earlier (compilation), the book was listed, but when you go to the shelf (runtime), it's mysteriously gone or damaged. This is an unexpected system-level problem.
Lesson 782 — VirtualMachineError and LinkageError: System-Level ErrorsLesson 807 — ClassNotFoundException and NoClassDefFoundError
noneMatch returns true
Also makes sense—there are no elements that match.
Lesson 1538 — Match Operations on Empty Streams
NoSuchFileException
NoSuchFileException is thrown when you try to list a directory that simply doesn't exist on the filesystem.
Lesson 2082 — Error Handling: NoSuchFileException and AccessDeniedException
Not guaranteed
The method makes a "best effort" but may skip zero bytes in some cases
Lesson 1910 — The skip(long) Method for Skipping Bytes
Not Thread-Safe
Like most collection classes (except the concurrent ones), ArrayDeque is not synchronized for concurrent access.
Lesson 1202 — What is ArrayDeque? Overview and Purpose
Not truly behavioral contracts
Marker interfaces are pure metadata; empty abstract classes imply (incorrectly) that there might be shared code.
Lesson 530 — Marker Interfaces vs Empty Abstract Classes
Null handling
One null is allowed (subsequent nulls are duplicates)
Lesson 1550 — Collectors.toSet(): Collecting into a Set
Null permitted
Both null keys and null values are allowed
Lesson 997 — HashMap: Key-Value Pairs with Hashing
NullPointerException
You tried to use an object reference that's null. This means you forgot to check for null or initialize something properly.
Lesson 790 — When to Use Unchecked Exceptions: Programming Errors

O

object
the element to repeat (can even be null)
Lesson 1259 — Collections.nCopies: Repeated Elements
object graph
This connected network of objects is called an object graph.
Lesson 2110 — Serialization and Object Graphs
Object-oriented design
It feels more natural to ask a list to sort itself rather than hand it to an external utility. The list is responsible for its own behavior.
Lesson 1357 — Sorting Lists with List.sort()
offer methods
offer methods are polite requests — they simply tell you "sorry, can't do that" by returning false
Lesson 1204 — Adding Elements: addFirst, addLast, offerFirst, offerLast
oldChar
the character you want to replace
Lesson 2201 — The replace Method: Replacing Characters
only job
A method reference works when your lambda's only job is to call an existing method with the parameter(s) it receives.
Lesson 1735 — What Are Method References?
OpenJDK
The completely free, open-source version that Oracle JDK is based on. Think of it as the community edition. No licensing fees, ever.
Lesson 3 — Choosing a JDK Distribution: Oracle, OpenJDK, and Others
Optimization opportunity
Because intermediate operations are lazy, Java can optimize the pipeline. For example, if you filter first and then map, Java only maps the elements that pass the filter—not all elements.
Lesson 1403 — Intermediate Operations Are Lazy
Oracle JDK
The original from Oracle Corporation. It requires a paid license for production use in some cases, but is free for learning and development. It comes with commercial support options.
Lesson 3 — Choosing a JDK Distribution: Oracle, OpenJDK, and Others
Order guarantee
The iterator order must match the queue's retrieval order
Lesson 1173 — Queue Iteration Order and Iterator Behavior
Order preserved
The returned list matches the input collection's order
Lesson 2758 — invokeAll: Executing Multiple Callables
Organization
The classpath treats all code as one giant pool with no boundaries. The module path recognizes distinct modules with explicit dependencies.
Lesson 2517 — Module Path Introduction: A New Way to Organize Code
original list
Changes to the original list are still reflected in the unmodifiable view, because they share the same underlying data.
Lesson 1239 — Collections.unmodifiableList: Read-Only Lists
OutOfMemoryError
The JVM has exhausted available heap memory and cannot allocate more objects. This typically means your application created too many objects or has a memory leak.
Lesson 775 — Error vs Exception: Two Branches of ThrowableLesson 776 — When to Catch Error: Almost NeverLesson 782 — VirtualMachineError and LinkageError: System-Level Errors
OutputStream
OutputStream is the abstract superclass for all classes that write bytes.
Lesson 1904 — The InputStream and OutputStream Abstract Classes
Overall time complexity
O(n) where n is total stream size
Lesson 1448 — Performance Implications of distinct on Large Streams
overloading
Overriding and overloading are both ways to have multiple methods with the same name, but they serve different purposes:
Lesson 416 — Overriding vs Overloading

P

package
A package is a namespace that groups related classes together and keeps them separate from other classes with the same name.
Lesson 658 — What Are Packages and Why They Matter
Package-private
Package-private is like sharing with your immediate team (same package)
Lesson 698 — Member-Level Access Modifiers: The Four Options
Parameter Passing
The simplest alternative is passing context data explicitly through method parameters. Yes, this might require updating multiple method signatures ("parameter drilling"), but it makes dependencies obvious:
Lesson 2641 — ThreadLocal Alternatives and When to Avoid It
PATH
The PATH is like a shortcut list your operating system maintains.
Lesson 6 — Adding Java to Your System PATH
Performance boost
Processing stops as soon as the limit is satisfied.
Lesson 1414 — Intermediate Short-Circuiting: limit Operation
Performance optimizations
The JVM optimizes String and wrapper classes aggressively (string pooling, unboxing). Subclasses would break these optimizations.
Lesson 429 — final Classes in the JDK: String and Wrappers
Period
Period represents date-based amounts: years, months, and days
Lesson 1857 — Duration vs Period: Temporal Amounts in java.time
Pitfall #1
Forgetting that Date.toInstant() always represents UTC. If the original Date was implicitly treated as local time, you'll lose hours.
Lesson 1903 — Migration Checklist and Common Pitfalls
Poor cache performance
Nodes are scattered across memory
Lesson 1227 — Performance Characteristics of Sorting
positive lookbehind
A positive lookbehind is a zero-width assertion that checks whether a certain pattern exists immediately before the current position in the string.
Lesson 2305 — Positive Lookbehind Syntax: (?<=...)
Postal codes
Checking that input is exactly the right format
Lesson 2256 — Using matches() for Full String Validation
Precision
.2 means two decimal places for floats
Lesson 2228 — Formatting Numbers with Precision
predefined character classes
Instead of writing [0-9] to match digits or [ \t\n\r] for whitespace, Java regex offers convenient shortcuts called predefined character classes.
Lesson 2297 — Predefined Character Classes: \d, \w, \s
Preventing split packages
Preventing split packages is critical for maintaining a clean architecture
Lesson 2524 — Migration Strategy: When to Use Module Path vs Classpath
Prevents accidental bugs
no setter methods means no one can corrupt your data
Lesson 727 — Immutability and final: Defensive Access Control
primary exception
The primary exception is the first exception thrown from your main try block.
Lesson 842 — Primary vs Suppressed Exceptions
Principle of Least Privilege
The Principle of Least Privilege means giving each part of your code the minimum level of access it needs to do its job—nothing more.
Lesson 337 — The Principle of Least Privilege
process
A process is an independent, isolated instance of a running program.
Lesson 2553 — Process: An Independent Program Instance
Processes
Processes are completely isolated by the operating system.
Lesson 2558 — Crash Isolation: Process Safety
producer
A producer is any collection or data structure you're only reading from or getting data out of.
Lesson 940 — Producers: When to Use '? extends T'
Profile-guided optimization
The runtime learns which implementations are most common and optimizes accordingly
Lesson 468 — Performance Implications of Dynamic Dispatch
Public Constructor
The default choice for most classes. Anyone can create instances freely.
Lesson 334 — Access Modifiers on Constructors

Q

Queue
A Queue is a collection interface that processes elements in first-in-first-out (FIFO) order—just like a line at a coffee shop.
Lesson 971 — Queue Interface: FIFO Processing

R

R1
The result type of the first downstream collector. For example, if you use counting(), this would be Long.
Lesson 1608 — The teeing Method Signature and Type Parameters
R2
The result type of the second downstream collector. It can be completely different from R1.
Lesson 1608 — The teeing Method Signature and Type Parameters
race condition
A race condition is a bug that occurs when the correctness of your program depends on the unpredictable timing or sequence of thread execution.
Lesson 2642 — What Is a Race Condition?
Random access
Random access means jumping to different file positions frequently.
Lesson 1954 — Disk I/O Latency and Sequential vs Random Access
Random access by index
Getting list.get(500) is nearly instant
Lesson 980 — ArrayList vs LinkedList: Access Patterns Matter
raw type
A raw type is a generic class or interface used without any type arguments.
Lesson 882 — What Are Raw Types?
read-modify-write
These steps are called read-modify-write, and they are not atomic — meaning another thread can interrupt between any of these steps.
Lesson 2644 — Why count++ Is Not Atomic
read-only property
This is called a read-only property or immutable property.
Lesson 345 — Read-Only Properties: Getters Without Setters
Reads all other modules
The unnamed module can access all exported packages from named modules on the module path
Lesson 2469 — Unnamed Modules and Compatibility
Reentrancy
Reentrancy means a lock can be acquired multiple times by the same thread that currently holds it.
Lesson 2671 — What Is Reentrancy?
Reflection-friendly
All packages are open for deep reflection
Lesson 2515 — Modular JARs vs Non-Modular JARs at Runtime
regex
A regular expression pattern to search for (though you can use simple literal strings too)
Lesson 2203 — replaceFirst: Replacing Only the First Occurrence
reified generics
However, languages like C# and Kotlin chose a different path called reified generics, where type parameters remain available at runtime.
Lesson 966 — Reified Generics in Other Languages: What Java Lacks
Reliability
The classpath allows duplicate classes and missing dependencies to fail at runtime. The module path validates the module graph at startup, catching errors early.
Lesson 2517 — Module Path Introduction: A New Way to Organize Code
Reliable configuration
Missing dependencies are detected at compile-time and startup, not randomly at runtime.
Lesson 2461 — Introduction to JPMS and the Module System
Removing a field
The serialized stream contains data for a field that no longer exists in the class. Java throws InvalidClassException.
Lesson 2128 — Removing or Renaming Fields: Breaking Changes
replacement
The string to substitute for the first match
Lesson 2203 — replaceFirst: Replacing Only the First Occurrence
Resource scheduling
The JVM scheduler or OS may favor certain threads over others
Lesson 2705 — What Is Starvation?
Return Type
It returns CompletableFuture<T> with the same type as the original future. If no exception occurs, the original value passes through unchanged. If an exception occurs, your fallback value is used instead.
Lesson 2836 — Basic exceptionally Syntax and Return Type
Returns
a new string with all replacements made
Lesson 2201 — The replace Method: Replacing Characters
Reusability
The same predicate works everywhere
Lesson 1645 — Predicates for Validation and Business Rules
Round status
processingOver() tells you if this is the final round
Lesson 2457 — The RoundEnvironment and Processing Rounds
runAsync
runAsync is like asking someone to sweep the floor — the action matters, but you don't need anything back
Lesson 2792 — When to Use supplyAsync vs runAsync
RUNTIME
Annotation is compiled into the .class file and available at runtime via reflection
Lesson 2379 — Annotation Retention and Runtime Availability
RUNTIME annotations
RUNTIME annotations are the only ones your reflection code can access using methods like getAnnotation(), getDeclaredAnnotations(), or isAnnotationPresent().
Lesson 2379 — Annotation Retention and Runtime Availability

S

Same type safety
The compiler still enforces types strictly
Lesson 859 — Diamond Operator: Type Inference in Constructors
Second parameter
The exception of type Throwable (or null if successful)
Lesson 2844 — The handle Method: Signature and Purpose
Security
Preventing subclassing ensures no one can override behavior in ways that might compromise the class's guarantees.
Lesson 427 — The final Keyword on Classes
Security checks
verifying permissions if a security manager is active
Lesson 2378 — Performance and Security Considerations
sentinel value
A sentinel value is a special input that signals "stop processing." Think of it like a "STOP" sign at the end of a street—it tells the loop when to quit.
Lesson 161 — Sentinel Values and Input Validation Loops
Sequential access
Sequential access means reading or writing bytes in consecutive order from start to finish.
Lesson 1954 — Disk I/O Latency and Sequential vs Random Access
Sequential processing
Sequential processing is acceptable for your use case
Lesson 1542 — findFirst: Deterministic Element Selection
serialVersionUID
This snapshot gets a unique identifier called a serialVersionUID.
Lesson 2118 — InvalidClassException: Version Mismatches
ServiceLoader
ServiceLoader is built into the JDK and uses module descriptors (uses and provides...with).
Lesson 2507 — Service Loading vs Traditional Dependency Injection
Shallow copy
Shallow copy means primitive fields are duplicated, but reference fields point to the same objects as the original.
Lesson 561 — The Cloneable Interface and Object.clone
short-circuiting
This is called short-circuiting, similar to how the || operator in boolean expressions stops evaluating as soon as it finds a true value.
Lesson 1532 — Understanding Match Operations OverviewLesson 1534 — Short-Circuiting Behavior of anyMatch
sibling exceptions
These are called sibling exceptions—they share a common ancestor (like Exception) but neither is a subclass of the other.
Lesson 760 — Catching Sibling Exception Types
side effect
This "something" is called a side effect—any action that changes state outside the operation itself or interacts with the external world.
Lesson 1492 — Side Effects in forEach
Simple return values work
Returning null, -1, or Optional is often clearer than throwing exceptions for normal "not found" scenarios
Lesson 821 — Best Practices: Avoiding Exception Overuse
Simplicity
The relationship isn't strong enough to justify nesting
Lesson 619 — Static Nested Classes vs Top-Level Classes
since
A string indicating when the element was deprecated (usually a version number)
Lesson 2410 — @Deprecated with since and forRemoval (Java 9+)
Single inheritance constraint
A class can only extend one abstract class, even if it's empty. This wastes your one "parent slot."
Lesson 530 — Marker Interfaces vs Empty Abstract Classes
Single iteration
The stream pipeline executes only once
Lesson 1613 — Performance Benefits of teeing Over Multiple Passes
Single quotes only
'A' is a char, but "A" (double quotes) is something different you'll learn later.
Lesson 48 — The char Type: Representing Single Characters
Single static import
Single static import is generally preferred because:
Lesson 673 — Single Static Import vs Static Import on Demand
Size reduction
A full JRE can exceed 200 MB. A custom image might be 30-50 MB or even smaller, containing only java.base, java.logging, and your application modules.
Lesson 2544 — What is jlink and Why Custom Runtime Images Matter
Skip it for internal utilities
If an interface is private or package-private and only used within your codebase, the annotation adds less value. You already have full control over changes.
Lesson 2421 — Best Practices: When to Use @FunctionalInterface
Smaller payloads
Binary formats like Protocol Buffers are often more compact
Lesson 2165 — Alternatives to Java Serialization
Snapshot-like
Elements present when iteration began are guaranteed to be traversed exactly once
Lesson 1307 — ConcurrentHashMap and Weakly Consistent Iterators
SOURCE annotations
SOURCE annotations are meant for compile-time tools (like @Override or @SuppressWarnings)—they guide the compiler but serve no purpose afterward.
Lesson 2379 — Annotation Retention and Runtime Availability
Special-value style
The host politely says "Sorry, no availability right now" (returns false/null). The customer can easily check and decide what to do next.
Lesson 1171 — Exception-Throwing vs Returning-Special-Value Methods
src
the source array (the old, full array)
Lesson 1008 — System.arraycopy: The Reallocation Mechanism
Stability
Stability means elements that compare as equal maintain their original relative order after sorting.
Lesson 1336 — Comparator Stability and Equals Consistency
stack trace
This snapshot, called a stack trace, shows every method that was active when the exception occurred, listed from the point where the exception was thrown all the way back to the program's entry point.
Lesson 753 — Stack Trace Information
Starvation
One or more threads could proceed but are continuously denied access
Lesson 2705 — What Is Starvation?
static
The JVM must call this method without creating an object first
Lesson 10 — The main Method: Entry Point of Execution
Static import on demand
Static import on demand is convenient when you use many members from one class, but it can make code harder to understand—someone reading sqrt(x) must guess it came from Math.
Lesson 673 — Single Static Import vs Static Import on Demand
static initializer block
A static initializer block (or static block) is a special section of code inside a class that runs exactly once: when the Java Virtual Machine first loads the class into memory.
Lesson 368 — What Are Static Blocks?
static methods
Just like static fields are shared at the class level, static methods are behaviors that belong to the class rather than to individual instances.
Lesson 362 — Declaring static MethodsLesson 466 — Hiding vs Overriding: Static Method BehaviorLesson 518 — Static Methods vs Default Methods: Key Differences
static nested class
A static nested class is a class declared inside another class with the static modifier.
Lesson 614 — What Are Static Nested Classes?Lesson 615 — Declaring and Instantiating Static Nested Classes
Step 2
The combined result is then merged with future3's result
Lesson 2834 — Chaining Multiple thenCombine Operations
String
the return type (cannot change)
Lesson 535 — Overriding toString: Basic Syntax
string literal
A string literal is how you write text directly in your code.
Lesson 61 — String Literals and Escape Characters
StringBuffer
StringBuffer is synchronized (thread-safe but slower), while StringBuilder is unsynchronized (faster, for single-threaded use).
Lesson 2185 — Why StringBuilder and StringBuffer Exist
StringBuilder
StringBuffer is synchronized (thread-safe but slower), while StringBuilder is unsynchronized (faster, for single-threaded use).
Lesson 2185 — Why StringBuilder and StringBuffer Exist
Strong encapsulation
Strong encapsulation is enforced at load time—non-exported packages remain invisible even via reflection (unless opens is used)
Lesson 2498 — The Service Provider Interface (SPI) PatternLesson 2520 — Class Loading Differences: Modules vs Classpath
Strong logical relationship
The nested class exists primarily to support the outer class and rarely makes sense independently (like Map.Entry supporting Map)
Lesson 619 — Static Nested Classes vs Top-Level Classes
Structure
Organizing complex patterns without polluting group numbers
Lesson 2269 — Non-Capturing Groups: (?:...)
supplier
The supplier is the function that creates this initial, empty container at the start of the collection operation.
Lesson 1616 — Supplier: Creating the Mutable Result Container
supplyAsync
supplyAsync is like sending a chef to prepare a dish — you're waiting for food (a result) to come back
Lesson 2792 — When to Use supplyAsync vs runAsync
surrogate pair
But here's the catch: characters outside that range (like emoji, ancient scripts, or rare symbols) need two 16-bit units called a surrogate pair.
Lesson 2001 — UTF-16 and UTF-32
switch expressions
Think of switch statements as a series of instructions to do things (print, modify variables, call methods), while switch expressions are designed to produce a value that you'll use immediately.
Lesson 153 — Switch Expressions vs Statements: When to Use Which
synchronized
synchronized is heavyweight: it guarantees both visibility and mutual exclusion (only one thread executes the critical section at a time).
Lesson 2683 — volatile vs synchronized: When to Use Each
Synchronous execution
The transformation happens in the same thread that completes the prior stage
Lesson 2797 — What thenApply Does: Synchronous Transformation
system call
This boundary crossing is called a system call, and it's surprisingly expensive—taking hundreds to thousands of CPU cycles.
Lesson 1953 — System Call Overhead and User vs Kernel Space

T

Tests become critical
Runtime is the only place these breaks surface
Lesson 2396 — Maintaining Code with Reflection
Text blocks
Text blocks are a special syntax for multi-line string literals, introduced in Java 15.
Lesson 2234 — What Are Text Blocks?
Text data
Text data consists of bytes that represent human-readable characters encoded using a character set (like UTF-8 or ASCII).
Lesson 1930 — Binary Data vs Text Data
thenAccept
thenAccept is like signing for the package and opening it—you need to see what's inside (the result).
Lesson 2813 — Choosing Between thenAccept and thenRun
thenApply
thenApply is like applying a simple calculation: "Take the price and add tax" → you get a number directly
Lesson 2818 — thenCompose vs thenApply: When to Use Which
thenCombine
thenCombine is for combining two independent futures that can run in parallel.
Lesson 2829 — thenCombine vs thenCompose: Key Differences
thenCompose
thenCompose is like triggering another async step: "Take the order ID and fetch customer details from a database" → you get a promise of customer details (another CompletableFuture)
Lesson 2818 — thenCompose vs thenApply: When to Use WhichLesson 2829 — thenCombine vs thenCompose: Key Differences
thenRun
thenRun is like playing a notification sound after delivery—you don't care what's in the box, just that it arrived.
Lesson 2813 — Choosing Between thenAccept and thenRun
Think of groups like labeled boxes
group 0 is the entire package, and groups 1, 2, 3, etc. are individual items inside, numbered by the order they appear in your pattern.
Lesson 2264 — Capturing Groups and Group Numbers
Think of it like
A line at a coffee shop—whoever arrived first gets served first.
Lesson 1218 — Stack vs Queue Trade-offs in Problem Solving
Think of it this way
Enum constants are like unique name tags. There's only one "MONDAY" tag in existence, so you can simply check if two variables point to the same tag using ==.
Lesson 581 — Accessing Enum Constants
thread
A thread is a lightweight path of execution within a process.
Lesson 2554 — Thread: A Lightweight Execution Unit
thread dump
A thread dump is a snapshot of all threads in your JVM at a specific moment, showing what each thread is doing and which locks it holds or waits for.
Lesson 2696 — Detecting Deadlock: Thread Dumps and jstack
Thread safety without synchronization
immutable objects are inherently safe to share
Lesson 727 — Immutability and final: Defensive Access Control
threshold
The threshold is the exact number of elements that, when reached, forces HashSet to rehash.
Lesson 1060 — Threshold: When Rehashing Triggers
Timeout issues
The database took too long to respond
Lesson 806 — SQLException: Database Access Errors
toIndex
The ending index (exclusive) where sorting stops
Lesson 267 — Arrays.sort with Custom Range
top-down migration strategy
The top-down migration strategy is the opposite of bottom-up: you start by converting your own application code into explicit modules, while external libraries and dependencies remain on the classpath or module path as automatic modules.
Lesson 2527 — The Top-Down Migration Strategy
Traditional DI frameworks
Traditional DI frameworks are runtime-heavy solutions that scan classes, read annotations, manage object lifecycles, and inject dependencies automatically.
Lesson 2507 — Service Loading vs Traditional Dependency Injection
traditional indexed for loop
The traditional indexed for loop is necessary when you need:
Lesson 1296 — Enhanced For Loop vs Traditional For Loop
truncation toward zero
This is called truncation toward zero: positive numbers round down, negative numbers round up (toward zero).
Lesson 81 — Precision Loss in Floating-Point to Integer Casts
Type checking
Verifying what something is at runtime
Lesson 2320 — What is the Class Object?
type compatibility
This is called type compatibility or substitutability.
Lesson 401 — Type Compatibility: Subclass Instances as Superclass References
Type erasure
Type erasure means the generic type parameter vanishes at runtime—there's no way to create an array of the exact generic type
Lesson 891 — What Is Type Erasure?Lesson 1001 — The Object Array Backing Store
type parameter
Instead of hardcoding String or Integer, you declare a placeholder (called a type parameter) that will be filled in later when someone uses your class.
Lesson 856 — Declaring a Generic Class with a Single Type Parameter
Type safety happens at compile-time
The compiler inserts casts where needed, but the bytecode has no memory of what T was
Lesson 893 — Type Parameters Become Object
Type Specialization
The JIT thrives on knowing exact types to generate optimized machine code. Reflection's type-erased nature (everything becomes Object) prevents type-specific optimizations.
Lesson 2402 — JIT Compilation Limits with Reflection
type token
A type token is a Class<T> object passed explicitly to preserve type information.
Lesson 898 — Type Tokens and Reification Workarounds

U

U identity
The starting value for your result (of the new type U)
Lesson 1510 — The Three-Argument reduce: Handling Different Types
UnaryOperator
Special case of Function where input and output are the same type
Lesson 1629 — Common Functional Interfaces in java.util.function
unchecked exception
An unchecked exception is any exception that extends RuntimeException (or is RuntimeException itself).
Lesson 785 — What Makes an Exception Unchecked?
Unchecked exceptions
Unchecked exceptions are exceptions the compiler doesn't enforce handling for.
Lesson 783 — The Two Categories: Checked and Unchecked Exceptions
Unicode values
Behind the scenes, each character is stored as a number from 0 to 65,535.
Lesson 48 — The char Type: Representing Single Characters
Union
Union is straightforward—simply list multiple ranges or characters inside one set of brackets, and any character matching any of those ranges will match.
Lesson 2299 — Union and Intersection in Character Classes
Unmodifiable
A view that prevents you from making changes, but the underlying collection can still change
Lesson 1238 — What Are Unmodifiable Collections?
unmodifiable collection
An unmodifiable collection is a read-only view of an existing collection.
Lesson 1238 — What Are Unmodifiable Collections?
unmodifiable list
An unmodifiable list is a wrapper around an existing list that blocks all modification attempts.
Lesson 1239 — Collections.unmodifiableList: Read-Only Lists
unnamed module
The unnamed module is where all classpath code lives.
Lesson 2541 — Reading the Unnamed Module from Automatic Modules
Upcasting
Upcasting is when you treat a subclass instance as if it were an instance of its superclass.
Lesson 439 — What is Upcasting?
Using clone with complex object graphs
If your object has many layers of references, clone() becomes error-prone. Copy constructors or factory methods are often clearer.
Lesson 570 — Clone Best Practices and Common Pitfalls
utility class
A utility class is a class designed to hold a collection of related static methods (and sometimes static fields like constants).
Lesson 385 — What Is a Utility Class?
utility function
A utility function is a method that performs a general-purpose task without needing to know anything about a specific object's state.
Lesson 367 — Common Use Cases for static Methods: Utility Functions

V

vacuous truth
This is called a vacuous truth in logic: a statement about an empty set is considered true because it cannot be falsified.
Lesson 1538 — Match Operations on Empty Streams
Validation
Bean Validation's @NotNull is checked at runtime
Lesson 2438 — RetentionPolicy.RUNTIME Explained
value
The value associated with that key
Lesson 1106 — Bucket Contents: Linked List Nodes
Value -1
A special sentinel indicating end-of-stream
Lesson 1905 — The read() Method: Reading a Single Byte
valueIfFalse
The result if the condition is false
Lesson 126 — The Ternary Operator: Syntax and Basic Usage
valueIfTrue
The result if the condition is true
Lesson 126 — The Ternary Operator: Syntax and Basic Usage
Values
Values are like the definitions (can be duplicated)
Lesson 973 — Map Interface: Key-Value Associations
Values 0-255
The actual byte value, returned as an unsigned integer
Lesson 1905 — The read() Method: Reading a Single Byte
variable capture
This ability to "capture" and reference external variables is called variable capture, and the lambda with its captured variables forms what's known as a closure.
Lesson 1718 — What Is Variable Capture in Lambdas?
Vector
Every method is synchronized, meaning only one thread can access the method at a time. This makes it thread-safe by default.
Lesson 1031 — Vector vs ArrayList: Key Differences
Verbose and repetitive
The cast is redundant—you already proved the type with instanceof
Lesson 452 — The Boilerplate Problem: Test-Cast-Use Pattern
Void
void.class (represents the absence of a return type)
Lesson 2322 — Using .class Literal Syntax

W

Wait for both
The combined future completes only when both inputs complete
Lesson 2825 — Understanding thenCombine: Combining Independent Futures
Weaker consistency
The iterator may show stale data
Lesson 1305 — What Is Fail-Safe Behavior?
What to run
The Runnable task containing your business logic
Lesson 2710 — The Executor Interface: Decoupling Task Submission from Execution
widening conversion
This is called a widening conversion or automatic type promotion.
Lesson 76 — Widening Conversions: Automatic Type Promotion
Works on a snapshot
The iterator sees the collection as it existed when the iterator was created
Lesson 1305 — What Is Fail-Safe Behavior?
Worst case
O(n²) if hash collisions are frequent (rare but possible)
Lesson 1448 — Performance Implications of distinct on Large Streams
Writer
Just as Reader handles character-based input, Writer is the abstract base class for all character-based output in Java.
Lesson 1960 — The Writer Hierarchy: Character-Based Output
Wrong working directory
Running from the wrong folder means relative paths won't resolve correctly. Always verify where your command executes from.
Lesson 693 — Common Classpath Issues and ClassNotFoundException

Z

Zero
this object is equal to the argument
Lesson 1313 — Return Values: Negative, Zero, Positive
Zero doesn't mean empty
available() returning 0 doesn't guarantee the stream is at its end—it just means no bytes are immediately ready
Lesson 1909 — The available() Method and Stream Availability