1. Introduction

1.绪论

In this tutorial, we’re going to learn how to generate a random string in Java, first using the standard Java libraries, then using a Java 8 variant, and finally using the Apache Commons Lang library.

在本教程中，我们将学习如何在Java中生成一个随机字符串，首先使用标准的Java库，然后使用Java 8的变体，最后使用Apache Commons Lang库。

This article is part of the “Java – Back to Basic” series here on Baeldung.

这篇文章是Baeldung网站上“Java–回到基础 “系列的一部分。

2. Generate Random Unbounded String With Plain Java

2.用普通的Java生成随机的无边界字符串

Let’s start simple and generate a random String bounded to 7 characters:

让我们从简单的开始，生成一个随机的String，限定为7个字符。

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

Keep in mind that the new string will not be anything remotely alphanumeric.

请记住，新的字符串将不会是任何遥远的字母数字。

3. Generate Random Bounded String With Plain Java

3.用普通的Java生成随机的有边界的字符串

Next let’s look at creating a more constrained random string; we’re going to generate a random String using lowercase alphabetic letters and a set length:

接下来让我们看看如何创建一个更有约束的随机字符串；我们将使用小写字母和设定的长度来生成一个随机String。

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

4. Generate Random Alphabetic String With Java 8

4.用Java 8生成随机字母串

Now let’s use Random.ints, added in JDK 8, to generate an alphabetic String:

现在让我们使用JDK 8中添加的Random.ints，来生成一个按字母排列的String：。

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

5. Generate Random Alphanumeric String With Java 8

5.用Java 8生成随机字母数字字符串

Then we can widen our character set in order to get an alphanumeric String:

然后我们可以扩大我们的字符集，以便得到一个字母数字的字符串：。

@Test
public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() {
    int leftLimit = 48; // numeral '0'
    int rightLimit = 122; // letter 'z'
    int targetStringLength = 10;
    Random random = new Random();

    String generatedString = 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();

    System.out.println(generatedString);
}

We used the filter method above to leave out Unicode characters between 65 and 90 in order to avoid out of range characters.

我们使用上面的filter方法，省去了65和90之间的Unicode字符，以避免超出范围的字符。

6. Generate Bounded Random String With Apache Commons Lang

6.用Apache Commons Lang生成有边界的随机字符串

The Commons Lang library from Apache helps a lot with random string generation. Let’s take a look at generating a bounded String using only letters:

Apache的Commons Lang库对随机字符串的生成有很大帮助。让我们来看看只用字母生成一个有界的String。

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

So instead of all the low-level code in the Java example, this one is done with a simple one-liner.

因此，这个例子没有Java例子中的所有低级代码，而是用一个简单的单行代码完成。

7. Generate Alphabetic String With Apache Commons Lang

7.用Apache Commons Lang生成字母字符串

Here is another very simple example, this time a bounded String with only alphabetic characters, but without passing boolean flags into the API:

这里是另一个非常简单的例子，这次是一个有界的String，只有字母字符，但没有向API传递布尔标志。

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

    System.out.println(generatedString);
}

8. Generate Alphanumeric String With Apache Commons Lang

8.用Apache Commons Lang生成字母数字字符串

Finally, we have the same random bounded String, but this time numeric:

最后，我们有同样的随机有界String,，但这次是数字的。

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

    System.out.println(generatedString);
}

And there we have it, creating bounded and unbounded strings with either plain Java, a Java 8 variant, or the Apache Commons Library.

就这样，用普通Java、Java 8变体或Apache Commons Library创建有界和无界的字符串。

9. Conclusion

9.结语

Through different implementation methods, we were able to generate bound and unbound strings using plain Java, a Java 8 variant, or the Apache Commons Library.

通过不同的实现方法，我们能够使用普通Java、Java 8变体或Apache Commons Library生成绑定和非绑定字符串。

In these Java examples, we used java.util.Random, but one point worth mentioning is that it is not cryptographically secure. Consider using java.security.SecureRandom instead for security-sensitive applications.

在这些Java例子中，我们使用了java.util.Random，但有一点值得一提的是，它在密码学上是不安全的。对于安全敏感的应用程序，请考虑使用java.security.SecureRandom，而不是。

The implementation of all of these examples and snippets can be found in the GitHub project. This is a Maven-based project so it should be easy to import and run.

所有这些例子和片段的实现都可以在GitHub项目中找到。这是一个基于Maven的项目，所以它应该很容易导入和运行。