Devops Monk

// Good: filter → transform → collect
List<String> premiumNames = customers.stream()
    .filter(Customer::isPremium)
    .map(Customer::getName)
    .sorted()
    .collect(Collectors.toList());

// Good: aggregation
Map<String, Long> countByCity = customers.stream()
    .collect(Collectors.groupingBy(Customer::getCity, Collectors.counting()));

// Bad: stream for something a loop does more clearly
IntStream.range(0, list.size())
    .forEach(i -> System.out.println(i + ": " + list.get(i)));

// Good: traditional loop wins here
for (int i = 0; i < list.size(); i++) {
    System.out.println(i + ": " + list.get(i));
}

// Good
stream.map(String::toUpperCase)
stream.filter(String::isEmpty)
stream.forEach(System.out::println)

// Bad: no improvement over the method reference
stream.map(s -> s.toUpperCase())
stream.filter(s -> s.isEmpty())

// Bad: using stream purely for side effects
names.stream().forEach(name -> emailService.sendWelcome(name));

// Good: forEach on the collection directly
names.forEach(name -> emailService.sendWelcome(name));
// or just a loop
for (String name : names) emailService.sendWelcome(name);

// Bad: boxes each int to Integer — heap pressure
int sum = numbers.stream()
    .map(n -> n * 2)
    .reduce(0, Integer::sum);

// Good: no boxing
int sum = numbers.stream()
    .mapToInt(Integer::intValue)
    .map(n -> n * 2)
    .sum();

// Bad: not thread-safe, mixes concerns
List<String> result = new ArrayList<>();
stream.filter(s -> s.length() > 3)
      .forEach(result::add); // side effect

// Good
List<String> result = stream
    .filter(s -> s.length() > 3)
    .collect(Collectors.toList());

// sorted() in a parallel stream has overhead — forces re-ordering after parallel processing
// Only use sorted() in parallel if you truly need it
stream.parallel().sorted().collect(...); // fine, but costs extra

// If you don't need order in the result, drop sorted():
stream.parallel().collect(...); // faster

Stream<String> stream = list.stream();
List<String> r1 = stream.collect(Collectors.toList()); // OK
long count = stream.count(); // IllegalStateException — stream already consumed

// Always create a new stream:
long count = list.stream().count();

// Good: signals "might not be found" to callers
public Optional<User> findByEmail(String email) { ... }

// Bad: as a field — not Serializable, wastes memory
private Optional<String> middleName;
// Good: nullable field with Optional getter
private String middleName;
public Optional<String> getMiddleName() { return Optional.ofNullable(middleName); }

// Bad: createDefault() always called even when present
User user = opt.orElse(createDefault());

// Good: createDefault() only called when absent
User user = opt.orElseGet(this::createDefault);

// Bad: throws NoSuchElementException if empty
String name = opt.get();

// Good: use orElseThrow for clear intent
String name = opt.orElseThrow(() -> new UserNotFoundException(id));

// Good: use map/orElse for transformations with defaults
String name = opt.map(User::getName).orElse("unknown");

// Bad: verbose null check in disguise
if (opt.isPresent()) {
    System.out.println(opt.get().getName());
}

// Good
opt.ifPresent(user -> System.out.println(user.getName()));
opt.map(User::getName).ifPresent(System.out::println);

// Bad: throws NPE if repo.findById returns null
Optional<User> opt = Optional.of(repo.findById(id));

// Good
Optional<User> opt = Optional.ofNullable(repo.findById(id));

// Bad: complex logic inside lambda
users.stream()
    .filter(user -> {
        if (user.getAge() < 18) return false;
        if (!user.isActive()) return false;
        if (user.getSubscriptionExpiry().isBefore(LocalDate.now())) return false;
        return user.hasVerifiedEmail();
    })
    .collect(Collectors.toList());

// Good: named method with clear intent
users.stream()
    .filter(this::isEligible)
    .collect(Collectors.toList());

private boolean isEligible(User user) {
    return user.getAge() >= 18
        && user.isActive()
        && !user.getSubscriptionExpiry().isBefore(LocalDate.now())
        && user.hasVerifiedEmail();
}

// Bad: single-letter parameters lose context
users.stream()
    .filter(u -> u.getAge() > 18)
    .map(u -> u.getName());

// Good: descriptive names
users.stream()
    .filter(user -> user.getAge() > 18)
    .map(User::getName);  // method reference is even better

// Good: method reference is clear
.map(String::toUpperCase)
.filter(Objects::nonNull)
.sorted(Comparator.comparing(Order::getDate))

// Lambda is better when the method reference obscures context
// Bad: hard to tell what 'this::process' does without knowing the class
.map(this::process)
// Good: lambda makes the operation visible
.map(item -> item.applyDiscount(0.1))

// Unnecessary
.map(s -> new StringBuilder(s))

// Clear
.map(StringBuilder::new)

// Bad: blocks the shared ForkJoinPool with I/O waits
CompletableFuture.supplyAsync(() -> httpClient.get(url));

// Good: dedicated thread pool for I/O
ExecutorService ioPool = Executors.newCachedThreadPool();
CompletableFuture.supplyAsync(() -> httpClient.get(url), ioPool);

// Bad: exceptions are silently swallowed
CompletableFuture.supplyAsync(() -> riskyCall());

// Good
CompletableFuture.supplyAsync(() -> riskyCall())
    .exceptionally(ex -> { log.error("Failed", ex); return fallback; });

// Bad: nested CompletableFuture<CompletableFuture<T>>
future.thenApply(user -> fetchOrders(user.getId())); // returns CF<CF<Orders>>

// Good
future.thenCompose(user -> fetchOrders(user.getId())); // returns CF<Orders>

// Bad: deadlock risk
future.thenApply(user -> anotherFuture.get()); // blocking inside callback

// Good: chain with thenCompose
future.thenCompose(user -> anotherFuture);

// Storing an event timestamp — use Instant
Instant occurredAt = Instant.now();

// Displaying to a user — convert to their timezone
ZonedDateTime userTime = occurredAt.atZone(ZoneId.of("Asia/Kolkata"));

// Bad: creates a new formatter object on every call
public String format(LocalDate date) {
    return date.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")); // new object each time
}

// Good: formatter is immutable and thread-safe — safe as static
private static final DateTimeFormatter DATE_FMT =
    DateTimeFormatter.ofPattern("dd/MM/yyyy");

public String format(LocalDate date) {
    return date.format(DATE_FMT);
}

// At legacy API boundary, convert once and use java.time internally
Date legacyDate = legacyService.getDate();
LocalDateTime dt = legacyDate.toInstant()
    .atZone(ZoneId.systemDefault())
    .toLocalDateTime();
// Use dt from here on — never pass legacyDate further into your code