How do I handle null safely using Objects.requireNonNullElse?

By I Wayan Saryada in Util Package 0 Comment

The Objects.requireNonNullElse method, introduced in Java 9, provides a safe and convenient way to handle null references by returning a default value if the provided object is null. This method ensures that you won’t get a NullPointerException in cases where you expect an object but want a fallback when it’s null.

Syntax

public static <T> T requireNonNullElse(T obj, T defaultObj)

Parameters

  • obj: The object to check for null.
  • defaultObj: The object to return if obj is null. This cannot be null; otherwise, a NullPointerException will be thrown.

Returns

  • If obj is not null, it returns obj.
  • If obj is null, it returns defaultObj.

Key Features

  • Ensures defaultObj is never null. If you pass a null defaultObj, the code will throw a NullPointerException.
  • Useful when you want a non-null value without writing explicit if-else conditions.

Example Usage

import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        String value = null;
        String defaultValue = "Default Value";

        // Using Objects.requireNonNullElse
        String result = Objects.requireNonNullElse(value, defaultValue);

        // Prints: Default Value
        System.out.println(result);

        // If value is not null
        value = "Actual Value";

        // Prints: Actual Value
        System.out.println(Objects.requireNonNullElse(value, defaultValue));
    }
}

How It Works

  1. When value is null, Objects.requireNonNullElse(value, defaultValue) will safely return "Default Value".
  2. When value is not null, it returns the actual value of value.

Important Notes

  1. defaultObj cannot be null:
    If the defaultObj provided is null, the method will throw a NullPointerException. For example:

    String result = Objects.requireNonNullElse(null, null); // Throws NullPointerException
  2. Use for Non-Primitive Types Only:
    Since Objects.requireNonNullElse works only with reference types (i.e., not primitive types like int, double), use boxed primitives such as Integer, Double, etc., when needed.

    // Example with Integer:
Integer number = null;
Integer defaultNumber = 42;

Integer result = Objects.requireNonNullElse(number, defaultNumber);

// Prints: 42
System.out.println(result);

Using Objects.requireNonNullElse is a clean, concise, and safe way to provide fallback values for potentially null objects without the need for verbose checks.

How to Use TreeMap for Sorted Key Access in Java

By I Wayan Saryada in Util Package 0 Comment

The TreeMap class in Java is part of the java.util package and provides an implementation of the Map interface that keeps its keys sorted in a natural order (according to ) or a custom order (defined by a Comparator, if provided during construction)Comparable. It’s commonly used when you need to access keys in sorted order efficiently.
Here’s a guide on how to use TreeMap for sorted key access in Java:

Key Features of TreeMap

  1. Maintains sorted order of keys.
  2. Implements the SortedMap and NavigableMap interfaces.
  3. Operates based on a Red-Black Tree, ensuring efficient sorting and lookup (O(log n) for most operations).

Basic Usage

Follow these steps to use TreeMap for sorted key access:

1. Create a TreeMap

You can create a TreeMap object with or without a custom comparator.

import java.util.*;

public class TreeMapExample {
    public static void main(String[] args) {
        // Natural ordering (keys must implement Comparable)
        TreeMap<Integer, String> treeMap = new TreeMap<>();

        // Custom comparator (e.g., descending order)
        TreeMap<Integer, String> customTreeMap = new TreeMap<>(Comparator.reverseOrder());
    }
}

2. Add Key-Value Pairs

Adding elements to a TreeMap is straightforward, using the put() method.

treeMap.put(3, "Three");
treeMap.put(1, "One");
treeMap.put(2, "Two");

The elements will automatically be stored in ascending order of keys.

3. Iterate Over Sorted Entries

The entries in the TreeMap can be accessed in sorted order.

for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

Output:

1 -> One
2 -> Two
3 -> Three

4. Access Specific Portions of the Map

The TreeMap provides powerful methods to access subsets of keys and values:

  • headMap(K toKey, boolean inclusive): Get keys less than a given key.
  • tailMap(K fromKey, boolean inclusive): Get keys greater than a given key.
  • subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive): Get keys in a given range.

Example:

System.out.println("Keys less than 3: " + treeMap.headMap(3).keySet());
System.out.println("Keys greater than or equal to 2: " + treeMap.tailMap(2).keySet());
System.out.println("Keys between 1 (inclusive) and 3 (exclusive): " 
                   + treeMap.subMap(1, true, 3, false).keySet());

Output:

Keys less than 3: [1, 2]
Keys greater than or equal to 2: [2, 3]
Keys between 1 (inclusive) and 3 (exclusive): [1, 2]

5. Use NavigableMap Methods

The TreeMap also implements the NavigableMap interface, offering methods for navigation:

  • firstKey() / lastKey(): Get the smallest/largest key.
  • lowerKey(key) / higherKey(key): Get the keys just below/above a given key.
  • floorKey(key) / ceilingKey(key): Get keys less than/greater than or equal to the given key.

Example:

System.out.println("First key: " + treeMap.firstKey());
System.out.println("Last key: " + treeMap.lastKey());
System.out.println("Key just below 3: " + treeMap.lowerKey(3));
System.out.println("Key just above 2: " + treeMap.higherKey(2));

Output:

First key: 1
Last key: 3
Key just below 3: 2
Key just above 2: 3

6. Remove Items

You can remove specific entries using the remove(key) method.

treeMap.remove(2); // Removes the key "2"
System.out.println(treeMap);

Output:

{1=One, 3=Three}

Example: Full Program

package org.kodejava.util;

import java.util.*;

public class TreeMapExample {
    public static void main(String[] args) {
        // Create a TreeMap
        TreeMap<Integer, String> treeMap = new TreeMap<>();

        // Add elements
        treeMap.put(3, "Three");
        treeMap.put(1, "One");
        treeMap.put(2, "Two");

        // Iterate over TreeMap
        System.out.println("TreeMap in ascending order:");
        for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        // Access portions of the map
        System.out.println("Keys less than 2: " + treeMap.headMap(2).keySet());
        System.out.println("Keys greater than or equal to 2: " + treeMap.tailMap(2).keySet());

        // Use NavigableMap methods
        System.out.println("First key: " + treeMap.firstKey());
        System.out.println("Last key: " + treeMap.lastKey());
    }
}

Output:

TreeMap in ascending order:
1 -> One
2 -> Two
3 -> Three
Keys less than 2: [1]
Keys greater than or equal to 2: [2, 3]
First key: 1
Last key: 3

Things to Remember

  1. Keys must be Comparable or you must provide a Comparator during construction.
  2. Null keys are not allowed in TreeMap, but null values are permitted.
  3. Use TreeMap when you need sorted access; otherwise, HashMap is a better choice for performance.

How to Use Locale for Internationalization

By I Wayan Saryada in Util Package 0 Comment

Internationalization (i18n) involves designing applications so that they can be adapted to different languages, regions, and cultures. In Java, the Locale class is a fundamental part of i18n. It represents a specific geographical, political, or cultural region and is used in conjunction with various APIs to format dates, numbers, and text according to a specific locale.

Here are the basic steps to use Locale for internationalization:

1. Creating a Locale

You can create a Locale object in a few different ways:

package org.kodejava.util;

import java.util.Locale;

public class LocaleExample {
    public static void main(String[] args) {
        // Using predefined constants
        Locale defaultLocale = Locale.getDefault();  // System default locale
        Locale usLocale = Locale.US;                 // United States

        // Using constructors
        Locale customLocale = new Locale("fr", "FR");  // French (France)

        // Using Locale.Builder (for more control)
        Locale builderLocale = new Locale.Builder()
                .setLanguage("de")  // German
                .setRegion("DE")    // Germany
                .build();

        System.out.println("Default Locale: " + defaultLocale);
        System.out.println("US Locale: " + usLocale);
        System.out.println("Custom Locale: " + customLocale);
        System.out.println("Builder Locale: " + builderLocale);
    }
}

2. Using Locale with Date/Time Formatting

Locale is commonly used to format dates and times in a way that is familiar to a specific region:

package org.kodejava.util;

import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

public class DateLocalizationExample {
    public static void main(String[] args) {
        Date now = new Date();

        // Formatting date in French (France)
        Locale frenchLocale = new Locale("fr", "FR");
        DateFormat frenchDateFormatter = DateFormat.getDateInstance(DateFormat.DEFAULT, frenchLocale);
        System.out.println("Date in French: " + frenchDateFormatter.format(now));

        // Formatting date in German (Germany)
        Locale germanLocale = new Locale("de", "DE");
        DateFormat germanDateFormatter = DateFormat.getDateInstance(DateFormat.DEFAULT, germanLocale);
        System.out.println("Date in German: " + germanDateFormatter.format(now));
    }
}

3. Using Locale with Numbers and Currency Formatting

The NumberFormat class allows you to format numbers and currencies according to a locale:

package org.kodejava.util;

import java.text.NumberFormat;
import java.util.Locale;

public class NumberLocalizationExample {
    public static void main(String[] args) {
        double amount = 12345.67;

        // Format currency in US locale
        Locale usLocale = Locale.US;
        NumberFormat usFormatter = NumberFormat.getCurrencyInstance(usLocale);
        System.out.println("In US: " + usFormatter.format(amount));

        // Format currency in Japanese locale
        Locale japanLocale = Locale.JAPAN;
        NumberFormat japanFormatter = NumberFormat.getCurrencyInstance(japanLocale);
        System.out.println("In Japan: " + japanFormatter.format(amount));
    }
}

4. Internationalizing Messages with ResourceBundles

For text and messages, Java provides the ResourceBundle class, which allows you to store localized strings in property files.

  1. Create Properties Files (e.g., messages_en_US.properties, messages_fr_FR.properties): 
    # messages_en_US.properties
greeting=Hello
farewell=Goodbye

    # messages_fr_FR.properties
greeting=Bonjour
farewell=Au revoir
  2. Read ResourceBundle Based on Locale: 
    package org.kodejava.util;

import java.util.Locale;
import java.util.ResourceBundle;

public class ResourceBundleExample {
  public static void main(String[] args) {
     // Locale for English (US)
     Locale usLocale = new Locale("en", "US");
     ResourceBundle bundleUS = ResourceBundle.getBundle("messages", usLocale);
     System.out.println("US Greeting: " + bundleUS.getString("greeting"));
     System.out.println("US Farewell: " + bundleUS.getString("farewell"));

     // Locale for French (France)
     Locale frLocale = new Locale("fr", "FR");
     ResourceBundle bundleFR = ResourceBundle.getBundle("messages", frLocale);
     System.out.println("French Greeting: " + bundleFR.getString("greeting"));
     System.out.println("French Farewell: " + bundleFR.getString("farewell"));
  }
}

5. Switching Locales Dynamically

You can dynamically switch between different locales at runtime, based on user preferences or system settings:

package org.kodejava.util;

import java.util.Locale;

public class LocaleSwitcher {
   public static void setLocale(String language, String country) {
      Locale.setDefault(new Locale(language, country));
   }

   public static void main(String[] args) {
      // Default locale
      System.out.println("Default Locale: " + Locale.getDefault());

      // Switch to French
      setLocale("fr", "FR");
      System.out.println("Current Locale: " + Locale.getDefault());
      // Perform locale-specific operations...

      // Switch back to English
      setLocale("en", "US");
      System.out.println("Current Locale: " + Locale.getDefault());
      // Perform locale-specific operations...
   }
}

Key Points:

  1. The Locale object is essential for tailoring applications for specific languages and regions.
  2. Utilize DateFormat, NumberFormat, and ResourceBundle for locale-based formatting and localized messages.
  3. Keep localized data (like messages) in separate resource files (.properties) to facilitate easier translation.
  4. Avoid hardcoding language-specific content directly in the code—this ensures maintainability and scalability.

How to Use Objects.requireNonNull() Effectively

By I Wayan Saryada in Util Package 0 Comment

The Objects.requireNonNull() method is a utility provided in Java to enforce that an object is not null during runtime. It is part of the java.util.Objects class starting from Java 7 and is commonly used for validating method parameters, ensuring that null values don’t propagate and cause unexpected NullPointerExceptions later.

Here’s a detailed explanation of how to use Objects.requireNonNull() effectively:

What It Does

Objects.requireNonNull() checks whether the provided reference is null. If it is null, it throws a NullPointerException. Optionally, you can provide a custom message to make the exception more meaningful.

Methods Available

There are three main variants of Objects.requireNonNull():

  1. public static <T> T requireNonNull(T obj)
    • Throws NullPointerException if obj is null.
  2. public static <T> T requireNonNull(T obj, String message)
    • Throws NullPointerException with the provided message if obj is null.
  3. public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) (Java 8 or later)
    • Defers the creation of the message via the Supplier, which is a performance-friendly option since the message is only computed if obj is null.

When to Use It

  1. To Validate Parameters
    Use Objects.requireNonNull() at the beginning of a method to validate parameters and catch null values early.

    public void setName(String name) {
   this.name = Objects.requireNonNull(name, "Name cannot be null!");
}
  2. Before Using a Field in Code
    Validate fields that are expected to be non-null before operating on them.

    public void processData(Data data) {
   Objects.requireNonNull(data, "Data must not be null before processing.");
   // process the data
}
  3. Constructor Argument Validation
    When writing constructors, validate inputs immediately to ensure that your object is consistently in a valid state.

    public Example(String id) {
   this.id = Objects.requireNonNull(id, "ID must not be null.");
}
  4. To Prevent Nullable Logic Elsewhere in Code
    By enforcing non-null guarantees in one place (e.g., via method validation), null checks do not need to be repeated elsewhere in the codebase.

Best Practices

  1. Always Provide a Meaningful Message
    The message should indicate what went wrong, so developers can quickly pinpoint the issue.

    public void processFile(File file) {
   Objects.requireNonNull(file, "File parameter is required.");
}
  2. Use a Supplier When the Message Is Expensive to Build
    If creating the message involves non-trivial operations, use the Supplier<String> version to only compute the message when it’s actually necessary:

    public void process(String input) {
   Objects.requireNonNull(input, () -> "Input cannot be null at " + LocalDateTime.now());
}
  3. Avoid Overusing It
    Don’t use Objects.requireNonNull() unnecessarily, such as in places where null values are either acceptable or already handled by the program.

    // Not recommended - Avoid redundant requireNonNull()
public String getNonNullValue(String value) {
   return Objects.requireNonNull(value, "Param cannot be null.");
}

// Instead, handle null where needed
return (value == null) ? "Default" : value;
  4. In Lombok Constructors
    If using Lombok, you can reduce boilerplate code by annotating with @NonNull in the parameters, and Lombok will handle the validation using Objects.requireNonNull() under the hood.

    @Data
public class Example {
   private final @NonNull String name;
}
  5. Avoid Overhead
    Don’t use Objects.requireNonNull() in performance-critical sections of the code. For repetitive checks in such cases, consider earlier null validations.

Example

Here’s a complete example of how Objects.requireNonNull() works in practice:

package org.kodejava.util;

import java.util.Objects;

public class User {
    private final String username;

    public User(String username) {
        // Validate that the username is not null
        this.username = Objects.requireNonNull(username, "Username cannot be null.");
    }

    public void updateEmail(String email) {
        Objects.requireNonNull(email, "Email cannot be null.");
        System.out.println("Email updated to: " + email);
    }

    public String getUsername() {
        return username;
    }

    public static void main(String[] args) {
        try {
            User user = new User(null); // Throws NullPointerException with message
        } catch (NullPointerException e) {
            System.out.println(e.getMessage()); // Output: "Username cannot be null."
        }

        User user = new User("JohnDoe");

        try {
            user.updateEmail(null); // Throws NullPointerException with message
        } catch (NullPointerException e) {
            System.out.println(e.getMessage()); // Output: "Email cannot be null."
        }
    }
}

Advantages

  • Improved Readability: Instead of writing verbose null-checks, Objects.requireNonNull() provides clear intent with less code.
  • Centralized Null Handling: Enforces null-checking policy consistently.
  • Clear Debugging: The custom exception message pinpoints the issue.

Conclusion

Objects.requireNonNull() is a highly effective tool to enforce non-null constraints in your code. When combined with thoughtful custom messages or suppliers, it helps you write cleaner, safer, and more readable Java code.

How to Generate UUIDs in Java

By I Wayan Saryada in Util Package 0 Comment

In Java, you can generate universally unique identifiers (UUIDs) using the java.util.UUID class. Here’s how you can generate a UUID:

Example Code

package org.kodejava.util;

import java.util.UUID;

public class UUIDExample {
    public static void main(String[] args) {
        // Generate a random UUID
        UUID uuid = UUID.randomUUID();
        System.out.println("Generated UUID: " + uuid.toString());
    }
}

Explanation

  • The UUID.randomUUID() method generates a type-4 (pseudo-random) UUID.
  • The output will look something like: f47ac10b-58cc-4372-a567-0e02b2c3d479.
  • The toString() method converts the UUID object into its string representation.

Other UUID Options

If you want to specify your own inputs, you can use the UUID.fromString(String uuid) or create a UUID from specific values with UUID.nameUUIDFromBytes(byte[] bytes). For example:

package org.kodejava.util;

import java.util.UUID;

public class UUIDFromNameExample {
    public static void main(String[] args) {
        // Generate a UUID based on an input name
        UUID uuid = UUID.nameUUIDFromBytes("example.com".getBytes());
        System.out.println("Generated UUID from name: " + uuid.toString());
    }
}

Notes

  • UUIDs are useful for generating unique IDs in distributed systems, database keys, and more.
  • Version-4 (random) UUIDs are the most commonly used since they rely only on randomness and are highly unlikely to collide.