Java Glossary

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

3,257 terms.

#

A

B

C

D

E

F

G

Game loops: continuously checking input and rendering frames; Lesson 169 — Omitting for Loop Components: Infinite Loops
Game mods: loading custom behavior; Lesson 2392 — Plugin Architectures and Extensibility
Gaps: When clocks jump ahead (e.; Lesson 1852 — Daylight Saving Time Transitions
Garbage collection: (the JVM's built-in daemon thread); Lesson 2618 — What Are Daemon Threads?Lesson 2623 — Common Use Cases for Daemon Threads
Garbage collection pressure: from temporary wrapper objects; Lesson 1388 — IntStream, LongStream, DoubleStream from Primitive Arrays
gatekeeper: , ensuring only valid data gets stored in your private fields.; Lesson 343 — Validation Logic in Setters Lesson 2468 — Module Descriptors and Accessibility Rules
Gather: Use `join()` to wait for all threads to complete before processing their collective results; Lesson 2616 — Common join Patterns: Scatter-Gather
GC behavior: Interned strings now participate in regular heap GC cycles; Lesson 2182 — Intern Pool Location: PermGen vs Metaspace
General handling: uses broader exception types:; Lesson 764 — Granular vs General Exception Handling
General-purpose decimal math: – Java expects `double` by default; Lesson 46 — When to Use double Over float
General-purpose file copying: where file sizes vary; Lesson 1935 — Default Buffer Size: 8KB Explained
Generating a module name: from the JAR filename (e.; Lesson 2535 — What Are Automatic Modules?
Generating patterns: Lesson 2219 — The repeat Method: Duplicating Strings
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 Lesson 872 — Generic Constructors
Generic method calls: where type parameters can't be inferred; Lesson 1731 — Target Type from Cast Expressions
generic static methods: in utility classes where making the entire class generic would be inappropriate or awkward.; Lesson 870 — Generic Static Methods: Utility Method Patterns Lesson 878 — Static Context and Type Parameters
Generic type `T`: = `Integer` (from the argument `42`); Lesson 1733 — Target Typing with Generic Methods
Generic type erasure: At runtime, `ArrayList<String>` and `ArrayList<Integer>` both become just `ArrayList` due to type erasure.; Lesson 960 — Cannot Create Arrays of Parameterized Types
Generic utilities: Tools that operate on any object type; Lesson 2341 — Overview of Method.invoke and Its Purpose
Geographic failover: Querying multiple data centers simultaneously and accepting the first response; Lesson 2767 — Use Cases: invokeAll vs invokeAny
get: (produce) items from it.; Lesson 939 — The PECS Principle: Producer Extends, Consumer Super Lesson 988 — Performance Characteristics Summary: Big-O Complexities
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
Getter/setter protection: when multiple fields must stay consistent; Lesson 2660 — When to Use Synchronized Methods
Getters: (`getFieldName()`) let others *read* a field's value; Lesson 338 — The Purpose of Getters and Setters Lesson 723 — Prefer private Fields with Controlled Public Methods
Glob patterns: are simple wildcard expressions:; Lesson 2076 — Filtering Directory Entries with Glob Patterns
Going down (pushing frames): Lesson 228 — Tracing Recursive Execution: The Call Stack
Good example (concrete type): Lesson 947 — PECS and Return Types: When Not to Use Wildcards
Good names: `com.; Lesson 2463 — Basic Module Declaration Syntax
Good performance: Lesson 1112 — Performance Characteristics: O(1) Average Case
Graceful shutdown: (`shutdown()`) is like announcing "no new customers" at a restaurant while letting everyone already seated finish their meals.; Lesson 2768 — Understanding Graceful vs Immediate Shutdown
Gradual migration: Converting existing code piece-by-piece; Lesson 2032 — Converting Between Path and File
Gradually migrate dependencies: as they release modular versions or as you have time to modularize them yourself; Lesson 2527 — The Top-Down Migration Strategy
Granting reflective access: to all packages by default; Lesson 2535 — What Are Automatic Modules?
Granular handling: means catching specific exception types with targeted responses:; Lesson 764 — Granular vs General Exception Handling
Graph construction: Build a directed graph where nodes are modules and edges are dependencies; Lesson 2470 — Module Graph and Dependencies at Runtime
Graphics/game programming: – Some GPU operations prefer `float`; Lesson 46 — When to Use double Over float
greater than: Is the left value larger?; Lesson 104 — Relational Operators: ==, !=, <, >, <=, >=Lesson 1313 — Return Values: Negative, Zero, Positive
Grids and matrices: `ArrayList<ArrayList<Integer>>`; Lesson 909 — Collections of Collections: Nested Generics
Group 1: = `((A)(B))` — the outermost parentheses (opens first); Lesson 2268 — Nested Groups and Group Numbering
Group 2: = `(A)` — opens second, nested inside group 1; Lesson 2268 — Nested Groups and Group Numbering
Group 3: = `(B)` — opens third, also nested inside group 1; Lesson 2268 — Nested Groups and Group Numbering
Group order might change: during refactoring; Lesson 2275 — Named Groups vs Numbered Groups
Group Related Exceptions: Lesson 765 — Catch Order Best Practices
Grouped by domain: (arrays, collections, objects, math); Lesson 392 — Real-World Examples: Java Standard Library
Grouped data: `ArrayList<HashSet<String>>` for sets of tags per item; Lesson 909 — Collections of Collections: Nested Generics
Grouping operations: organizing stream elements into categories (like grouping by key); Lesson 1522 — Why collect Is the Gateway to Advanced Collectors
guaranteed: to match your declaration order.; Lesson 582 — The values() Method: Iterating All Constants Lesson 931 — Reading from <? extends T> Collections Lesson 2707 — Fair vs Unfair Locks

H

I

J

Jackson and JSON Serialization: Lesson 2368 — Legitimate Use Cases: Frameworks and Serialization
JAR file: (Java ARchive) is a single compressed file that bundles multiple compiled `.; Lesson 684 — What Is a JAR File?
JAR files: (which are archives of `.; Lesson 689 — The Classpath: Finding Classes at Runtime
JAR hell: Conflicting library versions on the classpath caused runtime failures that were difficult to diagnose.; Lesson 2461 — Introduction to JPMS and the Module System Lesson 2516 — Classpath Mechanics: How the JVM Finds Classes
Java 11: , the `isEmpty()` method was introduced as its logical inverse—it returns `true` when the `Optional` is **empty**, and `false` when it contains a value.; Lesson 1772 — The isEmpty() Method (Java 11+)
Java 17: (and enhanced in later versions), switch expressions and enhanced switch statements allow you to explicitly handle `null` cases.; Lesson 155 — Null Handling and Switch Behavior
Java 6 changed this: , recognizing that implementing an interface method is conceptually similar to overriding: you're providing a concrete implementation for an abstract contract.; Lesson 2407 — @Override with Interfaces (Java 6+)
Java 7: , Oracle moved the intern pool to the **main heap**.; Lesson 2182 — Intern Pool Location: PermGen vs Metaspace
Java 7 and earlier: , the String intern pool was stored in **PermGen** (Permanent Generation), a fixed-size memory area separate from the main heap.; Lesson 2182 — Intern Pool Location: PermGen vs Metaspace
Java 8: , PermGen was completely eliminated and replaced with **Metaspace** (which stores class metadata only, not interned strings).; Lesson 2182 — Intern Pool Location: PermGen vs Metaspace
Java 9: , if your resource variable is **effectively final** (never reassigned after initialization), you can reference it directly in the try-with-resources statement:; Lesson 1949 — Effectively Final Resources (Java 9+)
Java blocks this: Lesson 709 — The 'Through Inheritance' Restriction
Java Compiler: is accessible.; Lesson 7 — Verifying Your Installation with java -version Lesson 12 — Compiling with javac Lesson 22 — javac vs java: The Compiler and Runtime Tools
Java Development Kit: .; Lesson 1 — What is the JDK and Why Do You Need It?
Java is different: In Java, `boolean` is its own separate type with only two possible values: `true` and `false`.; Lesson 55 — Common Mistakes: boolean vs Numeric Types
Java launcher: .; Lesson 22 — javac vs java: The Compiler and Runtime Tools
Java Runtime Environment: part of your JDK.; Lesson 7 — Verifying Your Installation with java -version
Java's internal character encoding: .; Lesson 2001 — UTF-16 and UTF-32
JDK: stands for **Java Development Kit**.; Lesson 1 — What is the JDK and Why Do You Need It?
JDK (Java Development Kit): The Top Layer; Lesson 2 — JDK vs JRE vs JVM: The Three-Layer Architecture
JDK tool: introduced with JPMS that creates **custom runtime images**.; Lesson 2544 — What is jlink and Why Custom Runtime Images Matter
JIT (Just-In-Time) Compilation: is the JVM's clever performance optimization.; Lesson 25 — JIT Compilation: From Bytecode to Native Code at Runtime
JIT (Just-In-Time) compiler: you learned about earlier.; Lesson 103 — Performance and Compiler Optimizations
JIT compiler limitations: The JVM cannot inline reflective calls as aggressively; Lesson 2395 — Performance Overhead of Reflection
JIT-compiled native code: = memorizing your most-ordered dish and cooking it automatically (faster, optimized); Lesson 25 — JIT Compilation: From Bytecode to Native Code at Runtime
JIT-friendly: The JVM can inline and optimize MethodHandle invocations far better than reflection.; Lesson 2403 — MethodHandles as a Faster Alternative
JRE (Java Runtime Environment): The Middle Layer; Lesson 2 — JDK vs JRE vs JVM: The Three-Layer Architecture
JSON: (with libraries like Jackson or Gson) converts objects to readable text.; Lesson 2165 — Alternatives to Java Serialization
Just need a timestamp: Use `Instant` for logging, database timestamps, or measuring duration between events.; Lesson 1856 — Best Practices: When to Use ZonedDateTime
Just-In-Time (JIT) compilation: .; Lesson 426 — final Methods and Performance Myths Lesson 468 — Performance Implications of Dynamic Dispatch
JVM: comes in.; Lesson 20 — The Java Virtual Machine (JVM): An Abstract Computer
JVM (Java Virtual Machine): The Bottom Layer; Lesson 2 — JDK vs JRE vs JVM: The Three-Layer Architecture
JVM checks current method: for a `try-catch` that surrounds the throw point; Lesson 751 — The Search for a Handler
JVM optimization level: (JIT compilation improves both, but direct calls benefit more); Lesson 2398 — Method Invocation Overhead: invoke vs Direct Calls
JVM overhead: The runtime itself adds small delays; Lesson 2596 — Sleep Precision and Guarantees
JVM's default locale: .; Lesson 2230 — Locale-Aware Formatting

K

L

M

N

O

P

Q

Qualified vs Unconditional: Using qualified `opens` (e.; Lesson 2497 — Security and Design Trade-offs with opens
Quantifier: requiring at least 2 letters for the top-level domain; Lesson 2282 — Matching Email Addresses with Regex
Quantifiers: `(?; Lesson 2269 — Non-Capturing Groups: (?:...)
Query execution errors: Your SQL statement has syntax errors or references tables/columns that don't exist; Lesson 806 — SQLException: Database Access Errors
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 Lesson 972 — Deque Interface: Double-Ended Queue Operations Lesson 1167 — Queue Interface Overview and FIFO Semantics
Queue and Deque Operations: Lesson 992 — LinkedList: When to Use It
Queue methods: on a `LinkedList`:; Lesson 1177 — Queue vs List Methods on LinkedList
Queued tasks continue: tasks waiting in the queue still get executed; Lesson 2715 — Graceful Shutdown: The shutdown Method
Queues: tasks if all workers are busy; Lesson 2712 — Thread Pools: Reusing Threads for Efficiency
Quick fix when stuck: Most IDEs let you stop a running program (often a red square button), or press `Ctrl+C` in the terminal.; Lesson 163 — Infinite Loops: Intentional and Accidental
Quick identification trick: Ask yourself, "Could I chain another operation after this?; Lesson 1401 — Identifying Operation Types in Real Code
Quick one-off parsing: where readability isn't critical; Lesson 2275 — Named Groups vs Numbered Groups
Quicksort: Pick a pivot, partition, sort each partition recursively; Lesson 233 — When to Use Recursion: Tree Traversal and Divide-and-Conquer

R

S

T

U

V

W

X

XML: offers structured, human-readable data with wide tooling support, though more verbose.; Lesson 2165 — Alternatives to Java Serialization
XOR (`^`): Returns 1 only when bits **differ**; Lesson 117 — The Bitwise XOR Operator (^)

Y

Z