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

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

вопрос задан 3.09.2008
Todd
1913 репутация

42 ответов


  • 0 рейтинг
    /**
        Generate a random String with maxlength random
        characters found in the ASCII table between 33
        and 122 (so it contains every lowercase / uppercase
        letters, numbers and some others characters
    */
    public static String GetRandomString(int maxlength)
    {
        String result = "";
        int i = 0, n = 0, min = 33, max = 122;
        while(i < maxlength)
        {
            n = (int)(Math.random() * (max - min) + min);
            if(n >= 33 && n < 123)
            {
                result += (char)n;
                ++i;
            }
        }
        return(result);
    }
    
    ответ дан Imagine Breaker, с репутацией 1256, 22.08.2014
  • 0 рейтинг

    Случайная 10-буквенная строка между верхним и нижним регистром

    StringBuilder randomString = new StringBuilder();   
    Random random = new Random();
    boolean alphaType = true;
    int j;
    
    for(int i = 0; i <= 9; ++i)
    {
        j = (random.nextInt(25) + (alphaType == true ? 65 : 97));
        randomString.append((char)j);
        alphaType = !alphaType;
    }
    return randomString.toString();
    
    ответ дан Albert, с репутацией 11, 25.09.2012
  • 0 рейтинг
    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();
    }
    
    ответ дан maxp, с репутацией 3174, 1.10.2008
  • 0 рейтинг
    public static String getRandomString(int length) 
    {
       String randomStr = UUID.randomUUID().toString();
       while(randomStr.length() < length) {
           randomStr += UUID.randomUUID().toString();
       }
       return randomStr.substring(0, length);
    }
    
    ответ дан Vin Ferothas, с репутацией 11, 3.12.2012
  • 0 рейтинг

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

    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);
        }
    
    ответ дан Burak T, с репутацией 37, 9.01.2013
  • 0 рейтинг

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

    // "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
    
    ответ дан dfa, с репутацией 91372, 1.02.2010
  • 0 рейтинг

    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
    
    ответ дан Steve McLeod, с репутацией 32167, 3.09.2008
  • 0 рейтинг

    Также вы можете генерировать любые буквы в нижнем или верхнем регистре или даже специальные символы мысли из таблицы 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
    
    ответ дан kyxap, с репутацией 156, 1.07.2017
  • 0 рейтинг
    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;
        }
    
    ответ дан Prasad Parab, с репутацией 37, 17.08.2018
  • 0 рейтинг

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

    (for (i <- 0 until rnd.nextInt(64)) yield { 
      ('0' + rnd.nextInt(64)).asInstanceOf[Char] 
    }) mkString("")
    
    ответ дан Ugo Matrangolo, с репутацией 21, 24.07.2012
  • 0 рейтинг

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

    /**
     * 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);
            }
        }
    }
    
    ответ дан Todd, с репутацией 1913, 3.09.2008
  • 0 рейтинг

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

    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
    ответ дан Kristian Kraljic, с репутацией 674, 4.08.2016
  • 0 рейтинг
    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
    ответ дан Suganya, с репутацией 11, 30.06.2011
  • 0 рейтинг

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

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

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

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

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

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

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

    comparison of token sizes

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

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

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

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

    • Base64 каждый символ кодирует 6 бит, создавая накладные расходы на 33%. К сожалению, в JDK нет стандартной реализации ( 7 и ниже - есть в Android и Java 8+ ). Но существует множество библиотек , которые добавляют это. Недостатком является то, что стандарт Base64 небезопасен, например. 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 о преобразовании в гекс здесь.

    Дополнительные кодировки, такие как 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); //hex encoding
    }
    
    //generateRandomHexToken(16) -> 2189df7475e96aa3982dbeab266497cd
    

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

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

    ответ дан for3st, с репутацией 20985, 28.05.2017
  • 0 рейтинг

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

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

    http: // mynotes. WordPress. com / 2009/07/23 / java-generation-random-string /

    ответ дан maxp, с репутацией 3174, 17.09.2009
  • 0 рейтинг

    Не очень нравится любой из этих ответов относительно "простого" решения: 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. википедия. org / wiki / Universally_unique_identifier # Collisions ):

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

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

    ответ дан Patrik Bego, с репутацией 2191, 21.02.2018
  • 0 рейтинг

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

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

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

    ответ дан neuhaus, с репутацией 1, 29.07.2013
  • 0 рейтинг
    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
    ответ дан rina, с репутацией 21, 9.10.2012
  • 0 рейтинг

    Вы можете использовать эту простую функцию Java:

     public class GenerateRandomString {
       private static final String ALPHA_NUM =
               "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
       public static void main(String[] args) {
          GenerateRandomString grs = new GenerateRandomString();
          System.out.println(grs.getAlphaNumeric(10));
          System.out.println(grs.getAlphaNumeric(20));
       }
       public String getAlphaNumeric(int len) {
          StringBuffer sb = new StringBuffer(len);
          for (int i=0;  i
    ответ дан Zeba, с репутацией 2224, 21.01.2013
  • 0 рейтинг

    Вот код одной строки от 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 '-'
    
    ответ дан user_3380739, с репутацией 783, 28.11.2016
  • 0 рейтинг

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

    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);
    
        }
    }
    
    ответ дан maxp, с репутацией 3174, 19.06.2009
  • 0 рейтинг

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

    RandomStringUtils.randomAlphanumeric(20).toUpperCase();
    
    ответ дан manish_s, с репутацией 2909, 20.07.2012
  • 0 рейтинг
    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);
        }
    }
    

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

    ответ дан cmpbah, с репутацией 21, 16.04.2012
  • 0 рейтинг

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

    /*
     * 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 - лучший вариант, даже если мы потеряем 4 символа (w-z). Чтобы теперь сгенерировать строку определенной длины, мы можем просто использовать число 2^(length*numBits)-1. Последняя проблема: если нам нужна строка определенной длины, случайное число может сгенерировать небольшое число, поэтому длина не будет достигнута, поэтому мы должны дополнить строку до требуемой длины, добавляя нули.

    ответ дан Kristian Kraljic, с репутацией 674, 3.07.2015
  • 0 рейтинг

    Много использования 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< 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);
    }
    
    ответ дан Jamie, с репутацией 1290, 3.12.2012
  • 0 рейтинг

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

    public static String randString(int length) {
        return UUID.randomUUID().toString().replace("-", "").substring(0, Math.min(length, 32)) + (length > 32 ? randString(length - 32) : "");
    }
    
    ответ дан aaronvargas, с репутацией 6839, 1.03.2018
  • 0 рейтинг

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

    public static String generatePassword(int passwordLength) {
        int asciiFirst = 33;
        int asciiLast = 126;
        Integer[] exceptions = { 34, 39, 96 };
    
        List exceptionsList = Arrays.asList(exceptions);
        SecureRandom random = new SecureRandom();
        StringBuilder builder = new StringBuilder();
        for (int i=0; i
    ответ дан Steven L, с репутацией 13102, 8.12.2014
  • 0 рейтинг

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

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

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

    ответ дан user unknown, с репутацией 28343, 17.04.2012
  • 0 рейтинг
    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
    ответ дан Jameskittu, с репутацией 378, 19.10.2011
  • 0 рейтинг

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

    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();
    
    }
    
    ответ дан Prasobh.K, с репутацией 723, 1.11.2012
  • 0 рейтинг

    Вы можете сделать это трудным путем:

    package gaming;
    
    import java.util.Random;
    
    public class game2 {
    
    public static char c;
    public static Random r = new Random();
    public static int i = r.nextInt(25);
    public static int i2 = r.nextInt(25);
    public static int i3 = r.nextInt(25);
    public static int i4= r.nextInt(25);
    public static int i5 = r.nextInt(25);
    public static int num2 = r.nextInt(9);
    public static int num3= r.nextInt(9);
    public static String s1 = String.valueOf(num2);
    public static String s2 = String.valueOf(num3);
    
    public static void main(String[] args){
    
    
        System.out.print("The pin is: ");
        changeToString(i);
        System.out.print(c);
        changeToString(i2);
        System.out.print(c);
        changeToString(i3);
        System.out.print(c);
        changeToString(i4);
        System.out.print(c);
        changeToString(i5);
        System.out.print(c);
        System.out.print(s1);
        System.out.print(s2);
    
    }
    
    public static void changeToString(int rand){
    
        switch (rand){
    
        case 0:
    
            c = 'A';
            break;
        case 1:
    
            c = 'B';
            break;
        case 2:
    
            c = 'C';
            break;
        case 3:
    
            c = 'D';
            break;
        case 4:
    
            c = 'E';
            break;
        case 5:
    
            c = 'F';
            break;
        case 6:
    
            c = 'G';
            break;
        case 7:
    
            c = 'H';
            break;
        case 8:
    
            c = 'I';
            break;
        case 9:
    
            c = 'J';
            break;
        case 10:
    
            c = 'K';
            break;
        case 11:
    
            c = 'L';
            break;
        case 12:
    
            c = 'M';
            break;
        case 13:
    
            c = 'N';
            break;
        case 14:
    
            c = 'O';
            break;
        case 15:
    
            c = 'P';
            break;
        case 16:
    
            c = 'Q';
            break;
        case 17:
    
            c = 'R';
            break;
        case 18:
    
            c = 'S';
            break;
        case 19:
    
            c = 'T';
            break;
        case 20:
    
            c = 'U';
            break;
        case 21:
    
            c = 'V';
            break;
        case 22:
    
            c = 'W';
            break;
        case 23:
    
            c = 'X';
            break;
        case 24:
    
            c = 'Y';
            break;
        case 25:
    
            c = 'Z';
            break;
    
        }
    
    }
    }
    
    ответ дан user3314952, с репутацией 11, 26.02.2014
  • 0 рейтинг
    public class RandomGenerator {
              private static SecureRandom prng;
              private static final Logger LOG = LoggerFactory
                        .getLogger(AuthTokenGenerator.class);
                static {
                    try {
                        // Initialize SecureRandom
                        prng = SecureRandom.getInstance("SHA1PRNG");
                    } catch (NoSuchAlgorithmException e) {
                        LOG.info("ERROR while intantiating Secure Random:   " + prng);
                }
            }
            /**
             * @return
             */
            public static String getToken() {
                try {
                    LOG.info("About to Generate Token in getToken()");
                    String token;
                    // generate a random number
                    String randomNum = Integer.toString(prng.nextInt());
                    // get its digest
                    MessageDigest sha = MessageDigest.getInstance("SHA-1");
                    byte[] result = sha.digest(randomNum.getBytes());
                    token = hexEncode(result);
                    LOG.info("Token in getToken():   " + token);
                    return token;
                } catch (NoSuchAlgorithmException ex) {
                    return null;
                }
            }
            /**
             * @param aInput
             * @return
             */
            private static String hexEncode(byte[] aInput) {
                StringBuilder result = new StringBuilder();
                char[] digits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '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' };
                for (byte b : aInput) {
                    result.append(digits[(b & 0xf0) >> 4]);
                    result.append(digits[b & 0x0f]);
                }
                return result.toString();
            }
    }
    
    ответ дан Sunil, с репутацией 297, 13.05.2015
  • 0 рейтинг

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

    ответ дан michaelok, с репутацией 935, 9.09.2011
  • 0 рейтинг

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

    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;
        }   
    
    }
    
    ответ дан Bhavik Ambani, с репутацией 5160, 28.04.2012
  • 0 рейтинг
    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;
    }
    
    ответ дан duggu, с репутацией 28305, 24.12.2012
  • 0 рейтинг

    Алгоритм

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

    Реализация

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

    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 9306840 - это число, равное q 9306840 алфавит, а x это длина идентификаторов. Это должно быть очень маленькое число, например, 2 ‑50 или меньше.

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

    Сравнение с UUID

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

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

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

    ответ дан erickson, с репутацией 216101, 3.09.2008
  • 0 рейтинг

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

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

    Легко.

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

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

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

    http: // en. википедия. org / wiki / Universally_unique_identifier # Random_UUID_probability_of_duplicates

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

    ответ дан Michael Allen, с репутацией 3887, 25.10.2012
  • 0 рейтинг

    Вот оно на Яве:

    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
    
    ответ дан Apocalisp, с репутацией 30735, 3.09.2008
  • 0 рейтинг

    с использованием библиотеки apache это можно сделать в одну строку

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

    вот документ http: // commons. апач. орг / языки / API-2. 3 / орг / Apache / Commons / ЯЗ / RandomStringUtils. HTML

    ответ дан hridayesh, с репутацией 625, 15.10.2012
  • 0 рейтинг

    Альтернатива в 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();
    }
    
    ответ дан Howard Lovatt, с репутацией 729, 25.11.2014
  • 0 рейтинг
    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();
        }
    
    ответ дан deepakmodak, с репутацией 1164, 6.02.2014
  • 0 рейтинг

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

    ответ дан cmsherratt, с репутацией 1939, 4.09.2008