Published on Sat May 03 2025 10:00:00 GMT+0000 (Coordinated Universal Time) by Purusothaman Ramanujam

Random Utilities in Apache Commons Lang

Introduction

Generating random data is a common requirement in Java applications, whether for testing, creating unique identifiers, or generating sample data. Apache Commons Lang’s RandomStringUtils provides a comprehensive set of utilities that make random string generation easy, flexible, and secure.

In this comprehensive guide, you’ll learn how to use RandomStringUtils effectively with detailed examples and real-world use cases.

Adding Apache Commons Lang to Your Project

Maven Dependency

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.13.0</version>
</dependency>

Gradle Dependency

implementation 'org.apache.commons:commons-lang3:3.13.0'

Basic Random String Generation

Simple Random Strings

import org.apache.commons.lang3.RandomStringUtils;

public class BasicRandomGeneration {
    public static void main(String[] args) {
        // Generate random alphanumeric string
        String randomAlphanumeric = RandomStringUtils.randomAlphanumeric(10);
        System.out.println("Random alphanumeric: " + randomAlphanumeric);

        // Generate random alphabetic string
        String randomAlphabetic = RandomStringUtils.randomAlphabetic(8);
        System.out.println("Random alphabetic: " + randomAlphabetic);

        // Generate random numeric string
        String randomNumeric = RandomStringUtils.randomNumeric(6);
        System.out.println("Random numeric: " + randomNumeric);

        // Generate random ASCII string
        String randomAscii = RandomStringUtils.randomAscii(12);
        System.out.println("Random ASCII: " + randomAscii);

        // Generate random string with custom characters
        String customChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String randomCustom = RandomStringUtils.random(8, customChars);
        System.out.println("Random custom: " + randomCustom);
    }
}

Advanced Random Generation

public class AdvancedRandomGeneration {
    public static void main(String[] args) {
        // Generate random string with specific character sets
        String letters = RandomStringUtils.randomAlphabetic(10);
        String numbers = RandomStringUtils.randomNumeric(5);
        String alphanumeric = RandomStringUtils.randomAlphanumeric(15);

        System.out.println("Letters: " + letters);
        System.out.println("Numbers: " + numbers);
        System.out.println("Alphanumeric: " + alphanumeric);

        // Generate random string with mixed case
        String mixedCase = RandomStringUtils.randomAlphabetic(10).toLowerCase();
        System.out.println("Mixed case: " + mixedCase);

        // Generate random string with specific length range
        int minLength = 5;
        int maxLength = 15;
        int randomLength = (int) (Math.random() * (maxLength - minLength + 1)) + minLength;
        String variableLength = RandomStringUtils.randomAlphanumeric(randomLength);
        System.out.println("Variable length (" + randomLength + "): " + variableLength);
    }
}

Character Set Specific Generation

Different Character Types

public class CharacterSetGeneration {
    public static void main(String[] args) {
        // Generate only uppercase letters
        String uppercase = RandomStringUtils.random(10, true, false);
        System.out.println("Uppercase only: " + uppercase);

        // Generate only lowercase letters
        String lowercase = RandomStringUtils.random(10, false, true);
        System.out.println("Lowercase only: " + lowercase);

        // Generate mixed case letters
        String mixedCase = RandomStringUtils.random(10, true, true);
        System.out.println("Mixed case: " + mixedCase);

        // Generate with specific character sets
        String vowels = "AEIOU";
        String consonants = "BCDFGHJKLMNPQRSTVWXYZ";
        String randomVowels = RandomStringUtils.random(5, vowels);
        String randomConsonants = RandomStringUtils.random(8, consonants);

        System.out.println("Random vowels: " + randomVowels);
        System.out.println("Random consonants: " + randomConsonants);

        // Generate with custom character set
        String hexChars = "0123456789ABCDEF";
        String randomHex = RandomStringUtils.random(8, hexChars);
        System.out.println("Random hex: " + randomHex);
    }
}

Specialized Character Sets

public class SpecializedGeneration {
    public static void main(String[] args) {
        // Generate random email addresses
        String email = generateRandomEmail();
        System.out.println("Random email: " + email);

        // Generate random phone numbers
        String phone = generateRandomPhone();
        System.out.println("Random phone: " + phone);

        // Generate random usernames
        String username = generateRandomUsername();
        System.out.println("Random username: " + username);

        // Generate random passwords
        String password = generateRandomPassword();
        System.out.println("Random password: " + password);
    }

    public static String generateRandomEmail() {
        String username = RandomStringUtils.randomAlphanumeric(8).toLowerCase();
        String domain = RandomStringUtils.randomAlphanumeric(6).toLowerCase();
        String tld = RandomStringUtils.random(3, "abcdefghijklmnopqrstuvwxyz");
        return username + "@" + domain + "." + tld;
    }

    public static String generateRandomPhone() {
        String areaCode = RandomStringUtils.randomNumeric(3);
        String prefix = RandomStringUtils.randomNumeric(3);
        String lineNumber = RandomStringUtils.randomNumeric(4);
        return "(" + areaCode + ") " + prefix + "-" + lineNumber;
    }

    public static String generateRandomUsername() {
        String prefix = RandomStringUtils.randomAlphabetic(5).toLowerCase();
        String suffix = RandomStringUtils.randomNumeric(3);
        return prefix + suffix;
    }

    public static String generateRandomPassword() {
        String letters = RandomStringUtils.randomAlphabetic(6);
        String numbers = RandomStringUtils.randomNumeric(2);
        String special = RandomStringUtils.random(2, "!@#$%^&*");
        return letters + numbers + special;
    }
}

Testing Data Generation

Test Data Creation

import java.util.ArrayList;
import java.util.List;

public class TestDataGeneration {
    public static class User {
        private String id;
        private String name;
        private String email;
        private String phone;

        public User(String id, String name, String email, String phone) {
            this.id = id;
            this.name = name;
            this.email = email;
            this.phone = phone;
        }

        @Override
        public String toString() {
            return String.format("User{id='%s', name='%s', email='%s', phone='%s'}",
                id, name, email, phone);
        }
    }

    public static List<User> generateTestUsers(int count) {
        List<User> users = new ArrayList<>();

        for (int i = 0; i < count; i++) {
            String id = RandomStringUtils.randomAlphanumeric(8).toUpperCase();
            String name = generateRandomName();
            String email = generateRandomEmail();
            String phone = generateRandomPhone();

            users.add(new User(id, name, email, phone));
        }

        return users;
    }

    public static String generateRandomName() {
        String[] firstNames = {"John", "Jane", "Mike", "Sarah", "David", "Lisa", "Tom", "Emma"};
        String[] lastNames = {"Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller"};

        String firstName = firstNames[(int) (Math.random() * firstNames.length)];
        String lastName = lastNames[(int) (Math.random() * lastNames.length)];

        return firstName + " " + lastName;
    }

    public static void main(String[] args) {
        List<User> testUsers = generateTestUsers(5);
        for (User user : testUsers) {
            System.out.println(user);
        }
    }
}

Database Test Data

public class DatabaseTestData {
    public static String generateRandomUUID() {
        return RandomStringUtils.randomAlphanumeric(8) + "-" +
               RandomStringUtils.randomAlphanumeric(4) + "-" +
               RandomStringUtils.randomAlphanumeric(4) + "-" +
               RandomStringUtils.randomAlphanumeric(4) + "-" +
               RandomStringUtils.randomAlphanumeric(12);
    }

    public static String generateRandomDate() {
        int year = 2020 + (int) (Math.random() * 5);
        int month = 1 + (int) (Math.random() * 12);
        int day = 1 + (int) (Math.random() * 28);

        return String.format("%04d-%02d-%02d", year, month, day);
    }

    public static String generateRandomTimestamp() {
        String date = generateRandomDate();
        int hour = (int) (Math.random() * 24);
        int minute = (int) (Math.random() * 60);
        int second = (int) (Math.random() * 60);

        return String.format("%s %02d:%02d:%02d", date, hour, minute, second);
    }

    public static void main(String[] args) {
        System.out.println("Random UUID: " + generateRandomUUID());
        System.out.println("Random Date: " + generateRandomDate());
        System.out.println("Random Timestamp: " + generateRandomTimestamp());
    }
}

Secure Random Generation

Cryptographically Secure Random

import java.security.SecureRandom;

public class SecureRandomGeneration {
    public static void main(String[] args) {
        // Use SecureRandom for cryptographic purposes
        SecureRandom secureRandom = new SecureRandom();

        // Generate secure random strings
        String secureAlphanumeric = RandomStringUtils.random(16, 0, 0, true, true, null, secureRandom);
        System.out.println("Secure alphanumeric: " + secureAlphanumeric);

        // Generate secure random numeric string
        String secureNumeric = RandomStringUtils.random(8, 0, 0, false, true, null, secureRandom);
        System.out.println("Secure numeric: " + secureNumeric);

        // Generate secure random alphabetic string
        String secureAlphabetic = RandomStringUtils.random(12, 0, 0, true, false, null, secureRandom);
        System.out.println("Secure alphabetic: " + secureAlphabetic);
    }
}

Token Generation

public class TokenGeneration {
    public static String generateAccessToken() {
        return RandomStringUtils.randomAlphanumeric(32);
    }

    public static String generateRefreshToken() {
        return RandomStringUtils.randomAlphanumeric(64);
    }

    public static String generateApiKey() {
        return RandomStringUtils.randomAlphanumeric(24).toUpperCase();
    }

    public static String generateSessionId() {
        return RandomStringUtils.randomAlphanumeric(16);
    }

    public static void main(String[] args) {
        System.out.println("Access Token: " + generateAccessToken());
        System.out.println("Refresh Token: " + generateRefreshToken());
        System.out.println("API Key: " + generateApiKey());
        System.out.println("Session ID: " + generateSessionId());
    }
}

Performance and Memory Considerations

Efficient Random Generation

public class PerformanceOptimization {
    public static void main(String[] args) {
        // For bulk generation, reuse Random instance
        java.util.Random random = new java.util.Random();

        // Generate multiple strings efficiently
        for (int i = 0; i < 10; i++) {
            String randomString = RandomStringUtils.random(8, 0, 0, true, true, null, random);
            System.out.println("Random string " + (i + 1) + ": " + randomString);
        }

        // Generate large amounts of data
        List<String> bulkData = generateBulkData(1000, 10);
        System.out.println("Generated " + bulkData.size() + " random strings");
    }

    public static List<String> generateBulkData(int count, int length) {
        List<String> data = new ArrayList<>();
        java.util.Random random = new java.util.Random();

        for (int i = 0; i < count; i++) {
            data.add(RandomStringUtils.random(length, 0, 0, true, true, null, random));
        }

        return data;
    }
}

Real-World Examples

Mock Data Service

import java.util.HashMap;
import java.util.Map;

public class MockDataService {
    public static Map<String, Object> generateMockUser() {
        Map<String, Object> user = new HashMap<>();

        user.put("id", RandomStringUtils.randomAlphanumeric(8).toUpperCase());
        user.put("username", RandomStringUtils.randomAlphanumeric(8).toLowerCase());
        user.put("email", generateRandomEmail());
        user.put("firstName", RandomStringUtils.randomAlphabetic(6).toLowerCase());
        user.put("lastName", RandomStringUtils.randomAlphabetic(8).toLowerCase());
        user.put("phone", generateRandomPhone());
        user.put("address", generateRandomAddress());
        user.put("createdAt", generateRandomTimestamp());

        return user;
    }

    public static String generateRandomAddress() {
        String number = RandomStringUtils.randomNumeric(3);
        String street = RandomStringUtils.randomAlphabetic(8).toLowerCase();
        String city = RandomStringUtils.randomAlphabetic(6).toLowerCase();
        String state = RandomStringUtils.randomAlphabetic(2).toUpperCase();
        String zip = RandomStringUtils.randomNumeric(5);

        return number + " " + street + " St, " + city + ", " + state + " " + zip;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Map<String, Object> mockUser = generateMockUser();
            System.out.println("Mock User " + (i + 1) + ": " + mockUser);
        }
    }
}

Configuration Testing

public class ConfigurationTesting {
    public static String generateTestConfig() {
        StringBuilder config = new StringBuilder();

        // Generate random configuration values
        config.append("server.port=").append(RandomStringUtils.randomNumeric(4)).append("\n");
        config.append("database.url=jdbc:mysql://localhost:").append(RandomStringUtils.randomNumeric(4)).append("/testdb\n");
        config.append("api.key=").append(RandomStringUtils.randomAlphanumeric(32)).append("\n");
        config.append("session.timeout=").append(RandomStringUtils.randomNumeric(4)).append("\n");
        config.append("log.level=").append(RandomStringUtils.random(4, "DEBUGINFOERROR")).append("\n");

        return config.toString();
    }

    public static void main(String[] args) {
        String testConfig = generateTestConfig();
        System.out.println("Test Configuration:");
        System.out.println(testConfig);
    }
}

Best Practices

Guidelines for Random Generation

public class BestPractices {
    public static void main(String[] args) {
        // 1. Use appropriate character sets for your use case
        String password = generateSecurePassword();
        System.out.println("Secure password: " + password);

        // 2. Consider length requirements
        String shortId = RandomStringUtils.randomAlphanumeric(6);
        String longToken = RandomStringUtils.randomAlphanumeric(32);
        System.out.println("Short ID: " + shortId);
        System.out.println("Long token: " + longToken);

        // 3. Use SecureRandom for security-sensitive data
        String secureToken = generateSecureToken();
        System.out.println("Secure token: " + secureToken);

        // 4. Validate generated data
        String testData = RandomStringUtils.randomAlphanumeric(10);
        System.out.println("Generated data: " + testData);
        System.out.println("Is valid: " + isValidGeneratedData(testData));
    }

    public static String generateSecurePassword() {
        String uppercase = RandomStringUtils.randomAlphabetic(3).toUpperCase();
        String lowercase = RandomStringUtils.randomAlphabetic(3).toLowerCase();
        String numbers = RandomStringUtils.randomNumeric(2);
        String special = RandomStringUtils.random(2, "!@#$%^&*");

        return uppercase + lowercase + numbers + special;
    }

    public static String generateSecureToken() {
        SecureRandom secureRandom = new SecureRandom();
        return RandomStringUtils.random(32, 0, 0, true, true, null, secureRandom);
    }

    public static boolean isValidGeneratedData(String data) {
        return data != null && data.length() >= 6 && data.matches(".*[A-Z].*") && data.matches(".*[a-z].*") && data.matches(".*\\d.*");
    }
}

Common Pitfalls

Avoiding Common Mistakes

public class CommonPitfalls {
    public static void main(String[] args) {
        // Pitfall 1: Not considering character set requirements
        String weakPassword = RandomStringUtils.randomAlphanumeric(8);
        System.out.println("Weak password: " + weakPassword);

        String strongPassword = generateStrongPassword();
        System.out.println("Strong password: " + strongPassword);

        // Pitfall 2: Using predictable random for security
        String predictableToken = RandomStringUtils.randomAlphanumeric(16);
        System.out.println("Predictable token: " + predictableToken);

        String secureToken = generateSecureToken();
        System.out.println("Secure token: " + secureToken);

        // Pitfall 3: Not validating generated data
        String invalidData = RandomStringUtils.randomAscii(10);
        System.out.println("Invalid data: " + invalidData);

        String validData = RandomStringUtils.randomAlphanumeric(10);
        System.out.println("Valid data: " + validData);
    }

    public static String generateStrongPassword() {
        String uppercase = RandomStringUtils.randomAlphabetic(2).toUpperCase();
        String lowercase = RandomStringUtils.randomAlphabetic(2).toLowerCase();
        String numbers = RandomStringUtils.randomNumeric(2);
        String special = RandomStringUtils.random(2, "!@#$%^&*");

        return uppercase + lowercase + numbers + special;
    }

    public static String generateSecureToken() {
        SecureRandom secureRandom = new SecureRandom();
        return RandomStringUtils.random(32, 0, 0, true, true, null, secureRandom);
    }
}

Conclusion

RandomStringUtils from Apache Commons Lang provides a powerful and flexible set of utilities for generating random strings. By understanding these methods and their proper usage, you can create robust test data, secure tokens, and unique identifiers efficiently.

The key benefits include:

Flexibility - Multiple character sets and generation options
Security - Support for cryptographically secure random generation
Performance - Efficient generation for bulk operations
Convenience - Simple API for common use cases
Customization - Ability to specify custom character sets

Start incorporating RandomStringUtils into your projects and see how it simplifies your random data generation needs!

Resources

Written by Purusothaman Ramanujam

← Back to blog