Как создать случайную буквенно-цифровую строку?

Я искал простой алгоритм Java для генерации псевдослучайной буквенно-цифровой строки. В моей ситуации он будет использоваться как уникальный идентификатор сеанса / ключа, который «вероятно» будет уникальным по сравнению с 500K + поколением (мои потребности действительно не требуют чего-то более сложного). В идеале я мог бы указать длину в зависимости от моих потребностей в уникальности. Например, сгенерированная строка длиной 12 может выглядеть примерно так: "AEYGF7K0DM1X" .

30 Solutions collect form web for “Как создать случайную буквенно-цифровую строку?”

Алгоритм

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

Реализация

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

 import java.security.SecureRandom; import java.util.Locale; import java.util.Objects; import java.util.Random; 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-адреса или повторно введены вручную.

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

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

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

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

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

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

Сравнение с UUID

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

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

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

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

Если вы счастливы использовать classы 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 устарел.

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

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

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

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

 RandomStringUtils.randomAlphanumeric(20).toUpperCase(); 

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

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

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

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

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

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

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

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

Затем вам нужно решить, «насколько уникален» ваш токен. Целая и единственная точка рассмотрения энтропии заключается в том, чтобы убедиться, что система может противостоять атакам с использованием грубой силы: пространство возможных значений должно быть настолько большим, чтобы любой злоумышленник мог попробовать только незначительную долю значений в непухое время 1 . Уникальные идентификаторы, такие как случайный UUID имеют 122 бит энтропии (т. Е. 2 ​​^ 122 = 5,3 × 10 36) – вероятность столкновения «* (…) для того, чтобы быть одним из миллиардов шансов на дублирование, 103 трлн. версия 4 UUID должны быть сгенерированы 2 “. Мы выберем 128 бит, так как он точно соответствует 16 байтам и считается настолько большим, чтобы быть уникальным для практически всех, но наиболее экстремальных случаев использования, и вам не нужно думать о дубликатах. Вот простая таблица сравнения энтропии, включая простой анализ проблемы дня рождения .

сравнение размеров токенов

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

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

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

Типичные кодировки include:

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

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

  • Base16 (hex) каждый символ кодирует 4 бит, требующий 2 символа на каждый байт (т. Е. 16 байт создает строку длиной 32). Поэтому hex меньше пространства, чем Base32 но безопасен для использования в большинстве случаев (url), поскольку он использует только 0-9 и A F . Пример кодирования 16 байт: 4fa3dd0f57cb3bf331441ed285b27735 . См. Обсуждение SO о преобразовании в hex здесь.

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

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); //hex encoding } //generateRandomHexToken(16) -> 2189df7475e96aa3982dbeab266497cd 

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

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

Удивительный никто здесь не предложил, но:

 import java.util.UUID UUID.randomUUID().toString(); 

Легко.

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

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

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

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

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

Здесь он находится в 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 

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

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

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

Альтернативой в 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) .mapToObj((i) -> (char) i) .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append) .toString(); } 
 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 

Использование UUID небезопасно, потому что части UUID вообще не случайны. Процедура @erickson очень аккуратная, но не создает строки одинаковой длины. Следующий fragment должен быть достаточным:

 /* * 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 и символы az, нам понадобится случайное число от 0 до 35, чтобы получить один из каждого символа. BigInteger предоставляет конструктор для генерации случайного числа, равномерно распределенного в диапазоне от 0 to (2^numBits - 1) . К сожалению, 35 не является числом, которое может быть получено 2 ^ numBits – 1. Таким образом, у нас есть два варианта: либо пойти с 2^5-1=31 либо 2^6-1=63 . Если бы мы выбрали 2^6 мы получили бы много «лишних» / «более длинных» чисел. Поэтому 2^5 является лучшим вариантом, даже если мы потеряем 4 символа (wz). Чтобы сгенерировать строку определенной длины, мы можем просто использовать номер 2^(length*numBits)-1 . Последняя проблема, если нам нужна строка с определенной длиной, случайный может генерировать небольшое число, поэтому длина не выполняется, поэтому нам нужно заполнить строку нужной нулевой длиной.

 import java.util.Random; public class passGen{ //Verison 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 String pass = ""; 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(25); pass += dCase.charAt(spot); } else if (rPick == 1) { int spot = r.nextInt (25); pass += uCase.charAt(spot); } else if (rPick == 2) { int spot = r.nextInt (7); pass += sChar.charAt(spot); } else if (rPick == 3){ int spot = r.nextInt (9); pass += intChar.charAt (spot); } } System.out.println ("Generated Pass: " + pass); } } 

Итак, что это такое, просто добавьте пароль в строку и … да, хорошо проверите это … очень просто. Я написал это

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

 /** * 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); } } } образом /** * 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); } } } 
 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 
  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(); } 
 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 

Don’t really like any of this answers regarding “simple” solution :S

I would go for a simple ;), pure java, one liner (entropy is based on random string length and the given character set):

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

or (a bit more readable old way)

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

But on the other hand you could also go with UUID which has a pretty good entropy ( https://en.wikipedia.org/wiki/Universally_unique_identifier#Collisions ):

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

Hope that helps.

Here it is a Scala solution:

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

You can use the UUID class with its getLeastSignificantBits() message to get 64bit of Random data, then convert it to a radix 36 number (ie a string consisting of 0-9,AZ):

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

This yields a String up to 13 characters long. We use Math.abs() to make sure there isn’t a minus sign sneaking in.

You can use following code , if your password mandatory contains numbers alphabetic special characters:

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

Here is the one line code by AbacusUtil

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

Random doesn’t mean it must be unique. to get unique strings, using:

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

You mention “simple”, but just in case anyone else is looking for something that meets more stringent security requirements, you might want to take a look at jpwgen . jpwgen is modeled after pwgen in Unix, and is very configurable.

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

using apache library it can be done in one line

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

here is doc http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/RandomStringUtils.html

Maybe this is helpful

 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 

Best Random String Generator Method

 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; } } 
 public static String getRandomString(int length) { String randomStr = UUID.randomUUID().toString(); while(randomStr.length() < length) { randomStr += UUID.randomUUID().toString(); } return randomStr.substring(0, length); } 
  • Создание случайных, уникальных значений C #
  • srand () - зачем вызывать его только один раз?
  • Сколько случайных элементов перед MD5 вызывает столкновения?
  • Случайные / шумовые функции для GLSL
  • Interesting Posts

    Случайные ошибки при смене серии с использованием JFreeChart

    Как получить один файл из определенной версии в Git

    Чтение двоичных данных stdout из оболочки adb?

    Каковы основные понятия прозрачности, которые должен знать каждый разработчик?

    Windows 10: переименовать закрепленные элементы в Quick Access

    Weird Wifi проблема в Windows

    BSOD «STOP 0x0000007B» после установки WIndows XP на внешний жесткий диск

    Не найдено ни одного приложения для журнала (log4j)?

    Будет ли SSD предотвращать перегрев ноутбука?

    Попытка настроить домашний сервер, но не в состоянии настроить IP-пересылку

    Как создать подписанный файл apk для выпуска с помощью Gradle?

    Перемещение Ctrl-Alt-Arrow в Windows 10 с помощью AutoHotkey

    Зачем нужен маршрутизатор?

    Название центра панели инструментов Android и собственный шрифт

    Как инициализируется ЦП с помощью тактовых импульсов?

    Давайте будем гением компьютера.