Czy istnieje możliwość generowania losowego znaku w Javie?

Aby wygenerować losowy znak w a-z:

Random r = new Random();
char c = (char)(r.nextInt(26) + 'a');

Możesz również użyć Randomstringuls z projektu Apache Commons:

Zależność:

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

Zastosowania:

RandomStringUtils.randomAlphabetic(stringLength);
RandomStringUtils.randomAlphanumeric(stringLength);

private static char rndChar () {
    int rnd = (int) (Math.random() * 52); // or use Random or whatever
    char base = (rnd < 26) ? 'A' : 'a';
    return (char) (base + rnd % 26);

}

Generuje wartości w zakresach a-z, A-Z.

String abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char letter = abc.charAt(rd.nextInt(abc.length()));

W następującej 97 wartości ascii małej "a".

public static char randomSeriesForThreeCharacter() {
Random r = new Random();
char random_3_Char = (char) (97 + r.nextInt(3));
return random_3_Char;
}

W powyższej liczbie 3 dla a, b, c lub d i jeśli chcesz wszystkie znaki jak a do z, to zamieniasz liczbę 3 na 25.

Możesz użyć generatorów z Quickcheck specification-based test framework .

Aby utworzyć losowy ciąg użyj metody anyString .

String x = anyString();

Możesz tworzyć ciągi znaków z bardziej ograniczonego zestawu znaków lub z ograniczeniami o minimalnym/maksymalnym rozmiarze.

Normalnie można uruchamiać testy z wieloma wartościami:

@Test
public void myTest() {
  for (List<Integer> any : someLists(integers())) {
    //A test executed with integer lists
  }
}

Using dollar :

Iterable<Character> chars = $('a', 'z'); // 'a', 'b', c, d .. z

Biorąc pod uwagę chars można zbudować" tasowany " zakres znaków:

Iterable<Character> shuffledChars = $('a', 'z').shuffle();

Następnie pobierając pierwsze znaki n, otrzymujemy losowy ciąg o długości n. Kod końcowy jest po prostu:

public String randomString(int n) {
    return $('a', 'z').shuffle().slice(n).toString();
}

NB: warunek n > 0 jest spełniony przez slice

EDIT

Jak słusznie zauważył Steve, randomString używa co najwyżej jednej litery. Jako obejście możesz powtórzyć alfabet m razy przed wywołaniem shuffle:

public String randomStringWithRepetitions(int n) {
    return $('a', 'z').repeat(10).shuffle().slice(n).toString();
}

Lub po prostu podaj swój alfabet jako String:

public String randomStringFromAlphabet(String alphabet, int n) {
    return $(alphabet).shuffle().slice(n).toString();
}

String s = randomStringFromAlphabet("00001111", 4);

To proste, ale przydatne odkrycie. Definiuje klasę RandomCharacter z 5 przeciążonymi metodami, aby losowo uzyskać określony typ znaków. Możesz użyć tych metod w swoich przyszłych projektach.

    public class RandomCharacter {
    /** Generate a random character between ch1 and ch2 */
    public static char getRandomCharacter(char ch1, char ch2) {
        return (char) (ch1 + Math.random() * (ch2 - ch1 + 1));
    }

    /** Generate a random lowercase letter */
    public static char getRandomLowerCaseLetter() {
        return getRandomCharacter('a', 'z');
    }

    /** Generate a random uppercase letter */
    public static char getRandomUpperCaseLetter() {
        return getRandomCharacter('A', 'Z');
    }

    /** Generate a random digit character */
    public static char getRandomDigitCharacter() {
        return getRandomCharacter('0', '9');
    }

    /** Generate a random character */
    public static char getRandomCharacter() {
        return getRandomCharacter('\u0000', '\uFFFF');
    }
}

Aby zademonstrować jak to działa, przyjrzyjmy się poniższemu programowi testowemu wyświetlającemu 175 losowych małych liter.

public class TestRandomCharacter {
    /** Main method */
    public static void main(String[] args) {
        final int NUMBER_OF_CHARS = 175;
        final int CHARS_PER_LINE = 25;
        // Print random characters between 'a' and 'z', 25 chars per line
        for (int i = 0; i < NUMBER_OF_CHARS; i++) {
            char ch = RandomCharacter.getRandomLowerCaseLetter();
            if ((i + 1) % CHARS_PER_LINE == 0)
                System.out.println(ch);
            else
                System.out.print(ch);
        }
    }
}

A Wyjście To:

Jeśli biegniesz jeszcze raz znowu:

PrzypisujęY. Danielowi Liangowi za jego książkęIntroduction to Java Programming, Comprehensive Version, 10th Edition, w której przytoczyłem tę wiedzę i wykorzystałem ją w moich projektach.

Notatka: Jeśli nie jesteś zaznajomiony z przeciążonymi methodami, w skrócie metoda Overloading jest funkcją, która pozwala klasie mieć więcej niż jedną metodę o tej samej nazwie, jeśli ich listy argumentów są różne.

Spójrz na klasę Java Randomizer . Myślę, że można randomizować znak za pomocą metody randomize (char [] array).

Moja propozycja do generowania losowego ciągu znaków o mieszanej wielkości liter np.: "DthJwMvsTyu" .
Algorytm ten bazuje na kodach liter ASCII, gdy jego kody a-z (97 do 122) i A-Z (65 do 90) różnią się 5-tym bitem (2^5 lub 1

random.nextInt(2): wynik to 0 LUB 1.

random.nextInt(2) << 5: wynik to 0 lub 32.

Górny A to 65, a dolny a to 97. Różnica jest tylko na 5-tym bitu (32), więc do generowania random char robimy binary lub ' / ' random charCaseBit (0 lub 32) i losowy Kod od A do Z (65 do 90).

public String fastestRandomStringWithMixedCase(int length) {
    Random random = new Random();
    final int alphabetLength = 'Z' - 'A' + 1;
    StringBuilder result = new StringBuilder(length);
    while (result.length() < length) {
        final char charCaseBit = (char) (random.nextInt(2) << 5);
        result.append((char) (charCaseBit | ('A' + random.nextInt(alphabetLength))));
    }
    return result.toString();
}

Oto kod do wygenerowania losowego kodu alfanumerycznego. Najpierw musisz zadeklarować ciąg dozwolonych znaków, który chcesz umieścić w losowej liczbie.a także zdefiniować maksymalną długość łańcucha

 SecureRandom secureRandom = new SecureRandom();
 String CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
    StringBuilder generatedString= new StringBuilder();
    for (int i = 0; i < MAXIMUM_LENGTH; i++) {
        int randonSequence = secureRandom .nextInt(CHARACTERS.length());
        generatedString.append(CHARACTERS.charAt(randonSequence));
    }

Użyj metody toString (), aby uzyskać String z StringBuilder

Odpowiedź Polygenelubricants jest również dobrym rozwiązaniem, jeśli chcesz wygenerować tylko wartości szesnastkowe:

/** A list of all valid hexadecimal characters. */
private static char[] HEX_VALUES = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A', 'B', 'C', 'D', 'E', 'F' };

/** Random number generator to be used to create random chars. */
private static Random RANDOM = new SecureRandom();

/**
 * Creates a number of random hexadecimal characters.
 * 
 * @param nValues the amount of characters to generate
 * 
 * @return an array containing <code>nValues</code> hex chars
 */
public static char[] createRandomHexValues(int nValues) {
    char[] ret = new char[nValues];
    for (int i = 0; i < nValues; i++) {
        ret[i] = HEX_VALUES[RANDOM.nextInt(HEX_VALUES.length)];
    }
    return ret;
}

W rzeczywistości wspomniane metody nie generują rzeczywistego losowego znaku. Aby wygenerować prawdziwy losowy znak, powinieneś dać mu losowe ziarno! w przykładowym czasie w milisekundzie. ten kod generuje 10 losowych znaków, a następnie konwertuje je na ciąg znaków:

import java.util.Random;
public class MyClass {
    public static void main() {

     String randomKey;

    char[] tempArray={0,0,0,0,0,0,0,0,0,0};  //ten characters

    long seed=System.currentTimeMillis();
    Random random=new Random(seed);
    for (int aux=0; aux<10;aux++){

        tempArray[aux]=(char) random.nextInt(255);
        System.out.println(tempArray[aux]);
    }

    randomKey=String.copyValueOf(tempArray);  


      System.out.println(randomKey);
    }
}

Używam tego:

char uppercaseChar = (char) ((int)(Math.random()*100)%26+65);

char lowercaseChar = (char) ((int)(Math.random()*1000)%26+97);

java.util.Random jest bardziej skuteczny, jaki wypróbowałem do tej pory, mając precyzję 98.65% wyjątkowość. Podałem poniżej kilka testów, które generują 10000 partii sto 2 znaków alfanumerycznych ciągów i oblicza średnią.

Inne losowe narzędzia były RandomStringUtils z commons.lang3 i java.util.Math.

public static void main(String[] args) {
    int unitPrintMarksTotal = 0;
    for (int i = 0; i < 10000; i++) {
        unitPrintMarksTotal += generateBatchOfUniquePrintMarks(i);
    }

    System.out.println("The precision across 10000 runs with 100 item batches is: " + (float) unitPrintMarksTotal / 10000);
}

private static int generateBatchOfUniquePrintMarks(int batch) {
    Set<String> printMarks = new HashSet<>();
    for (int i = 0; i < 100; i++) {
        printMarks.add(generatePrintMarkWithJavaUtil());
    }

    System.out.println("Batch " + batch + " Unique number of elements is " + printMarks.size());

    return printMarks.size();
}

// the best so far => 98.65
// with 3 chars => 99.98
// with 4 chars => 99.9997
private static String generatePrintMarkWithJavaUtil() {
    int leftLimit = 48; // numeral '0'
    int rightLimit = 122; // letter 'z'
    int targetStringLength = 2;
    String printMark;
    do {
        printMark = new Random().ints(leftLimit, rightLimit + 1)
                .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
                .limit(targetStringLength)
                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
                .toString();
    } while (!isValid(printMark));

    return printMark;
}

// 95.46
private static String generatePrintMarkWithCommonsLang3() {
    String printMark;
    do {
        printMark = RandomStringUtils.randomAlphanumeric(2).toUpperCase();
    } while (!isValid(printMark));

    return printMark;
}

// 95.92
private static String generatePrintMarkWithMathRandom() {
    final String ALPHA_NUMERIC_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    StringBuilder printMark;
    do {
        printMark = new StringBuilder();
        int i = (int) (Math.random() * ALPHA_NUMERIC_STRING.length());
        printMark.append(ALPHA_NUMERIC_STRING.charAt(i));
        int j = (int) (Math.random() * ALPHA_NUMERIC_STRING.length());
        printMark.append(ALPHA_NUMERIC_STRING.charAt(j));
    } while (!isValid(printMark.toString()));

    return printMark.toString();
}

private static boolean isValid(final String printMark) {
    return true;
}

Jeśli nie masz nic przeciwko dodaniu nowej biblioteki do kodu, możesz wygenerować znaki za pomocą MockNeat (zastrzeżenie: jestem jednym z autorów).

MockNeat mock = MockNeat.threadLocal();

Character chr = mock.chars().val();
Character lowerLetter = mock.chars().lowerLetters().val();
Character upperLetter = mock.chars().upperLetters().val();
Character digit = mock.chars().digits().val();
Character hex = mock.chars().hex().val(); 

public static void  main(String[] args) {

  //  System.out.println("Enter a number to changeit at char  ");
    Random random = new Random();

    int x = random.nextInt(26)+65;    //0  to 25
    System.out.println((char)x);
}

   Random randomGenerator = new Random();

   int i = randomGenerator.nextInt(256);
   System.out.println((char)i);

Powinieneś zadbać o to, co chcesz, zakładając, że rozważasz '0,'1','2'.. jako postacie.