When get() Might Be Acceptable
You'll learn the rare, justified scenarios where using get() on an Optional doesn't undermine its purpose.
We've established that get() is generally an anti-pattern because it can throw NoSuchElementException and defeats Optional's safety guarantees. However, there are narrow, specific cases where get() is defensible—though even then, alternatives are usually clearer.
The Justified Scenarios
1. Business Logic Guarantees
When your business rules absolutely guarantee the Optional contains a value, and that guarantee is enforced by external constraints (not just assumptions):
// User must exist because database transaction enforces referential integrity
Optional<User> userOpt = findUserById(validatedId);
// After validation layer confirms ID exists:
User user = userOpt.get(); // Justified by external guarantee
2. Fail-Fast During Development
In test code or initialization routines where you want an exception if the value is absent:
// Test setup: we WANT the test to fail loudly if config is missing
Optional<Config> config = loadTestConfig();
Config testConfig = config.get(); // Acceptable in test fixtures
3. Immediately After Creating with of()
When you literally just created the Optional yourself:
Optional<String> opt = Optional.of("value");
String value = opt.get(); // Safe, but pointless—just use "value" directly!
The Reality Check
Even in these cases, alternatives are often better:
- Use
orElseThrow()with a custom exception for clarity - Use
orElse()with a documented fallback - Restructure to avoid extracting at all
Key Takeaway: While get() can be justified when external systems guarantee a value exists or in fail-fast test scenarios, these cases are rare, and more expressive Optional methods almost always communicate intent better.