How do you check whether an Optional contains a value, and what changed in Java 11?

## The querying problem Once you have an `Optional<T>`, you eventually need to know: is there a value inside, or is it empty? The two boolean query methods answer exactly that. ## `isPresent()` `boolean isPresent()` returns `true` when the Optional contains a value and `false` when it is empty. Because it returns a primitive `boolean`, you can drop it straight into an `if`: ```java if (opt.isPresent()) { // there is a value } ``` ## `isEmpty()` (Java 11+) For years the only way to test for absence was to negate: `!opt.isPresent()`. The leading `!` is easy to miss when skimming code, which causes bugs. Java 11 added `boolean isEmpty()`, defined as the exact opposite of `isPresent()` — it returns `true` when the Optional is empty. It adds no new capability; it's purely a readability win for the case where the *absent* branch is the one you care about: ```java if (opt.isEmpty()) { // handle the missing case clearly } ``` Note: this means `isEmpty()` does **not** exist on Java 8/9/10. On older runtimes you must use `!isPresent()`. ## Why "isPresent + get" is discouraged A tempting pattern is: ```java if (opt.isPresent()) { use(opt.get()); } ``` This works, but it's considered an anti-pattern for two reasons. First, it's essentially the same as the manual `if (x != null)` null check that Optional was designed to make unnecessary — you've added a wrapper but kept the old habit. Second, the structure invites mistakes: someone can call `opt.get()` outside the guard (e.g., in an `else` branch or after refactoring), and `get()` on an empty Optional throws `NoSuchElementException`. The compiler cannot stop you. The idiomatic alternatives express both branches in a single, safe expression: - `opt.ifPresent(v -> use(v))` — run code only if present. - `opt.map(...).orElse(default)` — transform or fall back. - `opt.orElse(default)` / `opt.orElseGet(supplier)` — get the value or a fallback. - `opt.orElseThrow()` — get the value or throw if absent. These never let you accidentally read an absent value. ## When the boolean methods are fine `isPresent`/`isEmpty` are still the right tool when you truly need a boolean — for example, counting how many results were found, or branching on presence where the two branches do unrelated things that don't map cleanly onto `map`/`orElse`. The guidance is "prefer the functional methods," not "never call isPresent." ## Summary - `isPresent()` → true if a value is inside. - `isEmpty()` → true if empty; added in Java 11; the same as `!isPresent()`. - Both return `boolean`. Prefer `map`/`ifPresent`/`orElse*` over `isPresent()` + `get()`.