Java - Generera slumpmässig sträng

I denna handledning kommer vi att visa hur man genererar en slumpmässig sträng i Java - först med hjälp av standard Java-bibliotek, sedan med en Java 8-variant och slutligen med hjälp av Apache Commons Lang-biblioteket.

Den här artikeln är en del av "Java - Back to Basic" -serien här på Baeldung.

1. Skapa slumpmässig obegränsad sträng med vanlig Java

Låt oss börja enkelt och generera en slumpmässig sträng avgränsad till 7 tecken:

@Test public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() { byte[] array = new byte[7]; // length is bounded by 7 new Random().nextBytes(array); String generatedString = new String(array, Charset.forName("UTF-8")); System.out.println(generatedString); }

Tänk på att den nya strängen inte kommer att vara något alfanumeriskt.

2. Skapa slumpmässig avgränsad sträng med vanlig Java

Nästa - låt oss titta på att skapa en mer begränsad slumpmässig sträng; vi kommer att generera en slumpmässig sträng med små bokstäver och en uppsatt längd:

@Test public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() { int leftLimit = 97; // letter 'a' int rightLimit = 122; // letter 'z' int targetStringLength = 10; Random random = new Random(); StringBuilder buffer = new StringBuilder(targetStringLength); for (int i = 0; i < targetStringLength; i++) { int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1)); buffer.append((char) randomLimitedInt); } String generatedString = buffer.toString(); System.out.println(generatedString); }

3. Skapa slumpmässiga alfabetiska strängar med Java 8

Låt oss nu använda Random.ints - läggs till i JDK 8 - för att generera en alfabetisk sträng:

@Test public void givenUsingJava8_whenGeneratingRandomAlphabeticString_thenCorrect() { int leftLimit = 97; // letter 'a' int rightLimit = 122; // letter 'z' int targetStringLength = 10; Random random = new Random(); String generatedString = random.ints(leftLimit, rightLimit + 1) .limit(targetStringLength) .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append) .toString(); System.out.println(generatedString); }

4. Skapa slumpmässiga alfanumeriska strängar med Java 8

Och sedan kan vi bredda vår karaktärsuppsättning för att få en alfanumerisk sträng:

@Test public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() 

Lägg märke till användningen av filtermetoden ovan för att utelämna Unicode-tecken mellan 65 och 90 - för att undvika tecken utanför räckhåll.

5. Generera avgränsad slumpmässig sträng med Apache Commons Lang

Commons Lang-biblioteket från Apache hjälper mycket med slumpmässig stränggenerering. Låt oss ta en titt på att generera en begränsad sträng med endast bokstäver :

@Test public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() { int length = 10; boolean useLetters = true; boolean useNumbers = false; String generatedString = RandomStringUtils.random(length, useLetters, useNumbers); System.out.println(generatedString); }

Så - i stället för all lågnivåkod i Java-exemplet - görs den här med en enkel enlinje.

6. Generera alfabetisk sträng med Apache Commons Lang

Ett annat väldigt enkelt exempel - den här gången en begränsad sträng med endast alfabetiska tecken, men utan att booleska flaggor överförs till API: et:

@Test public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() { String generatedString = RandomStringUtils.randomAlphabetic(10); System.out.println(generatedString); }

7. Generera alfanumeriska strängar med Apache Commons Lang

Och slutligen - samma slumpmässiga begränsade sträng men den här gången - numerisk:

@Test public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() { String generatedString = RandomStringUtils.randomAlphanumeric(10); System.out.println(generatedString); }

Och där har vi det - skapa avgränsade och obegränsade strängar med antingen vanlig Java, en Java 8-variant eller Apache Commons Library.

8. Slutsats

Genom olika implementeringsmetoder kunde vi generera bundna och obundna strängar med vanlig Java, en Java 8-variant eller Apache Commons Library.

I dessa Java-exempel har vi använt java.util.Random , men en punkt som är värt att nämna är att den inte är kryptografiskt säker. Överväg att använda java.security.SecureRandom istället för säkerhetskänsliga applikationer.

Implementeringen av alla dessa exempel och utdrag finns i GitHub-projektet. Detta är ett Maven-baserat projekt så det ska vara enkelt att importera och köra.