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
- Analogy
- Instead of standing at the deli counter, you get a pager that buzzes when your order is ready. While waiting, you can order drinks (another async operation), and when both complete, automatically sit down to eat—all without blocking your thread.
- Lesson 554 — How HashMap Uses hashCode for Bucket SelectionLesson 1765 — Optional.ofNullable(): Safe Wrapping of Nullable ValuesLesson 1921 — Flushing and Closing: flush() and close() MethodsLesson 2022 — PrintWriter vs BufferedWriterLesson 2168 — Why Java Strings Are ImmutableLesson 2523 — Performance Benefits of Module PathLesson 2777 — What is CompletableFuture and Why Use It?
- 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?
- capacity
- Think of it like a parking lot analogy: size is the number of cars currently parked, while capacity is the total number of parking spaces that exist.
- Lesson 1002 — Initial Capacity and the Default ConstructorLesson 1004 — The size vs capacity DistinctionLesson 1011 — ArrayList's Internal Array and Capacity ConceptLesson 1059 — Capacity vs Size in HashSetLesson 1123 — Understanding Load Factor: Capacity vs Size
- 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
- Annotation is compiled into the .class file but not loaded into the JVM at runtime
- Lesson 304 — What Is a Class? Blueprint for ObjectsLesson 305 — Declaring a Class: Syntax and Naming ConventionsLesson 2379 — Annotation Retention and Runtime Availability
- 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
- condition
- The condition is a boolean expression (just like in if statements).
- Lesson 126 — The Ternary Operator: Syntax and Basic UsageLesson 156 — The while Loop: Basic Syntax and Execution Flow
- 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
- Debugging
- Encoding bugs are notoriously difficult to track down after the fact
- Lesson 769 — Wrapping Exceptions: throw new Exception(cause)Lesson 2044 — Character Encoding and Charset Parameters
- 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 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 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
- expression body
- x -> x * 2 — the result is automatically returned
- Lesson 1703 — Expression Body: Single Statement LambdasLesson 1705 — Explicit return in Block Bodies
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?
- false
- The key is invalid (directory deleted, watch service closed, etc.)
- Lesson 1964 — The ready() Method: Non-Blocking ChecksLesson 2100 — Resetting the WatchKey for Continued Monitoring
- 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
- keyMapper
- A Function that extracts or computes the key from each element
- Lesson 1519 — Collectors.toMap() with Key and Value MappersLesson 1552 — Collectors.toMap(): Basic Key-Value Mapping
- 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
- load factor
- The load factor is a threshold (typically 0.75) that determines when the hash table should resize.
- Lesson 1054 — Initial Capacity and Load Factor in HashSetLesson 1057 — What Is Load Factor in HashSet?Lesson 1123 — Understanding Load Factor: Capacity vs Size
- 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
- Maintenance burden
- Adding one nullable field means hunting down every usage
- Lesson 1462 — Removing peek in Production CodeLesson 1755 — Traditional null Checking: Verbose and Error-Prone
- 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
- MyClass
- the name you choose for your class
- Lesson 305 — Declaring a Class: Syntax and Naming Conventions
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 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 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()
- off
- the starting index (offset) in the array
- Lesson 1908 — The write(byte[]) and write(byte[], int, int) Methods
- 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
- 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
- Factory methods are optimized with specialized implementations for small sizes
- Lesson 1214 — ArrayDeque as a Stack: Implementation ChoiceLesson 1263 — Comparing Factory Methods with Java 9+ Collection Factories
- 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
- 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
- private
- private is like a personal diary—only you (the class) can read it
- Lesson 698 — Member-Level Access Modifiers: The Four OptionsLesson 2124 — Declaring an Explicit serialVersionUID
- 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
- The official API of your class. Only expose what's necessary for outside code.
- Lesson 10 — The main Method: Entry Point of ExecutionLesson 305 — Declaring a Class: Syntax and Naming ConventionsLesson 326 — The Four Access Levels in JavaLesson 335 — Comparing Access Levels: A Decision Matrix
- 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
- Readability
- String::toUpperCase is shorter and clearer than s -> s.toUpperCase()
- Lesson 475 — Practical Benefits: Avoiding DowncastsLesson 1266 — Collections.addAll: Bulk Addition with VarargsLesson 1429 — map with Method References
- 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-circuit evaluation
- This is called short-circuit evaluation.
- Lesson 110 — Short-Circuit Evaluation in && and ||Lesson 140 — Short-Circuit Evaluation: Efficiency and Safety
- 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
- Think of it like a parking lot analogy: size is the number of cars currently parked, while capacity is the total number of parking spaces that exist.
- Lesson 1002 — Initial Capacity and the Default ConstructorLesson 1004 — The size vs capacity DistinctionLesson 1011 — ArrayList's Internal Array and Capacity ConceptLesson 1059 — Capacity vs Size in HashSetLesson 1123 — Understanding Load Factor: Capacity vs Size
- 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
- 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
- StackOverflowError
- The call stack is exhausted (usually from infinite recursion)
- Lesson 776 — When to Catch Error: Almost NeverLesson 782 — VirtualMachineError and LinkageError: System-Level Errors
- 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 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
- 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
- true
- The key is still valid and will continue monitoring
- Lesson 1964 — The ready() Method: Non-Blocking ChecksLesson 2100 — Resetting the WatchKey for Continued Monitoring
- 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 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 -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
- valueMapper
- A Function that extracts or computes the value from each element
- Lesson 1519 — Collectors.toMap() with Key and Value MappersLesson 1552 — Collectors.toMap(): Basic Key-Value Mapping
- 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
- VirtualMachineError
- The JVM itself is broken or corrupted
- Lesson 775 — Error vs Exception: Two Branches of ThrowableLesson 776 — When to Catch Error: Almost Never
W
- Wait for both
- The combined future completes only when both inputs complete
- Lesson 2825 — Understanding thenCombine: Combining Independent Futures
- 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 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