Алгоритм

Чтобы сгенерировать случайную строку, объедините символы, выбранные случайным образом из набора допустимых символов, пока строка не достигнет желаемой длины.

Выполнение

Вот довольно простой и очень гибкий код для генерации случайных идентификаторов. Прочтите следующую информацию за важные замечания по применению.

public class RandomString {

    /**
     * Generate a random string.
     */
    public String nextString() {
        for (int idx = 0; idx < buf.length; ++idx)
            buf[idx] = symbols[random.nextInt(symbols.length)];
        return new String(buf);
    }

    public static final String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    public static final String lower = upper.toLowerCase(Locale.ROOT);

    public static final String digits = "0123456789";

    public static final String alphanum = upper + lower + digits;

    private final Random random;

    private final char[] symbols;

    private final char[] buf;

    public RandomString(int length, Random random, String symbols) {
        if (length < 1) throw new IllegalArgumentException();
        if (symbols.length() < 2) throw new IllegalArgumentException();
        this.random = Objects.requireNonNull(random);
        this.symbols = symbols.toCharArray();
        this.buf = new char[length];
    }

    /**
     * Create an alphanumeric string generator.
     */
    public RandomString(int length, Random random) {
        this(length, random, alphanum);
    }

    /**
     * Create an alphanumeric strings from a secure generator.
     */
    public RandomString(int length) {
        this(length, new SecureRandom());
    }

    /**
     * Create session identifiers.
     */
    public RandomString() {
        this(21);
    }

}

Примеры использования

Создайте небезопасный генератор для 8-значных идентификаторов:

RandomString gen = new RandomString(8, ThreadLocalRandom.current());

Создайте безопасный генератор идентификаторов сессий:

RandomString session = new RandomString();

Создайте генератор с легко читаемыми кодами для печати. Строки длиннее, чем полные буквенно-цифровые строки, чтобы компенсировать использование меньшего количества символов:

String easy = RandomString.digits + "ACEFGHJKLMNPQRUVWXYabcdefhijkprstuvwx";
RandomString tickets = new RandomString(23, new SecureRandom(), easy);

Использовать как идентификаторы сеанса

Недостаточно генерировать идентификаторы сеанса, которые могут быть уникальными, или вы можете просто использовать простой счетчик. Злоумышленники захватывают сеансы, когда используются предсказуемые идентификаторы.

Между длиной и безопасностью существует противоречие. Более короткие идентификаторы легче угадать, потому что здесь меньше возможностей. Но более длинные идентификаторы занимают больше места для хранения и пропускной способности. Большой набор символов помогает, но может вызвать проблемы с кодированием, если идентификаторы включены в URL-адреса или повторно введены вручную.

Базовый источник случайности или энтропии для идентификаторов сеанса должен исходить от генератора случайных чисел, предназначенного для криптографии. Однако инициализация этих генераторов иногда может быть дорогостоящей или медленной с точки зрения вычислений, поэтому следует прилагать усилия для их повторного использования, когда это возможно.

Использовать как идентификаторы объекта

Не каждое приложение требует безопасности. Случайное назначение может быть эффективным способом для нескольких объектов генерировать идентификаторы в общем пространстве без какой-либо координации или разделения. Координация может быть медленной, особенно в кластерной или распределенной среде, а разделение пространства вызывает проблемы, когда объекты в конечном итоге имеют слишком маленькие или слишком большие общие ресурсы.

Идентификаторы, созданные без принятия мер по их непредсказуемости, должны быть защищены другими средствами, если злоумышленник может просматривать их и манипулировать ими, как это происходит в большинстве веб-приложений. Должна быть отдельная система авторизации, защищающая объекты, идентификатор которых злоумышленник может угадать без разрешения на доступ.

Также необходимо проявлять осторожность, чтобы использовать идентификаторы, которые имеют достаточную длину, чтобы сделать коллизии маловероятными, учитывая ожидаемое общее количество идентификаторов. Это называется «парадоксом дня рождения». Вероятность столкновения,п, приблизительно равно n² / (2q^x), где п - количество фактически сгенерированных идентификаторов, q - количество различных символов в алфавите, а Икс - длина идентификаторов. Это должно быть очень маленькое число, например 2^‑50 или меньше.

Расчет этого показывает, что вероятность столкновения между 500 000 15-символьными идентификаторами составляет около 2^‑52, что, вероятно, менее вероятно, чем необнаруженные ошибки космических лучей и т. д.

Сравнение с UUID

Согласно их спецификации, UUID не предназначены для непредсказуемости, и не следует может использоваться как идентификаторы сеанса.

UUID в их стандартном формате занимают много места: 36 символов всего на 122 бита энтропии. (Не все биты «случайного» UUID выбираются случайным образом.) Произвольно выбранная буквенно-цифровая строка содержит больше энтропии всего за 21 символ.

UUID не гибкие; они имеют стандартизированную структуру и расположение. Это их главное достоинство, а также их главная слабость. При сотрудничестве с внешней стороной может оказаться полезной стандартизация, предлагаемая UUID. Для чисто внутреннего использования они могут оказаться неэффективными.

Вот это на Java:

import static java.lang.Math.round;
import static java.lang.Math.random;
import static java.lang.Math.pow;
import static java.lang.Math.abs;
import static java.lang.Math.min;
import static org.apache.commons.lang.StringUtils.leftPad

public class RandomAlphaNum {
  public static String gen(int length) {
    StringBuffer sb = new StringBuffer();
    for (int i = length; i > 0; i -= 12) {
      int n = min(12, abs(i));
      sb.append(leftPad(Long.toString(round(random() * pow(36, n)), 36), n, '0'));
    }
    return sb.toString();
  }
}

Вот пример выполнения:

scala> RandomAlphaNum.gen(42)
res3: java.lang.String = uja6snx21bswf9t89s00bxssu8g6qlu16ffzqaxxoy

Java предоставляет способ сделать это напрямую. Если вам не нужны тире, их легко удалить. Просто используйте uuid.replace("-", "")

import java.util.UUID;

public class randomStringGenerator {
    public static void main(String[] args) {
        System.out.println(generateString());
    }

    public static String generateString() {
        String uuid = UUID.randomUUID().toString();
        return "uuid = " + uuid;
    }
}

Выход

uuid = 2d7428a6-b58c-4008-8575-f05549f16316

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

/**
 * 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);
        }
    }
}

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

Пример:

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

Начиная с Apache Commons Lang 3.6, RandomStringUtils устарел.

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();
}

Я разработал приложение для разработки автоматически сгенерированной буквенно-цифровой строки для моего проекта. В этой строке первые три символа являются алфавитными, а следующие семь - целыми числами.

public class AlphaNumericGenerator {

    public static void main(String[] args) {
        java.util.Random r = new java.util.Random();
        int i = 1, n = 0;
        char c;
        String str = "";
        for (int t = 0; t < 3; t++) {
            while (true) {
                i = r.nextInt(10);
                if (i > 5 && i < 10) {

                    if (i == 9) {
                        i = 90;
                        n = 90;
                        break;
                    }
                    if (i != 90) {
                        n = i * 10 + r.nextInt(10);
                        while (n < 65) {
                            n = i * 10 + r.nextInt(10);
                        }
                    }
                    break;
                }
            }
            c = (char)n;

            str = String.valueOf(c) + str;
        }

        while(true){
            i = r.nextInt(10000000);
            if (i > 999999)
                break;
        }
        str = str + i;
        System.out.println(str);
    }
}

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

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

Источник: Java - создание случайной строки

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

// "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

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);
        }
    }
}

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

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;
    }
}

import java.util.Random;

public class passGen{
    // Version 1.0
    private static final String dCase = "abcdefghijklmnopqrstuvwxyz";
    private static final String uCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String sChar = "!@#$%^&*";
    private static final String intChar = "0123456789";
    private static Random r = new Random();
    private static StringBuilder pass = new StringBuilder();

    public static void main (String[] args) {
        System.out.println ("Generating pass...");
        while (pass.length () != 16){
            int rPick = r.nextInt(4);
            if (rPick == 0){
                int spot = r.nextInt(26);
                pass.append(dCase.charAt(spot));
            } else if (rPick == 1) {
                int spot = r.nextInt(26);
                pass.append(uCase.charAt(spot));
            } else if (rPick == 2) {
                int spot = r.nextInt(8);
                pass.append(sChar.charAt(spot));
            } else {
                int spot = r.nextInt(10);
                pass.append(intChar.charAt(spot));
            }
        }
        System.out.println ("Generated Pass: " + pass.toString());
    }
}

Это просто добавляет пароль в строку и ... да, работает хорошо. Проверьте это ... Это очень просто; Я это написал.

Краткое и простое решение, но в нем используются только строчные буквы и числа:

Random r = new java.util.Random ();
String s = Long.toString (r.nextLong () & Long.MAX_VALUE, 36);

Размер составляет примерно 12 цифр до 36 и не может быть улучшен таким образом. Конечно, вы можете добавить несколько экземпляров.

Лучший метод генератора случайных строк

public class RandomStringGenerator{

    private static int randomStringLength = 25 ;
    private static boolean allowSpecialCharacters = true ;
    private static String specialCharacters = "!@$%*-_+:";
    private static boolean allowDuplicates = false ;

    private static boolean isAlphanum = false;
    private static boolean isNumeric = false;
    private static boolean isAlpha = false;
    private static final String alphabet = "abcdefghijklmnopqrstuvwxyz";
    private static boolean mixCase = false;
    private static final String capAlpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String num = "0123456789";

    public static String getRandomString() {
        String returnVal = "";
        int specialCharactersCount = 0;
        int maxspecialCharacters = randomStringLength/4;

        try {
            StringBuffer values = buildList();
            for (int inx = 0; inx < randomStringLength; inx++) {
                int selChar = (int) (Math.random() * (values.length() - 1));
                if (allowSpecialCharacters)
                {
                    if (specialCharacters.indexOf("" + values.charAt(selChar)) > -1)
                    {
                        specialCharactersCount ++;
                        if (specialCharactersCount > maxspecialCharacters)
                        {
                            while (specialCharacters.indexOf("" + values.charAt(selChar)) != -1)
                            {
                                selChar = (int) (Math.random() * (values.length() - 1));
                            }
                        }
                    }
                }
                returnVal += values.charAt(selChar);
                if (!allowDuplicates) {
                    values.deleteCharAt(selChar);
                }
            }
        } catch (Exception e) {
            returnVal = "Error While Processing Values";
        }
        return returnVal;
    }

    private static StringBuffer buildList() {
        StringBuffer list = new StringBuffer(0);
        if (isNumeric || isAlphanum) {
            list.append(num);
        }
        if (isAlpha || isAlphanum) {
            list.append(alphabet);
            if (mixCase) {
                list.append(capAlpha);
            }
        }
        if (allowSpecialCharacters)
        {
            list.append(specialCharacters);
        }
        int currLen = list.length();
        String returnVal = "";
        for (int inx = 0; inx < currLen; inx++) {
            int selChar = (int) (Math.random() * (list.length() - 1));
            returnVal += list.charAt(selChar);
            list.deleteCharAt(selChar);
        }
        list = new StringBuffer(returnVal);
        return list;
    }   

}

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

RandomStringUtils.randomAlphanumeric(20).toUpperCase();

Вот решение Scala:

(for (i <- 0 until rnd.nextInt(64)) yield { 
  ('0' + rnd.nextInt(64)).asInstanceOf[Char] 
}) mkString("")

public static String generateSessionKey(int length){
    String alphabet =
        new String("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); // 9

    int n = alphabet.length(); // 10

    String result = new String();
    Random r = new Random(); // 11

    for (int i=0; i<length; i++) // 12
        result = result + alphabet.charAt(r.nextInt(n)); //13

    return result;
}

Используя библиотеку Apache Commons, это можно сделать одной строкой:

import org.apache.commons.lang.RandomStringUtils;
RandomStringUtils.randomAlphanumeric(64);

Документация

Удивительно, но здесь никто этого не предлагал, но:

import java.util.UUID

UUID.randomUUID().toString();

Легко.

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

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

" ...only after generating 1 billion UUIDs every second for the next 100 years, the probability of creating just one duplicate would be about 50%."

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

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

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();
}

public static String getRandomString(int length)
{
    String randomStr = UUID.randomUUID().toString();
    while(randomStr.length() < length) {
        randomStr += UUID.randomUUID().toString();
    }
    return randomStr.substring(0, length);
}

В предыдущих ответах много использовалось StringBuilder. Думаю, это просто, но для этого требуется вызов функции для каждого символа, увеличение массива и т. д.

При использовании конструктора строк рекомендуется указать требуемую емкость строки, т. Е.

new StringBuilder(int capacity);

Вот версия, в которой не используются добавление StringBuilder или String и нет словаря.

public static String randomString(int length)
{
    SecureRandom random = new SecureRandom();
    char[] chars = new char[length];
    for(int i=0; i<chars.length; i++)
    {
        int v = random.nextInt(10 + 26 + 26);
        char c;
        if (v < 10)
        {
            c = (char)('0' + v);
        }
        else if (v < 36)
        {
            c = (char)('a' - 10 + v);
        }
        else
        {
            c = (char)('A' - 36 + v);
        }
        chars[i] = c;
    }
    return new String(chars);
}

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;
}

Вы можете создать массив символов, который включает в себя все буквы и цифры, а затем вы можете случайным образом выбрать из этого массива символов и создать свой собственный строковый пароль.

char[] chars = new char[62]; // Sum of letters and numbers

int i = 0;

for(char c = 'a'; c <= 'z'; c++) { // For letters
    chars[i++] = c;
}

for(char c = '0'; c <= '9';c++) { // For numbers
    chars[i++] = c;
}

for(char c = 'A'; c <= 'Z';c++) { // For capital letters
    chars[i++] = c;
}

int numberOfCodes = 0;
String code = "";
while (numberOfCodes < 1) { // Enter how much you want to generate at one time
    int numChars = 8; // Enter how many digits you want in your password

    for(i = 0; i < numChars; i++) {
        char c = chars[(int)(Math.random() * chars.length)];
        code = code + c;
    }
    System.out.println("Code is:" + code);
}

Вы можете использовать класс UUID с его сообщением getLeastSignificantBits (), чтобы получить 64-битные данные случайный, а затем преобразовать их в число с основанием 36 (то есть строку, состоящую из 0-9, A-Z):

Long.toString(Math.abs( UUID.randomUUID().getLeastSignificantBits(), 36));

Это дает нить длиной до 13 символов. Мы используем Math.abs (), чтобы убедиться, что нет знака минус.

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();
}

Альтернатива в Java 8:

static final Random random = new Random(); // Or SecureRandom
static final int startChar = (int) '!';
static final int endChar = (int) '~';

static String randomString(final int maxLength) {
  final int length = random.nextInt(maxLength + 1);
  return random.ints(length, startChar, endChar + 1)
        .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
        .toString();
}

Еще одно решение ...

public static String generatePassword(int passwordLength) {
    int asciiFirst = 33;
    int asciiLast = 126;
    Integer[] exceptions = { 34, 39, 96 };

    List<Integer> exceptionsList = Arrays.asList(exceptions);
    SecureRandom random = new SecureRandom();
    StringBuilder builder = new StringBuilder();
    for (int i=0; i<passwordLength; i++) {
        int charIndex;

        do {
            charIndex = random.nextInt(asciiLast - asciiFirst + 1) + asciiFirst;
        }
        while (exceptionsList.contains(charIndex));

        builder.append((char) charIndex);
    }
    return builder.toString();
}

Использование UUID небезопасно, потому что части UUID вовсе не случайны. процедура эриксона очень удобен, но он не создает строки одинаковой длины. Следующего фрагмента должно быть достаточно:

/*
 * The random generator used by this class to create random keys.
 * In a holder class to defer initialization until needed.
 */
private static class RandomHolder {
    static final Random random = new SecureRandom();
    public static String randomKey(int length) {
        return String.format("%"+length+"s", new BigInteger(length*5/*base 32,2^5*/, random)
            .toString(32)).replace('\u0020', '0');
    }
}

Почему выбирают length*5? Давайте предположим простой случай случайной строки длины 1, то есть одного случайного символа. Чтобы получить случайный символ, содержащий все цифры 0-9 и символы a-z, нам потребуется случайное число от 0 до 35, чтобы получить по одному каждому символу.

BigInteger предоставляет конструктор для генерации случайного числа, равномерно распределенного в диапазоне 0 to (2^numBits - 1). К сожалению, 35 - это не число, которое можно получить с помощью 2 ^ numBits - 1.

Итак, у нас есть два варианта: либо использовать 2^5-1=31, либо 2^6-1=63. Если бы мы выбрали 2^6, то получили бы много «ненужных» / «длинных» номеров. Поэтому 2^5 - лучший вариант, даже если мы потеряем четыре символа (w-z). Теперь, чтобы сгенерировать строку определенной длины, мы можем просто использовать число 2^(length*numBits)-1. Последняя проблема: если нам нужна строка определенной длины, random может сгенерировать небольшое число, поэтому длина не соблюдается, поэтому мы должны дополнить строку до требуемой длины, добавив нули.

Может быть, это полезно

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;

    }
}

Вот однострочный текст от 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. Генерация криптографических псевдослучайных данных (PRNG)

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

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

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

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

Затем вам нужно решить, насколько уникальным должен быть ваш токен. Весь и единственный смысл рассмотрения энтропии состоит в том, чтобы убедиться, что система может противостоять атакам грубой силы: пространство возможных значений должно быть настолько большим, чтобы любой злоумышленник мог попробовать только незначительную часть значений за несмешное время ¹.

Уникальные идентификаторы, такие как random UUID, имеют 122 бита энтропии (т. Е. 2 ​​^ 122 = 5,3x10 ^ 36) - вероятность коллизии равна «* (...), так как вероятность дублирования составляет один на миллиард, 103 должен быть сгенерирован триллион UUID версии 4 ² ". Мы выберем 128 бит, так как он умещается ровно в 16 байт. и рассматривается как весьма достаточный, поскольку он уникален практически для всех, но в самых крайних случаях использования, и вам не нужно думать о дубликатах. Вот простая сравнительная таблица энтропии, включая простой анализ проблема дня рождения.

^{For simple requirements, 8 or 12 byte length might suffice, but with 16 bytes you are on the "safe side".}

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

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

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

• Base64 каждый символ кодирует 6 бит, создавая 33% накладных расходов. К счастью, в Java 8+ и Android есть стандартные реализации. Со старой версией Java вы можете использовать любой из многочисленные сторонние библиотеки. Если вы хотите, чтобы ваши токены были безопасными для URL, используйте версию URL-безопасный RFC4648 (которая обычно поддерживается большинством реализаций). Пример кодирования 16 байтов с заполнением: XfJhfv3C0P6ag7y9VQxSbw==

• Base32 каждый символ кодирует 5 бит, создавая 40% накладных расходов. Это будет использовать A-Z и 2-7, что сделает его разумно эффективным по занимаемому пространству, при этом буквенно-числовые символы без учета регистра. Нет никакого стандартная реализация в JDK. Пример кодирования 16 байтов без заполнения: WUPIL5DQTZGMF4D3NX5L7LNFOY

• Base16 (шестнадцатеричный) каждый символ кодирует четыре бита, требуя двух символов на байт (т.е. 16 байтов создают строку длиной 32). Поэтому шестнадцатеричный формат менее эффективен, чем Base32, но его можно использовать в большинстве случаев (URL), поскольку он использует только 0-9 и A - F. Пример кодирования 16 байт: 4fa3dd0f57cb3bf331441ed285b27735. См. Обсуждение Stack Overflow о преобразовании в шестнадцатеричный формат здесь..

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

4. Резюме и пример

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

Не надо

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

Пример: Генератор шестнадцатеричных токенов

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); // Hexadecimal encoding
}

//generateRandomHexToken(16) -> 2189df7475e96aa3982dbeab266497cd

Пример: генератор токенов Base64 (безопасный для URL)

public static String generateRandomBase64Token(int byteLength) {
    SecureRandom secureRandom = new SecureRandom();
    byte[] token = new byte[byteLength];
    secureRandom.nextBytes(token);
    return Base64.getUrlEncoder().withoutPadding().encodeToString(token); //base64 encoding
}

//generateRandomBase64Token(16) -> EEcCCAYuUcQk7IuzdaPzrg

Пример: Java CLI Tool

Если вам нужен готовый инструмент CLI, вы можете использовать игральная кость:

Пример: Связанная проблема - Защитите свои текущие идентификаторы

Если у вас уже есть идентификатор, который вы можете использовать (например, синтетический long в вашей сущности), но не хочу публиковать внутреннюю ценность, вы можете использовать эту библиотеку для его шифрования и обфускации: https://github.com/patrickfav/id-mask

IdMask<Long> idMask = IdMasks.forLongIds(Config.builder(key).build());
String maskedId = idMask.mask(id);
// Example: NPSBolhMyabUBdTyanrbqT8
long originalId = idMask.unmask(maskedId);

Кроме того, вы можете генерировать любые строчные или прописные буквы или даже специальные символы с помощью данных из таблицы ASCII. Например, сгенерируйте буквы в верхнем регистре от A (DEC 65) до Z (DEC 90):

String generateRandomStr(int min, int max, int size) {
    String result = "";
    for (int i = 0; i < size; i++) {
        result += String.valueOf((char)(new Random().nextInt((max - min) + 1) + min));
    }
    return result;
}

Сгенерированный вывод для generateRandomStr(65, 90, 100));:

TVLPFQJCYFXQDCQSLKUKKILKKHAUFYEXLUQFHDWNMRBIRRRWNXNNZQTINZPCTKLHGHVYWRKEOYNSOFPZBGEECFMCOKWHLHCEWLDZ

Мне не очень нравятся эти ответы относительно "простого" решения: 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")); // The character set 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")); // The character set can basically be anything
    }
}

Но с другой стороны, вы также можете использовать UUID, который имеет довольно хорошую энтропию:

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

Вот простой однострочник, использующий UUID в качестве базы символов и возможность указать (почти) любую длину. (Да, я знаю, что использование UUID предлагалось раньше.)

public static String randString(int length) {
    return UUID.randomUUID().toString().replace("-", "").substring(0, Math.min(length, 32)) + (length > 32 ? randString(length - 32) : "");
}

public static String getRandomString(int length) {
    char[] chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRST".toCharArray();

    StringBuilder sb = new StringBuilder();
    Random random = new Random();
    for (int i = 0; i < length; i++) {
        char c = chars[random.nextInt(chars.length)];
        sb.append(c);
    }
    String randomStr = sb.toString();

    return randomStr;
}

Я думаю, что это самое маленькое решение здесь или почти одно из самых маленьких:

 public String generateRandomString(int length) {
    String randomString = "";

    final char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890".toCharArray();
    final Random random = new Random();
    for (int i = 0; i < length; i++) {
        randomString = randomString + chars[random.nextInt(chars.length)];
    }

    return randomString;
}

Код работает нормально. Если вы используете этот метод, я рекомендую вам использовать более 10 символов. Коллизия происходит при 5 символах / 30362 итерациях. Это заняло 9 секунд.

Вот решение Java 8 на основе потоков.

    public String generateString(String alphabet, int length) {
        return generateString(alphabet, length, new SecureRandom()::nextInt);
    }

    // nextInt = bound -> n in [0, bound)
    public String generateString(String source, int length, IntFunction<Integer> nextInt) {
        StringBuilder sb = new StringBuilder();
        IntStream.generate(source::length)
                .boxed()
                .limit(length)
                .map(nextInt::apply)
                .map(source::charAt)
                .forEach(sb::append);

        return sb.toString();
    }

Используйте это как

String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
int length = 12;
String generated = generateString(alphabet, length);
System.out.println(generated);

Функция nextInt должна принимать int bound и возвращать случайное число от 0 до bound - 1.

Эффективно и коротко.

/**
 * Utility class for generating random Strings.
 */
public interface RandomUtil {

    int    DEF_COUNT = 20;
    Random RANDOM    = new SecureRandom();

    /**
     * Generate a password.
     *
     * @return the generated password
     */
    static String generatePassword() {
        return generate(true, true);
    }

    /**
     * Generate an activation key.
     *
     * @return the generated activation key
     */
    static String generateActivationKey() {
        return generate(false, true);
    }

    /**
     * Generate a reset key.
     *
     * @return the generated reset key
     */
    static String generateResetKey() {
        return generate(false, true);
    }

    static String generate(boolean letters, boolean numbers) {
        int
            start = ' ',
            end   = 'z' + 1,
            count = DEF_COUNT,
            gap   = end - start;
        StringBuilder builder = new StringBuilder(count);

        while (count-- != 0) {
            int codePoint = RANDOM.nextInt(gap) + start;

            switch (getType(codePoint)) {
                case UNASSIGNED:
                case PRIVATE_USE:
                case SURROGATE:
                    count++;
                    continue;
            }

            int numberOfChars = charCount(codePoint);

            if (count == 0 && numberOfChars > 1) {
                count++;
                continue;
            }

            if (letters && isLetter(codePoint)
                || numbers && isDigit(codePoint)
                || !letters && !numbers) {

                builder.appendCodePoint(codePoint);
                if (numberOfChars == 2)
                    count--;
            }
            else
                count++;
        }
        return builder.toString();
    }
}

public static String RandomAlphanum(int length)
{
    String charstring = "abcdefghijklmnopqrstuvwxyz0123456789";
    String randalphanum = "";
    double randroll;
    String randchar;
    for (double i = 0; i < length; i++)
    {
        randroll = Math.random();
        randchar = "";
        for (int j = 1; j <= 35; j++)
        {
            if (randroll <= (1.0 / 36.0 * j))
            {
                randchar = Character.toString(charstring.charAt(j - 1));
                break;
            }
        }
        randalphanum += randchar;
    }
    return randalphanum;
}

Я использовал очень примитивный алгоритм с использованием Math.random (). Чтобы увеличить случайность, вы можете напрямую реализовать класс util.Date. Тем не менее, это работает.

Я использую библиотеку из Apache Commons для создания буквенно-цифровой строки:

import org.apache.commons.lang3.RandomStringUtils;

String keyLength = 20;
RandomStringUtils.randomAlphanumeric(keylength);

Это быстро и просто!