랜덤 영숫자 문자열 생성 방법
나는 의사 난수 영숫자 문자열을 생성하기 위한 간단한 자바 알고리즘을 찾고 있었다.제 상황에서는 이 ID가 고유한 세션/키 ID로 사용되며, 이 ID는 "아마도" 고유할 것입니다.500K+세대(제 욕구는 사실 더 정교한 것은 필요 없습니다).
이상적으로는 나만의 요구에 따라 길이를 지정할 수 있습니다.되면 12의 문자열로 수 ."AEYGF7K0DM1X"
알고리즘.
임의의 문자열을 생성하려면 문자열이 원하는 길이에 도달할 때까지 허용 가능한 기호 집합에서 무작위로 그려진 문자를 연결합니다.
실행
다음은 랜덤 식별자를 생성하기 위한 매우 간단하고 유연한 코드입니다.응용 프로그램의 중요한 노트에 대해서는, 다음의 정보를 참조해 주세요.
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는 약2 n/(2qx)입니다.여기서 n은 실제로 생성된 식별자의 수, q는 알파벳 내의 구별되는 기호의 수, x는 식별자의 길이입니다.이것은 2 이하와 같이‑50 매우 작은 숫자여야 합니다.
이를 통해 50만 개의 15자 식별자 중 충돌 확률은‑52 약 2로, 우주선에서 검출되지 않은 오차보다 낮은 것으로 나타났다.
UUID와의 비교
이들 사양에 따르면 UUID는 예측할 수 없도록 설계되어 있지 않으며 세션 ID로 사용할 수 없습니다.
표준 포맷의 UUID는 많은 공간을 차지합니다.12비트 엔트로피의 경우 36글자입니다.('랜덤' UUID의 모든 비트가 랜덤으로 선택되는 것은 아닙니다).랜덤으로 선택한 영숫자 문자열은 단 21자로 엔트로피를 더 많이 채웁니다.
UUID는 유연하지 않습니다.UUID는 표준화된 구조와 레이아웃을 갖추고 있습니다.이것이 그들의 주요 장점이자 약점이다.외부 파티와 협업하는 경우 UUID에서 제공하는 표준화가 도움이 될 수 있습니다.순수하게 내부에서 사용하는 경우에는 비효율적일 수 있습니다.
Java java java java java java java java java java java java java java java java java java java 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();
}
Apache 클래스를 사용하려면 (Apache Commons Text)를 사용할 수 있습니다.
예:
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을 사용하다
Apache Commons 라이브러리를 사용하여 다음을 수행할 수 있습니다.
RandomStringUtils.randomAlphanumeric(20).toUpperCase();
한 줄:
Long.toHexString(Double.doubleToLongBits(Math.random()));
이것은 외부 라이브러리 없이도 쉽게 달성할 수 있습니다.
1. 암호화 의사 랜덤 데이터 생성(PRNG)
먼저 암호화 PRNG가 필요합니다. Java는 암호화 PRNG를 가지고 있으며 일반적으로 기계에서 최고의 엔트로피 소스(예:/dev/random자세한 것은 이쪽을 참조해 주세요.
SecureRandom rnd = new SecureRandom();
byte[] token = new byte[byteLength];
rnd.nextBytes(token);
SecureRandom는 Java에서 랜덤바이트를 생성하는 가장 느리지만 안전한 방법입니다.단, 초당 수백만 개의 토큰을 생성해야 하는 경우를 제외하고는 일반적으로 애플리케이션에 실질적인 영향을 미치지 않으므로 여기서는 성능을 고려하지 않는 것이 좋습니다.
2. 가능한 가치의 필요 공간
다음으로 토큰이 얼마나 고유해야 하는지 결정해야 합니다.엔트로피를 고려하는 유일한 요점은 시스템이 무차별적인 공격에도 견딜 수 있도록 하는 것입니다.가능한 값의 공간은 공격자가 무차별적인1 시간 내에 값의 극히 일부만 시도할 수 있도록 매우 커야 합니다.
랜덤과 같은 고유 식별자는 122비트 엔트로피(즉, 2^160 = 5.3x10^36)를 가진다. 충돌 확률은 "*(...)"이며, 103조 버전 4 UUID가 생성되어야2 한다.128비트는 16바이트에 정확히 맞으며 기본적으로 모든 사용 사례에 대해 고유하다고 간주되기 때문에 중복을 고려할 필요가 없습니다.생일 문제의 간단한 분석을 포함한 엔트로피의 간단한 비교표입니다.
단순한 요건의 경우 8바이트 또는 12바이트 길이로 충분할 수 있지만 16바이트의 경우 "안전한 편"입니다.
은 , 읽기, 쓰기, 쓰기, 쓰기)로될 수 있도록 이 마지막입니다.인쇄 가능한 텍스트(읽기, 읽기)로 나타낼 수 있습니다.String를 참조해 주세요.
3. 바이너리-텍스트 부호화
일반적인 인코딩은 다음과 같습니다.
Base64모든 문자가 6비트를 인코딩하여 33%의 오버헤드를 생성합니다.다행히 Java 8+와 Android에는 표준 구현이 있습니다.오래된 Java에서는 다양한 서드파티 라이브러리를 사용할 수 있습니다.토큰을 URL로 보호하려면 URL로 보호되는 버전의 RFC4648을 사용합니다(일반적으로 대부분의 구현에서 지원됩니다).패딩을 사용한16 바이트 부호화의 예:XfJhfv3C0P6ag7y9VQxSbw==Base32모든 문자가 5비트를 인코딩하여 40%의 오버헤드를 생성합니다.이 방법은A-Z★★★★★★★★★★★★★★★★★」2-7따라서 대소문자를 구분하지 않고 공간을 효율적으로 사용할 수 있습니다.JDK에는 표준 구현이 없습니다. 패딩 없이 16바이트 인코딩 예제:WUPIL5DQTZGMF4D3NX5L7LNFOYBase16(소수) 각 문자는 4비트를 부호화하며 바이트당 2문자가 필요합니다(즉, 16바이트는 길이 32의 문자열을 만듭니다).따라서 16진수는 다음보다 공간 효율이 낮습니다.Base32, URL에서는 「」, 「URL()」만을 사용하고 있기 때문에, 사용하는 것이 안전합니다.0-9★★★★★★★★★★★★★★★★★」A로로 합니다.F예: . 16 바이트:4fa3dd0f57cb3bf331441ed285b27735. 16진수로의 변환에 대해서는, 「스택 오버플로」의 설명을 참조해 주세요.
Base85 및 이국적인 Base122와 같은 추가 인코딩은 공간 효율이 좋거나 나쁘거나 합니다.독자적으로 인코딩을 작성할 수 있지만(이 스레드에서는 기본적으로 대부분의 답변이 해당) 특별한 요건이 없다면 사용하지 않는 것이 좋습니다.Wikipedia 문서에서 더 많은 인코딩 체계를 참조하십시오.
4. 개요와 예시
- 사용
- 가능한 값의 최소 16바이트(2^128)를 사용합니다.
- 한다(통상은 「」( 「」)
hex★★★★★★★★★★★★★★★★★」base32★★★★★★★★★★★★★★★★」
하지 마
- ...홈브루 인코딩 사용: 한 번에 문자를 생성하는 루프에 이상한 인코딩을 사용하는 것이 아니라 사용자가 사용하는 표준 인코딩을 확인할 경우 유지보수가 용이하고 읽기 쉬운 인코딩을 사용합니다.
- ... UUID 사용: 랜덤성을 보장하지 않습니다. 6비트의 엔트로피를 낭비하고 있으며 자세한 문자열이 표시됩니다.
예:16진수 토큰 생성기
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 도구
즉시 사용할 수 있는 CLI 도구가 필요한 경우 다음과 같이 주사위를 사용할 수 있습니다.
예: 관련 문제 - 현재 ID 보호
수 있는 들어 ID)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);
달러 사용은 다음과 같이 단순해야 합니다.
// "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 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);
사이즈는 Base 36에서 12자리 정도이므로 더 이상 개선할 수 없습니다.물론 여러 인스턴스를 추가할 수 있습니다.
놀랍게도 아무도 제안하지 않았습니다만, 하지만
import java.util.UUID
UUID.randomUUID().toString();
만만하다.
이 방법의 장점은 UUID가 적절하고 길며 충돌하는 일이 거의 없다는 것입니다.
Wikipedia는 이에 대해 잘 설명하고 있습니다.
"...앞으로 100년 동안 초당 10억 개의 UUID를 생성한 후에만 중복 항목이 하나 생성될 확률은 약 50%가 될 것입니다."
처음 4비트는 버전타입이고 2비트는 바리안트용이므로 랜덤으로 122비트를 얻을 수 있습니다.따라서 원하는 경우 끝에서 잘라 UUID 크기를 줄일 수 있습니다.권장되지는 않지만, 50만 개의 레코드가 쉽게 기록될 만큼 랜덤성이 풍부합니다.
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 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;
}
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());
}
}
이렇게 하면 문자열에 암호가 추가되고...네, 잘 작동해요이것 좀 봐...그것은 매우 간단하다; 내가 그것을 썼다.
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인 랜덤 문자열의 단순한 경우를 가정해 보겠습니다.즉, 랜덤 문자가 1개라고 합니다. 0 ~9 와 문자 a ~를 하려면 , 0 ~1 취득하려면 , 0 ~9 의 임의의 숫자가 필요합니다.a ~z 。 , 1 ~ 35 。
BigInteger는 임의의 컨스트럭터를 제공합니다. 「난수」의 하고 있습니다.0 to (2^numBits - 1)는 35 、 2 ^numBits - 1 。
두 이 있어요. go either2^5-1=31 ★★★★★★★★★★★★★★★★★」2^6-1=63만약 우리가 선택한다면2^6 될 이다.'보통' / '보통' 숫자가 많을 거예요그러므로2^54자(w-z)입니다. 해서한 길이의 '일부러'를하면 됩니다.2^(length*numBits)-1작은 수 있기 않기 에 제로를붙여야 .마지막 문제는 특정 길이의 스트링을 필요로 하는 경우 랜덤으로 작은 숫자가 생성될 수 있기 때문에 길이가 충족되지 않기 때문에 스트링을 필요한 길이의 선두에 제로를 붙여야 합니다.
랜덤 16진 부호화 문자열을 생성하는 솔루션을 찾았습니다.제공된 장치 테스트가 주요 사용 사례에 부합하는 것 같습니다.단, 이는 제공된 다른 답변보다 약간 더 복잡합니다.
/**
* 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);
}
}
}
요건에 따라 String 문자를 변경합니다.
문자열은 불변입니다.서 ★★★★
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.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;
}
}
간단한 솔루션에 관한 다음 답변은 마음에 들지 않습니다.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("-", "")
Apache Commons의 라이브러리를 사용하여 영숫자 문자열을 생성합니다.
import org.apache.commons.lang3.RandomStringUtils;
String keyLength = 20;
RandomStringUtils.randomAlphanumeric(keylength);
빠르고 간단해!
'심플'을 언급하고 있습니다만, 보다 엄격한 시큐러티 요건을 만족시키는 것을 찾고 있는 유저가 있는 경우는, jpwgen을 참조해 주세요.jpwgen은 Unix의 pwgen을 본떠 설계되어 있어 설정이 매우 용이합니다.
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);
}
}
}
패스워드에 숫자와 영문자의 특수문자가 포함되어 있는 경우는, 다음의 코드를 사용할 수 있습니다.
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();
}
getLestSignificantBits() 메시지와 함께 UUID 클래스를 사용하여 64비트의 랜덤 데이터를 얻은 후 기수 36 번호(0-9, A-Z로 구성된 문자열)로 변환할 수 있습니다.
Long.toString(Math.abs( UUID.randomUUID().getLeastSignificantBits(), 36));
그러면 최대 13자의 문자열이 생성됩니다.Math.abs()를 사용하여 마이너스 부호가 몰래 들어오지 않도록 합니다.
다음은 Abacus Util의 원라이너입니다.
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 '-'
Scala 솔루션은 다음과 같습니다.
(for (i <- 0 until rnd.nextInt(64)) yield {
('0' + rnd.nextInt(64)).asInstanceOf[Char]
}) mkString("")
Apache Commons 라이브러리를 사용하면 다음 한 줄로 작업을 수행할 수 있습니다.
import org.apache.commons.lang.RandomStringUtils;
RandomStringUtils.randomAlphanumeric(64);
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;
}
저는 이것이 여기서 가장 작은 솔루션 또는 가장 작은 솔루션 중 하나라고 생각합니다.
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초 걸렸어요.
public static String getRandomString(int length)
{
String randomStr = UUID.randomUUID().toString();
while(randomStr.length() < length) {
randomStr += UUID.randomUUID().toString();
}
return randomStr.substring(0, length);
}
언급URL : https://stackoverflow.com/questions/41107/how-to-generate-a-random-alpha-numeric-string
'programing' 카테고리의 다른 글
| 포인터 주소와 포인터 값을 증가시키는 방법 (0) | 2022.08.27 |
|---|---|
| Vuex Getters 메서드 스타일 함수 반환 방법 (0) | 2022.08.27 |
| Vue2 - 오류: CSS 문자열 대신 PostCSS가 정의되지 않았습니다. (0) | 2022.08.27 |
| [Vue warn] :알 수 없는 사용자 지정 요소: ..." vuetify UI 구성 요소를 vue-cli-plugin-vuetify와 함께 사용하는 경우 오류 발생 (0) | 2022.08.27 |
| vue + Typescript 클래스 구성 요소와 mapActions를 사용하는 방법 (0) | 2022.08.27 |