🌐 What is Optional?

Optional<T> is a container object that may or may not contain a non-null value.
It’s designed to help avoid null checks and reduce the chances of getting dreaded NullPointerException (NPE).

---

✅ Why was Optional introduced?

Before Optional, methods that might return null forced developers to:

• Either write manual null checks (boilerplate).
• Or risk NullPointerException if they forgot the check.

Example (pre-Java 8):

String value = findValue();
if (value != null) {
    System.out.println(value.toUpperCase());
}

With Optional, the method can return:

Optional<String> optionalValue = findValue();
optionalValue.ifPresent(v -> System.out.println(v.toUpperCase()));

🧰 Key Methods in Optional

Method	Purpose
empty()	Creates empty Optional
of(value)	Wraps non-null value (throws if null)
ofNullable(value)	Wraps value (empty if null)
isPresent()	Returns true if value exists
ifPresent()	Runs code if value exists
orElse(default)	Returns value or default if empty
orElseGet(supplier)	Returns value or supplier result if empty
orElseThrow()	Throws exception if empty
map()	Transforms value if present
flatMap()	Similar to map, but for nested Optional
filter()	Filters value if condition matches

---

📚 Examples

1️⃣ Creating Optional

Optional<String> name = Optional.of("Alice");   // Non-null
Optional<String> emptyName = Optional.empty();  // No value
Optional<String> nullableName = Optional.ofNullable(null);  // Empty

2️⃣ Using Optional — Safe Access

Optional<String> name = Optional.of("Alice");
name.ifPresent(n -> System.out.println(n.toUpperCase()));  // ALICE

3️⃣ Default Value if Empty

String result = name.orElse("Unknown");

4️⃣ Throw Exception if Empty

String value = name.orElseThrow(() -> new IllegalStateException("No name present"));

5️⃣ Transform Value

Optional<String> name = Optional.of("Bob");
Optional<Integer> length = name.map(String::length);  // map transforms value if present

6️⃣ Filter Value

Optional<String> name = Optional.of("Charlie");
name.filter(n -> n.length() > 5).ifPresent(System.out::println);  // Charlie

⚠️ Common Mistake — Don’t Overuse Optional

✅ Use Optional as a return type — especially for methods where “no result” is valid.
❌ Avoid using Optional for:

• Method parameters (just use null if needed).
• Class fields (use normal nullable fields instead).

---

📊 Summary Table

Feature	Description
Purpose	Handle missing values gracefully
Reduces	NullPointerException risk
Alternative to	Returning null directly
Introduced in	Java 8

---

🔥 Best Practices

✅ Use for return values, especially in Streams, repositories, or finders.
✅ Combine with map/filter/ifPresent for functional programming style.
✅ Avoid chaining too many operations (Optional abuse).
✅ Don’t use Optional for fields — it’s designed for return values.

---

🎯 Final Pro Tip for Interviews

✅ Optional = “A box that might contain a value, or might be empty.”
✅ Great for methods like:

Optional<User> findUserById(int id);

✅ Encourages null-safe functional programming style.

Lets’ say we have example

Optional<String> name = Optional.of("Bob");
Optional<Integer> length = name.map(String::length);

✅ String::length is an instance method reference.

---

💡 Explanation

• length() is a regular instance method of the String class.
• The map() function is called on an Optional<String>, so the map() operation gets the contained value (Bob), and applies String::length to it.
• String::length is shorthand for:

s -> s.length()

This works because:

• map() expects a Function<T, R>.
• The method length() is an instance method on String (not static).

---

🔥 Key Rule

Reference Type	Example	Explanation
Static Method Reference	Math::max	Refers to a static method (max)
Instance Method Reference (bound to object)	System.out::println	Refers to method bound to a specific instance (System.out)
Instance Method Reference (unbound — provided at runtime)	String::length	Refers to method that will be called on each object processed (like map providing a string instance)
Constructor Reference	ArrayList::new	Refers to a constructor

---

🧰 Visualizing What Happens

This:

Optional<Integer> length = name.map(String::length);

Is equivalent to:

Optional<Integer> length = name.map(s -> s.length());

📊 Summary of String::length

Method Type	Instance Method
Bound to specific instance?	❌ No — it works on any String given by map()
Method signature	int length()
Expected Functional Interface	Function<String, Integer> (input: String, output: Integer)

---

🔥 Final Answer

✅ String::length is an unbound instance method reference.
✅ It gets bound at runtime to the actual object provided by the Optional — in this case, the string "Bob".

---

💡 Pro Tip for Interviews

✅ Emphasize that this is different from System.out::println, which is a bound instance method reference (because System.out is a pre-existing object).
✅ String::length works like s -> s.length(), so it’s instance-level but unbound until called.

Provide example with static method reference

public class MathUtils {
    public static int square(int number) {
        return number * number;
    }
}

Now, if you have a list of numbers and you want to map each number to its square, you can do it using a lambda like this:

List<Integer> numbers = List.of(1, 2, 3, 4);

List<Integer> squares = numbers.stream()
    .map(n -> MathUtils.square(n))  // Lambda
    .collect(Collectors.toList());

🔗 Using Static Method Reference

Instead of the lambda, you can use a method reference to directly refer to the static method:

List<Integer> squares = numbers.stream()
    .map(MathUtils::square)  // Static method reference
    .collect(Collectors.toList());

This works because:

• map() expects a Function<T, R>.
• MathUtils::square fits perfectly into Function<Integer, Integer>.

---

✅ Why is this Static?

• The method square(int) is declared as static inside MathUtils.
• It belongs to the class, not to any particular instance.
• This makes it a static method reference.

---

📊 Summary Table (Static vs Instance)

Type	Example	Explanation
Static Method Reference	MathUtils::square	Method belongs to a class
Instance Method Reference (specific object)	System.out::println	Method called on a pre-existing object (System.out)
Instance Method Reference (unbound)	String::length	Method called on each element passed in (provided by map())
Constructor Reference	ArrayList::new	Refers to constructor (creates new instance)

---

💡 Pro Tip for Interviews

✅ Always say:

• “Static method references belong to the class itself.”
• “They are often used for utility methods, like Math.max() or Files.exists().”

⚙️ Complete Example

import java.util.*;
import java.util.stream.Collectors;

public class StaticMethodReferenceExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4);
        List<Integer> squares = numbers.stream()
                                       .map(MathUtils::square)
                                       .collect(Collectors.toList());
        System.out.println(squares);  // [1, 4, 9, 16]
    }
}

class MathUtils {
    public static int square(int number) {
        return number * number;
    }
}