This article presents a set of concise, production-ready utility methods for everyday Java development—focused on string and collection validation, tmiestamp formatting, time arithmetic, and date comparison. Each method avoids common pitfalls such as null pointer exceptions and unnecessary object instantiation.

1. Safely Check for Empty Strings

A robust check that handles both null and zero-length strings without throwing exceptions. Uses Objects.isNull() and String.isEmpty() for clarity and modern JDK compatibility.

public static boolean isEmpty(String input) {
    return Objects.isNull(input) || input.isEmpty();
}

Usage example:

System.out.println(isEmpty(""));     // true
System.out.println(isEmpty(null));    // true
System.out.println(isEmpty("data"));  // false

2. Vaildate Empty or Null Lists

Checks whether a List reference is null or contains no elements. Leverages Collection.isEmpty() for consistency across collection types.

public static boolean isEmpty(Collection<?> items) {
    return Objects.isNull(items) || items.isEmpty();
}

Works with any Collection, including ArrayList, LinkedList, or Set:

List<String> emptyList = new ArrayList<>();
List<String> nullList = null;
System.out.println(isEmpty(emptyList)); // true
System.out.println(isEmpty(nullList));  // true

3. Format Current Timestamp with Fallback Pattern

Returns the current system time formatted using a provided pattern—or defaults to "yyyy-MM-dd HH:mm:ss" if none is supplied. Uses thread-safe DateTimeFormatter (Java 8+) instead of legacy SimpleDateFormat.

public static String formatCurrentTime(String pattern) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
        Objects.requireNonNullElse(pattern, "yyyy-MM-dd HH:mm:ss")
    );
    return LocalDateTime.now().format(formatter);
}

Examples:

System.out.println(formatCurrentTime(""));           // e.g., "2024-05-22 14:30:45"
System.out.println(formatCurrentTime("yyyyMMdd"));   // e.g., "20240522"

4. Add Minutes to a Given Timestamp

Accepts an input timestamp string (or uses current time if omitted), parses it using a specified pattern, adds the requested number of minutes, and returns the result in the same format. Built on immutable LocalDateTime and DateTimeFormatter.

public static String addMinutes(int minutes, String timestamp, String pattern) {
    String resolvedPattern = Objects.requireNonNullElse(pattern, "yyyy-MM-dd HH:mm:ss");
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(resolvedPattern);
    
    LocalDateTime baseTime = (timestamp == null || timestamp.trim().isEmpty())
        ? LocalDateTime.now()
        : LocalDateTime.parse(timestamp.trim(), formatter);
    
    LocalDateTime result = baseTime.plusMinutes(minutes);
    return result.format(formatter);
}

Usage:

System.out.println(addMinutes(15, null, "HH:mm:ss"));                     // e.g., "14:45:30"
System.out.println(addMinutes(-5, "2024-05-22 10:00:00", "yyyy-MM-dd HH:mm:ss")); // "2024-05-22 09:55:00"

5. Compare Two Timestamps Chronologically

Determines whether the second timestamp occurs strictly after the first, given a shared formatting pattern. Returns true only when time2 > time1.

public static boolean isLater(String time1, String time2, String pattern) {
    String resolvedPattern = Objects.requireNonNullElse(pattern, "yyyy-MM-dd HH:mm:ss");
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(resolvedPattern);
    
    LocalDateTime t1 = LocalDateTime.parse(time1.trim(), formatter);
    LocalDateTime t2 = LocalDateTime.parse(time2.trim(), formatter);
    
    return t2.isAfter(t1);
}

Example:

System.out.println(isLater("2024-05-22 09:00:00", "2024-05-22 09:15:00", "yyyy-MM-dd HH:mm:ss")); // true
System.out.println(isLater("20240522090000", "20240522084500", "yyyyMMddHHmmss")); // false