How to Use Locale for Internationalization

By Wayan 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 Wayan 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 Wayan 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.

How do I use new Java 10 methods like List.copyOf(), Set.copyOf(), and Map.copyOf()?

By Wayan in Java 10, Util Package 0 Comment

Java 10 introduced the List.copyOf(), Set.copyOf(), and Map.copyOf() methods as convenient ways to create unmodifiable copies of existing collections. These methods are part of the java.util package and provide a simpler way to create immutable collections compared to using older methods like Collections.unmodifiableList().

Here’s how you can use them:

1. List.copyOf()

The List.copyOf() method creates an unmodifiable copy of the provided Collection. The returned list:

  • Is immutable (you cannot add, remove, or modify elements).
  • Rejects null elements (throws a NullPointerException).

Example:

package org.kodejava.util;

import java.util.List;

public class ListCopyExample {
    public static void main(String[] args) {
        // Create a mutable list
        List<String> originalList = List.of("A", "B", "C");

        // Create an unmodifiable copy
        List<String> unmodifiableList = List.copyOf(originalList);

        // Print the copied list
        System.out.println(unmodifiableList);

        // Throws UnsupportedOperationException if modification is attempted
        // unmodifiableList.add("D");

        // Throws NullPointerException if original list has nulls
        // List<String> listWithNull = new ArrayList<>();
        // listWithNull.add(null);
        // List.copyOf(listWithNull);
    }
}

2. Set.copyOf()

The Set.copyOf() method creates an unmodifiable copy of the provided Collection, ensuring that:

  • The returned set contains no duplicate elements.
  • Null elements are not allowed.
  • The original collection can be a List, Set, or any Collection.

Example:

package org.kodejava.util;

import java.util.Set;

public class SetCopyExample {
   public static void main(String[] args) {
      // Create a mutable set
      Set<String> originalSet = Set.of("A", "B", "C");

      // Create an unmodifiable copy
      Set<String> unmodifiableSet = Set.copyOf(originalSet);

      // Print the copied set
      System.out.println(unmodifiableSet);

      // Throws UnsupportedOperationException
      // unmodifiableSet.add("D");
   }
}

3. Map.copyOf()

The Map.copyOf() method creates an unmodifiable copy of the provided map. Similar to List.copyOf() and Set.copyOf():

  • The returned map is immutable.
  • Null keys or values are not allowed.
  • Elements retain the original insertion order (if applicable, e.g., for LinkedHashMap).

Example:

package org.kodejava.util;

import java.util.Map;

public class MapCopyExample {
   public static void main(String[] args) {
      // Create a mutable map
      Map<Integer, String> originalMap = Map.of(1, "One", 2, "Two", 3, "Three");

      // Create an unmodifiable copy
      Map<Integer, String> unmodifiableMap = Map.copyOf(originalMap);

      // Print the copied map
      System.out.println(unmodifiableMap);

      // Throws UnsupportedOperationException
      // unmodifiableMap.put(4, "Four");
   }
}

Notes:

  1. Immutable Behavior:
    • Any attempt to modify the unmodifiable collections (e.g., using add() or put()) throws UnsupportedOperationException.
    • These methods return a new collection, but if the input collection is already immutable and meets the conditions, it may return the original collection (performance optimization).
  2. Handling Nulls:
    • If any input collection contains null elements, these methods will throw a NullPointerException.
  3. Differences from Existing Methods:
    • Unlike Collections.unmodifiableList()/Set()/Map(), these methods create a copy, ensuring that changes to the source collection won’t affect the new collection.
  4. Static Imports:
    • These methods belong to static utility classes (List, Set, and Map) and are invoked directly as static methods.

Summary:

  • Use these methods to get immutable copies of collections.
  • They reject null values by design.
  • Collections become unmodifiable and can’t be changed after creation.

They are great for enhancing immutability and safety of the application!

How do I avoid Optional performance pitfalls in high-frequency code paths?

By Wayan in Util Package 0 Comment

When working with Java’s Optional in high-frequency code paths, it’s essential to understand and avoid the performance pitfalls associated with its usage. Although Optional provides functional-style coding benefits and helps prevent NullPointerException, it introduces additional overhead due to extra object creation and functional programming constructs. Here are some recommendations to ensure optimal performance:

1. Avoid Optional in Performance-Critical Return Paths

  • Pitfall: Using Optional as a return type results in heap allocation, which can impact performance in high-frequency code paths.
  • Resolution: Prefer returning null or an alternative (e.g., a special value) in performance-critical sections of the code where object creation is a concern. Reserve Optional for APIs where readability and null-safety are a higher priority.
// Example of avoiding Optional in a performance-critical path
@Nullable
public String findValue(Map<String, String> map, String key) {
   return map.containsKey(key) ? map.get(key) : null;
}

2. Minimize Optional Creation and Chaining

  • Pitfall: Frequent creation of Optional instances for chaining operations like map, filter, etc., can result in unnecessary allocations and functional overhead.
  • Resolution: Avoid repeated and nested transformations. If you need chains of operations, consider processing directly instead of creating multiple intermediate Optional instances.
// Inefficient
Optional<String> result = Optional.ofNullable(value)
                                  .filter(v -> v.startsWith("prefix"))
                                  .map(v -> transform(v));

// More efficient
if (value != null && value.startsWith("prefix")) {
   result = transform(value);
}

3. Avoid Optional for Fields in High-Frequency Objects

  • Pitfall: Using Optional for class fields can be wasteful in terms of memory and lead to extra indirection.
  • Resolution: Use null instead of Optional for fields and handle null-safety in getters or utility methods.
// Avoid this:
private Optional<String> value; 

// Prefer:
private String value; // Use nullable reference directly.

For optional fields, you can provide clear access methods:

public Optional<String> getValue() {
   return Optional.ofNullable(value);
}

4. Be Careful with Streams and Optionals

  • Pitfall: Using Optional within streams often results in additional unnecessary wrapping and unwrapping.
  • Resolution: Avoid excessive use of Optional in stream pipelines, especially in loops or large datasets.
// Inefficient
List<String> filtered = items.stream()
                            .map(item -> Optional.ofNullable(item).filter(...))
                            .filter(Optional::isPresent)
                            .map(Optional::get)
                            .collect(Collectors.toList());

// Efficient
List<String> filtered = items.stream()
                            .filter(Objects::nonNull)
                            .filter(...)
                            .collect(Collectors.toList());

5. Do Not Use Optional in Constructor Parameters

  • Pitfall: Passing Optional parameters in constructors (or methods) can create unnecessary wrapping and unwrapping operations.
  • Resolution: Use nullable parameters, document their behavior, and handle the null checks internally.
// Avoid this:
public MyClass(Optional<String> optionalParam) { }

// Prefer this:
public MyClass(@Nullable String param) {
   this.value = param != null ? param : "default";
}

6. Combine Null Checks and Optional Usage

  • Pitfall: Overusing Optional for null-safe data access can introduce hard-to-read or inefficient code.
  • Resolution: Consider combining plain null checks with Optional for better performance.
// Inefficient:
Optional.ofNullable(obj)
       .map(v -> v.getNested())
       .orElse(defaultValue);

// More efficient:
if (obj != null && obj.getNested() != null) {
   return obj.getNested();
}
return defaultValue;

7. Optimize for Hot Code Paths

  • For hot code paths (executed very frequently), prioritize raw performance over readability. Focus on reducing heap allocations and method calls. Direct null checks and traditional constructs are generally more efficient in such cases.

8. Profile and Measure

  • Always profile your code to identify if Optional is a bottleneck. Use tools like Java Mission Control, YourKit, or VisualVM to analyze if garbage collection or method invocation from Optional usage contributes to performance issues.

Trade-offs Between Safety and Performance

While avoiding Optional can improve performance, it comes at the cost of reduced readability and safety. Evaluate whether the potential performance gains outweigh the benefits of reducing null-related errors.

By following these strategies, you can achieve a good balance between writing clean, maintainable code and not sacrificing performance in high-frequency code paths.