Unlocking the Full Potential of Optional in Java: Advanced Use Cases for Digital Wallets

Lucas Copque

·

Follow

3 min read

·

Feb 28, 2025

Listen

Share

Introduction

Many developers see Optional<T> in Java as a simple way to avoid null values, but its true power goes far beyond that. When used effectively, Optional can help you build cleaner, safer, and more expressive code—especially in domains like digital wallets, where encapsulation and transaction security are crucial.

This article explores advanced use cases where Optional becomes a game-changer in a digital wallet system, demonstrating how to encapsulate complex business rules efficiently.

📌 Note: The examples in this article are based on a fictitious digital wallet system, designed purely for practical learning and demonstrating the power of Optional in Java.

1️⃣ Secure Payments with Fraud Prevention

📌 Problem: Some transactions may be flagged as suspicious and require additional checks before processing.

📌 Solution: The payment process encapsulates rules such as sufficient balance, transaction limits, and fraud detection.

import java.math.BigDecimal;
import java.util.Optional;

public class DigitalWallet {
    private BigDecimal balance;
    private final BigDecimal transactionLimit = new BigDecimal("5000.00");

    public DigitalWallet(BigDecimal initialBalance) {
        this.balance = initialBalance;
    }

    public Optional<Boolean> processPayment(BigDecimal amount, boolean isSuspicious) {
        return Optional.of(this)
            .filter(w -> !isSuspicious) // Block suspicious transactions
            .filter(w -> amount.compareTo(transactionLimit) <= 0) // Respect transaction limits
            .flatMap(w -> w.debit(amount)); // Deduct amount if balance is sufficient
    }

    private Optional<Boolean> debit(BigDecimal amount) {
        return Optional.of(this)
            .filter(w -> w.balance.compareTo(amount) >= 0)
            .map(w -> {
                w.balance = w.balance.subtract(amount);
                return true;
            });
    }

    public BigDecimal getBalance() {
        return balance;
    }
}

🔹 Benefit: The entire payment process is encapsulated within the wallet, preventing business logic from leaking into the client code.

2️⃣ Secure Peer-to-Peer Transfers with Cashback

📌 Problem: Transfers between users should ensure sufficient balance, apply cashback rules, and log the transaction.

📌 Solution: The entire workflow is handled within DigitalWallet, using map() for a fluent pipeline.

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class DigitalWallet {
    private BigDecimal balance;
    private final List<String> transactionHistory = new ArrayList<>();

    public DigitalWallet(BigDecimal initialBalance) {
        this.balance = initialBalance;
    }

    public Optional<Boolean> transferTo(DigitalWallet recipient, BigDecimal amount, BigDecimal cashbackPercentage) {
        return this.debit(amount)
            .map(success -> {
                recipient.credit(amount);
                recipient.applyCashback(amount, cashbackPercentage);
                this.transactionHistory.add("Transfer of $" + amount + " to " + recipient);
                return true;
            });
    }

    private Optional<Boolean> debit(BigDecimal amount) {
        return Optional.of(this)
            .filter(w -> w.balance.compareTo(amount) >= 0)
            .map(w -> {
                w.balance = w.balance.subtract(amount);
                return true;
            });
    }

    private void credit(BigDecimal amount) {
        this.balance = this.balance.add(amount);
    }

    private void applyCashback(BigDecimal amount, BigDecimal cashbackPercentage) {
        BigDecimal cashback = amount.multiply(cashbackPercentage).divide(new BigDecimal("100"));
        this.credit(cashback);
    }

    public BigDecimal getBalance() {
        return balance;
    }
}

🔹 Benefit: The entire transaction, including cashback calculation, is encapsulated in a single method.

3️⃣ Automatic Subscription Payments with Retry Mechanism

📌 Problem: Digital wallets need to automatically pay subscriptions but allow partial payments when funds are low.

📌 Solution: Optional enables automatic retries with a 50% fallback payment.

import java.math.BigDecimal;
import java.util.Optional;

public class DigitalWallet {
    private BigDecimal balance;

    public DigitalWallet(BigDecimal initialBalance) {
        this.balance = initialBalance;
    }

    public Optional<Boolean> paySubscription(BigDecimal monthlyFee) {
        return debit(monthlyFee)
            .or(() -> retryPayment(monthlyFee));
    }

    private Optional<Boolean> retryPayment(BigDecimal amount) {
        return Optional.of(this)
            .filter(w -> w.balance.compareTo(amount.divide(new BigDecimal("2"))) >= 0)
            .map(w -> {
                w.balance = w.balance.subtract(amount.divide(new BigDecimal("2")));
                return true;
            });
    }

    private Optional<Boolean> debit(BigDecimal amount) {
        return Optional.of(this)
            .filter(w -> w.balance.compareTo(amount) >= 0)
            .map(w -> {
                w.balance = w.balance.subtract(amount);
                return true;
            });
    }

    public BigDecimal getBalance() {
        return balance;
    }
}

🔹 Benefit: The retry mechanism is seamlessly built-in, avoiding manual logic in the client code.

🚀 Conclusion: Optional at its Full Power!

By leveraging Optional in Java:

✅ You eliminate null checks and nested if-else structures.

✅ You encapsulate business rules within objects, reducing external logic.

✅ You create expressive and functional pipelines.

✅ You enable automatic retries and recovery mechanisms.

Using Optional effectively transforms digital wallet management into a secure, reusable, and maintainable system. 🚀💳