How to generate a random alphanumeric string in Java?

General Discussions
, ,
1

How can I generate a random string in Java with characters A-Z and 0-9?

I need to create a random 17-character long ID, like “AJB53JHS232ERO0H1”, where both the letters and numbers are randomized. I initially thought of creating an array with the letters A-Z and using a ‘check’ variable to randomly choose between letters and numbers, with the logic inside a loop:

  1. Randomize ‘check’ to 1-2.
  2. If check == 1, pick a random letter from the array.
  3. Otherwise, pick a random number.

However, I feel there might be a simpler way to achieve this. Is there a more efficient way to generate a random string like this in Java?

2

I’ve worked with random string generation in Java quite a bit, and if you’re looking for an efficient way to do this, there’s a simple and effective approach.

One way to solve this is by defining a character set containing uppercase letters (A-Z) and numbers (0-9), then selecting random characters from this set. Here’s how you can generate a 17-character random string:

import java.util.Random;

public class RandomStringGenerator {
    public static void main(String[] args) {
        String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuilder result = new StringBuilder();
        
        for (int i = 0; i < 17; i++) {
            int index = random.nextInt(characters.length());
            result.append(characters.charAt(index));
        }
        
        System.out.println("Random String: " + result.toString());
    }
}

This method leverages Java’s built-in Random class, which efficiently selects characters from the defined set. If you’re looking for a straightforward java generate random string solution, this is a great starting point!

3

Good approach, @ishrth_fathima But if you’re working in a multi-threaded environment, there’s a better way to ensure efficiency and avoid potential performance bottlenecks."*

Instead of using Random, which can be problematic in high-concurrency scenarios, ThreadLocalRandom is a more optimized choice:

import java.util.concurrent.ThreadLocalRandom;

public class RandomStringGenerator {
    public static void main(String[] args) {
        String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        StringBuilder result = new StringBuilder();
        
        for (int i = 0; i < 17; i++) {
            int index = ThreadLocalRandom.current().nextInt(characters.length());
            result.append(characters.charAt(index));
        }
        
        System.out.println("Random String: " + result.toString());
    }
}

Why use ThreadLocalRandom? Because it’s specifically designed for concurrent applications, eliminating contention issues that might occur with Random. So if you’re working in a multi-threaded scenario, this is a better java generate random string approach.

4

@dimplesaini.230, I completely agree with your approach for multi-threading! But if security is a concern—say, for generating secure tokens or passwords—we need something stronger."*

For cryptographic security, SecureRandom is the way to go. Unlike Random and ThreadLocalRandom, SecureRandom generates numbers that are less predictable, making it ideal for security-sensitive applications.

import java.security.SecureRandom;

public class RandomStringGenerator {
    public static void main(String[] args) {
        String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        SecureRandom secureRandom = new SecureRandom();
        StringBuilder result = new StringBuilder();
        
        for (int i = 0; i < 17; i++) {
            int index = secureRandom.nextInt(characters.length());
            result.append(characters.charAt(index));
        }
        
        System.out.println("Random String: " + result.toString());
    }
}

SecureRandom is slower than Random and ThreadLocalRandom, but if your java generate random string use case involves security (e.g., authentication tokens, password generation), this is the best choice.