Если вы счастливы использовать классы Apache, вы можете использовать org.apache.commons.text.RandomStringGenerator (commons-text).

Пример:

RandomStringGenerator randomStringGenerator =
        new RandomStringGenerator.Builder()
                .withinRange('0', 'z')
                .filteredBy(CharacterPredicates.LETTERS, CharacterPredicates.DIGITS)
                .build();
randomStringGenerator.generate(12); // toUpperCase() if you want

Поскольку commons-lang 3.6, RandomStringUtils устарел.

Это легко достижимо без каких-либо внешних библиотек.

1. Генерация криптографических псевдослучайных данных

Сначала вам нужен криптографический PRNG. Java имеет SecureRandom , для которого обычно используется лучший источник энтропии на машине (например, /dev/random). Подробнее читайте здесь.

SecureRandom rnd = new SecureRandom();
byte[] token = new byte[byteLength];
rnd.nextBytes(token);

Примечание: SecureRandom - самый медленный, но наиболее безопасный способ в Java генерации случайных байтов. Тем не менее, я рекомендую НЕ рассматривать производительность здесь, поскольку она обычно не оказывает реального влияния на ваше приложение, если вам не нужно генерировать миллионы токенов в секунду.

2. Требуемое пространство возможных значений

Затем вам нужно решить, «как уникально» ваш токен. Целая и единственная точка рассмотрения энтропии заключается в том, чтобы убедиться, что система может противостоять атакам с использованием грубой силы: пространство возможных значений должно быть настолько большим, чтобы любой атакующий мог только попробовать незначительную долю значений в непухотное время 1 [/ д2]. Уникальные идентификаторы, такие как случайные UUID , имеют 122 бит энтропии (т. Е. 2 ​​^ 122 = 5.3x10 ^ 36) - вероятность столкновения равна «* (...), чтобы существовала одна в миллиардной вероятности дублирования необходимо создать 103 триллиона версий UUID 2 ". Мы выберем 128 бит, так как он точно соответствует 16 байтам и считается достаточно высоким для того, чтобы быть уникальным для всех, но наиболее экстремальных, используемых случаев, и вам не нужно думать о дубликатах. Вот простая таблица сравнения энтропии, включая простой анализ проблемы рождения .

Для простых требований 8 или 12 длина байта может быть достаточной, но с 16 байтами вы находитесь на «безопасной стороне».

И это в основном это. Последнее стоит подумать о кодировании, чтобы его можно было представить в виде печатного текста (read, a String).

3. Бинарное кодирование текста

Типичные кодировки включают в себя:

• Base64 каждый символ кодирует 6 бит, создавая 33% служебных данных. К сожалению, стандартная реализация в JDK ( 7 и ниже отсутствует] - в Android и Java 8 + ). Но существует множество библиотек , которые добавляют это. Недостатком является то, что стандарт Base64 небезопасен, например. URL-адреса и имя файла в большинстве файловых систем, требующих дополнительного кодирования (например, url-кодирование ) или URL-адрес безопасной версии Base64 используется . Пример кодирования 16 байтов с заполнением: XfJhfv3C0P6ag7y9VQxSbw==
• Base32 каждый символ кодирует 5 бит, создавая 40% служебных данных. Это будет использовать A-Z и 2-7, что делает его разумным пространственно эффективным, нечувствительным к регистру буквенно-цифровым. Стандартная реализация в JDK отсутствует. Пример кодирования 16 байтов без заполнения: WUPIL5DQTZGMF4D3NX5L7LNFOY
• Base16 (шестнадцатеричный) каждый символ кодирует 4 бит, требующий 2 символа на каждый байт (т. Е. 16 байт создает строку длиной 32 ). Поэтому hex меньше пространства, чем Base32, но безопасен для использования в большинстве случаев (url), поскольку он использует только 0-9 и A - F. Пример кодирования 16 байтов: 4fa3dd0f57cb3bf331441ed285b27735. См. обсуждение SO о преобразовании в hex здесь.

Дополнительные кодировки, такие как Base85 и экзотический Base122 существуют с лучшей / меньшей эффективностью пространства. Вы можете создать свою собственную кодировку (которая в основном отвечает большинству ответов в этом потоке), но я бы посоветовал это сделать, если у вас нет особых требований. См. больше схем кодирования в статье Википедии.

4. Сводка и пример

• Используйте SecureRandom
• Используйте не менее 16 байт (2 ^ 128) возможных значений
• Кодируйте в соответствии с вашими требованиями (обычно hex или base32, если вам нужно, чтобы оно было буквенно-цифровым)

Не

• . .. используйте свою домашнюю кодировку для варки: лучше поддерживаются и читаемы для других, если они видят, какую стандартную кодировку вы используете, а не странно для создания циклов за один раз.
• ... используйте UUID: вы тратите 6bits энтропии и имеете подробное строковое представление

Пример: Hex Token Generator

public static String generateRandomHexToken(int byteLength) {
    SecureRandom secureRandom = new SecureRandom();
    byte[] token = new byte[byteLength];
    secureRandom.nextBytes(token);
    return new BigInteger(1, token).toString(16); //hex encoding
}

//generateRandomHexToken(16) -> 2189df7475e96aa3982dbeab266497cd

Пример: Инструмент

Если вы хотите готовый к использованию инструмент cli, вы можете использовать кости: https://github.com/patrickfav/dice

Вы упоминаете «простой», но на всякий случай кто-то ищет что-то, что отвечает более строгим требованиям безопасности, вы можете взглянуть на jpwgen . jpwgen моделируется после pwgen в Unix и очень настраивается.

public static String randomSeriesForThreeCharacter() {
    Random r = new Random();
    String value="";
    char random_Char ;
    for(int i=0; i<10;i++)
    { 
        random_Char = (char) (48 + r.nextInt(74));
        value=value+random_char;
    }
    return value;
}

Вы можете использовать библиотеку Apache для этого: RandomStringUtils

RandomStringUtils.randomAlphanumeric(20).toUpperCase();

Удивительно, что никто не предложил это, но:

import java.util.UUID

UUID.randomUUID().toString();

Легко.

Преимущество этого в том, что UUID являются хорошими и длинными и гарантированно почти невозможно столкнуться.

Википедия имеет хорошее объяснение:

«... только после генерации 1 миллиарда UUID каждую секунду в течение следующих 100 лет вероятность создания всего одного дубликата будет около 50%».

http: // ru.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates

Первые 4 бита - это тип версии и 2 для варианта, так что вы получаете 122 бит случайных значений. Поэтому, если вы хотите , вы можете обрезать с конца, чтобы уменьшить размер UUID. Это не рекомендуется, но у вас все еще есть множество случайностей, достаточно для ваших записей 500k.

Возможно, это полезно

package password.generater;

import java.util.Random;

/**
 *
 * @author dell
 */
public class PasswordGenerater {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int length= 11;
        System.out.println(generatePswd(length));

        // TODO code application logic here
    }
    static char[] generatePswd(int len){
        System.out.println("Your Password ");
        String charsCaps="ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
        String Chars="abcdefghijklmnopqrstuvwxyz";
        String nums="0123456789";
        String symbols="!@#$%^&*()_+-=.,/';:?><~*/-+";
        String passSymbols=charsCaps + Chars + nums +symbols;
        Random rnd=new Random();
        char[] password=new char[len];

        for(int i=0; i<len;i++){
            password[i]=passSymbols.charAt(rnd.nextInt(passSymbols.length()));
        }
      return password;

    }
}

Не нравится какой-либо из этих ответов относительно «простого» решения: S

Я бы выбрал простой;), чистый java, один вкладыш (энтропия основана на случайной длине строки и заданный набор символов):

public String randomString(int length, String characterSet) {
    return IntStream.range(0, length).map(i -> new SecureRandom().nextInt(characterSet.length())).mapToObj(randomInt -> characterSet.substring(randomInt, randomInt + 1)).collect(Collectors.joining());
}

@Test
public void buildFiveRandomStrings() {
    for (int q = 0; q < 5; q++) {
        System.out.println(randomString(10, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));//charachterSet can basically be anything
    }
}

или (более читаемый старый способ)

public String randomString(int length, String characterSet) {
    StringBuilder sb = new StringBuilder(); //consider using StringBuffer if needed
    for (int i = 0; i < length; i++) {
        int randomInt = new SecureRandom().nextInt(characterSet.length());
        sb.append(characterSet.substring(randomInt, randomInt + 1));
    }
    return sb.toString();
}

@Test
public void buildFiveRandomStrings() {
    for (int q = 0; q < 5; q++) {
        System.out.println(randomString(10, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")); //charachterSet can basically be anything
    }
}

Но, с другой стороны, вы также можете использовать UUID, который довольно хорош энтропия ( https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions ):

UUID.randomUUID().toString().replace("-", "")

Надеюсь, что это поможет.

Вот код одной строки от AbacusUtil

String.valueOf(CharStream.random('0', 'z').filter(c -> N.isLetterOrDigit(c)).limit(12).toArray())

Случайный не означает, что он должен быть уникальным. для получения уникальных строк, используя:

N.uuid() // e.g.: "e812e749-cf4c-4959-8ee1-57829a69a80f". length is 36.
N.guid() // e.g.: "0678ce04e18945559ba82ddeccaabfcd". length is 32 without '-'

1. Измените строковые символы в соответствии с вашими требованиями.
2. Строка неизменна. Здесь StringBuilder.append более эффективен, чем конкатенация строк.

public static String getRandomString(int length) {
       final String characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+";
       StringBuilder result = new StringBuilder();
       while(length > 0) {
           Random rand = new Random();
           result.append(characters.charAt(rand.nextInt(characters.length())));
           length--;
       }
       return result.toString();
    }

Вы можете использовать следующий код, если ваш пароль обязательно содержит номера буквенных специальных символов:

private static final String NUMBERS = "0123456789";
private static final String UPPER_ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static final String LOWER_ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
private static final String SPECIALCHARACTERS = "@#$%&*";
private static final int MINLENGTHOFPASSWORD = 8;

public static String getRandomPassword() {
    StringBuilder password = new StringBuilder();
    int j = 0;
    for (int i = 0; i < MINLENGTHOFPASSWORD; i++) {
        password.append(getRandomPasswordCharacters(j));
        j++;
        if (j == 3) {
            j = 0;
        }
    }
    return password.toString();
}

private static String getRandomPasswordCharacters(int pos) {
    Random randomNum = new Random();
    StringBuilder randomChar = new StringBuilder();
    switch (pos) {
        case 0:
            randomChar.append(NUMBERS.charAt(randomNum.nextInt(NUMBERS.length() - 1)));
            break;
        case 1:
            randomChar.append(UPPER_ALPHABETS.charAt(randomNum.nextInt(UPPER_ALPHABETS.length() - 1)));
            break;
        case 2:
            randomChar.append(SPECIALCHARACTERS.charAt(randomNum.nextInt(SPECIALCHARACTERS.length() - 1)));
            break;
        case 3:
            randomChar.append(LOWER_ALPHABETS.charAt(randomNum.nextInt(LOWER_ALPHABETS.length() - 1)));
            break;
    }
    return randomChar.toString();

}

import java.util.Date;
import java.util.Random;

public class RandomGenerator {

  private static Random random = new Random((new Date()).getTime());

    public static String generateRandomString(int length) {
      char[] values = {'a','b','c','d','e','f','g','h','i','j',
               'k','l','m','n','o','p','q','r','s','t',
               'u','v','w','x','y','z','0','1','2','3',
               '4','5','6','7','8','9'};

      String out = "";

      for (int i=0;i<length;i++) {
          int idx=random.nextInt(values.length);
          out += values[idx];
      }
      return out;
    }
}

В одной строке:

Long.toHexString(Double.doubleToLongBits(Math.random()));

http://mynotes.wordpress.com/2009/07/23/java-generating-random-string/

import java.util.*;
import javax.swing.*;
public class alphanumeric{
    public static void main(String args[]){
        String nval,lenval;
        int n,len;

        nval=JOptionPane.showInputDialog("Enter number of codes you require : ");
        n=Integer.parseInt(nval);

        lenval=JOptionPane.showInputDialog("Enter code length you require : ");
        len=Integer.parseInt(lenval);

        find(n,len);

    }
    public static void find(int n,int length) {
        String str1="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        StringBuilder sb=new StringBuilder(length);
        Random r = new Random();

        System.out.println("\n\t Unique codes are \n\n");
        for(int i=0;i<n;i++){
            for(int j=0;j<length;j++){
                sb.append(str1.charAt(r.nextInt(str1.length())));
            }
            System.out.println("  "+sb.toString());
            sb.delete(0,length);
        }
    }
}

Я нашел это решение, которое генерирует случайную шестнадцатеричную кодированную строку. Представленный модульный тест, похоже, подходит для моего основного использования. Хотя, это немного сложнее, чем некоторые другие предоставленные ответы.

/**
 * Generate a random hex encoded string token of the specified length
 *  
 * @param length
 * @return random hex string
 */
public static synchronized String generateUniqueToken(Integer length){ 
    byte random[] = new byte[length];
    Random randomGenerator = new Random();
    StringBuffer buffer = new StringBuffer();

    randomGenerator.nextBytes(random);

    for (int j = 0; j < random.length; j++) {
        byte b1 = (byte) ((random[j] & 0xf0) >> 4);
        byte b2 = (byte) (random[j] & 0x0f);
        if (b1 < 10)
            buffer.append((char) ('0' + b1));
        else
            buffer.append((char) ('A' + (b1 - 10)));
        if (b2 < 10)
            buffer.append((char) ('0' + b2));
        else
            buffer.append((char) ('A' + (b2 - 10)));
    }
    return (buffer.toString());
}

@Test
public void testGenerateUniqueToken(){
    Set set = new HashSet();
    String token = null;
    int size = 16;

    /* Seems like we should be able to generate 500K tokens 
     * without a duplicate 
     */
    for (int i=0; i<500000; i++){
        token = Utility.generateUniqueToken(size);

        if (token.length() != size * 2){
            fail("Incorrect length");
        } else if (set.contains(token)) {
            fail("Duplicate token generated");
        } else{
            set.add(token);
        }
    }
}

с использованием Доллар должен быть простым:

// "0123456789" + "ABCDE...Z"
String validCharacters = $('0', '9').join() + $('A', 'Z').join();

String randomString(int length) {
    return $(validCharacters).shuffle().slice(length).toString();
}

@Test
public void buildFiveRandomStrings() {
    for (int i : $(5)) {
        System.out.println(randomString(12));
    }
}

выводит что-то вроде этого:

DKL1SBH9UJWC
JH7P0IT21EA5
5DTI72EO6SFU
HQUMJTEBNF7Y
1HCR6SKYWGT7

static final String AB = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static SecureRandom rnd = new SecureRandom();

String randomString( int len ){
   StringBuilder sb = new StringBuilder( len );
   for( int i = 0; i < len; i++ ) 
      sb.append( AB.charAt( rnd.nextInt(AB.length()) ) );
   return sb.toString();
}