在 Kotlin 中生成随机字母数字字符串的惯用方法

Question

我可以生成一定范围内的随机数字序列，如下所示：

fun ClosedRange<Int>.random() = Random().nextInt(endInclusive - start) +  start
fun generateRandomNumberList(len: Int, low: Int = 0, high: Int = 255): List<Int> {
  (0..len-1).map {
    (low..high).random()
  }.toList()
}

那么我将不得不扩展List：

fun List<Char>.random() = this[Random().nextInt(this.size)]

那我可以做：

fun generateRandomString(len: Int = 15): String{
  val alphanumerics = CharArray(26) { it -> (it + 97).toChar() }.toSet()
      .union(CharArray(9) { it -> (it + 48).toChar() }.toSet())
  return (0..len-1).map {
      alphanumerics.toList().random()
  }.joinToString("")
}

但也许有更好的方法？

Answer 1

这是它的加密安全版本，或者我相信：

fun randomString(len: Int): String {
    val random = SecureRandom()
    val chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".toCharArray()
    return (1..len).map { chars[random.nextInt(chars.size)] }.joinToString("")
}

Answer 2

您可以使用 apache-commons-lang3

中的RandomStringUtils.randomAlphanumeric(min: Int, max: Int) -> String

Answer 3

这个问题已经很老了，但我认为另一个很好的解决方案（应该从 Kotlin 1.3 开始工作）如下：

// Just a simpler way to create a List of characters, as seen in other answers
// You can achieve the same effect by declaring it as a String "ABCDEFG...56789"
val alphanumeric = ('A'..'Z') + ('a'..'z') + ('0'..'9')

fun generateAlphanumericString(length: Int) : String {
    // The buildString function will create a StringBuilder
    return buildString {
        // We will repeat length times and will append a random character each time
        // This roughly matches how you would do it in plain Java
        repeat(length) { append(alphanumeric.random()) }
    }
}

Answer 4

从 Kotlin 1.3 开始，您可以这样做：

fun getRandomString(length: Int) : String {
    val allowedChars = ('A'..'Z') + ('a'..'z') + ('0'..'9')
    return (1..length)
        .map { allowedChars.random() }
        .joinToString("")
}

Answer 5

我使用以下代码生成随机单词和句子。

val alphabet: List<Char> = ('a'..'z') + ('A'..'Z') + ('0'..'9')

val randomWord: String = List((1..10).random()) { alphabet.random() }.joinToString("")

val randomSentence: String = (1..(1..10).random()).joinToString(" ") { List((1..10).random()) { alphabet.random() }.joinToString("") }

Answer 6

为定义长度定义它：

val randomString = UUID.randomUUID().toString().substring(0,15)

其中15 是字符数

Answer 7

没有JDK8：

fun ClosedRange<Char>.randomString(length: Int) = 
    (1..length)
        .map { (Random().nextInt(endInclusive.toInt() - start.toInt()) + start.toInt()).toChar() }
        .joinToString("")

用法：

('a'..'z').randomString(6)

Answer 8

使用 Kotlin 1.3 中的 Collection.random()：

// Descriptive alphabet using three CharRange objects, concatenated
val alphabet: List<Char> = ('a'..'z') + ('A'..'Z') + ('0'..'9')

// Build list from 20 random samples from the alphabet,
// and convert it to a string using "" as element separator
val randomString: String = List(20) { alphabet.random() }.joinToString("")

Answer 9

fun randomAlphaNumericString(@IntRange(from = 1, to = 62) lenght: Int): String {
    val alphaNumeric = ('a'..'z') + ('A'..'Z') + ('0'..'9')
    return alphaNumeric.shuffled().take(lenght).joinToString("")
}

Answer 10

假设您有一组特定的源字符（此 sn-p 中的source），您可以这样做：

val source = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
java.util.Random().ints(outputStrLength, 0, source.length)
        .asSequence()
        .map(source::get)
        .joinToString("")

对于 outputStrLength = 10，它会给出类似“LYANFGNPNI”的字符串。

两个重要的位是

1. Random().ints(length, minValue, maxValue) 生成 length 个随机数流，每个随机数从 minValue 到 maxValue-1，以及
2. asSequence() 将不是大量有用的 IntStream 转换为更有用的 Sequence<Int>。

Answer 11

使用 Kotlin 1.3：

此方法使用所需字符串长度desiredStrLength 的输入作为整数，并返回所需字符串长度的随机字母数字字符串。

fun randomAlphaNumericString(desiredStrLength: Int): String {
    val charPool: List<Char> = ('a'..'z') + ('A'..'Z') + ('0'..'9')

    return (1..desiredStrLength)
        .map{ kotlin.random.Random.nextInt(0, charPool.size) }
        .map(charPool::get)
        .joinToString("")
}

如果您更喜欢未知长度的字母数字（或至少像下面我的示例中的 36 那样的相当长的字符串长度），可以使用此方法：

fun randomAlphanumericString(): String {
    val charPool: List<Char> = ('a'..'z') + ('A'..'Z') + ('0'..'9')
    val outputStrLength = (1..36).shuffled().first()

    return (1..outputStrLength)
        .map{ kotlin.random.Random.nextInt(0, charPool.size) }
        .map(charPool::get)
        .joinToString("")
}

Answer 12

根据 Paul Hicks 的答案，我想要一个自定义字符串作为输入。在我的情况下，大写和小写字母数字字符。 Random().ints(...) 也不适用于我，因为它需要 Android 上的 API 级别 24 才能使用它。

这就是我使用 Kotlin 的 Random 抽象类的方式：

import kotlin.random.Random

object IdHelper {

    private val ALPHA_NUMERIC = ('0'..'9') + ('A'..'Z') + ('a'..'z')
    private const val LENGTH = 20

    fun generateId(): String {
        return List(LENGTH) { Random.nextInt(0, ALPHA_NUMERIC.size) }
                .map { ALPHA_NUMERIC[it] }
                .joinToString(separator = "")
    }
}

该过程及其工作原理与此处已发布的许多其他答案相似：

1. 生成与源字符串的索引值相对应的长度为LENGTH 的数字列表，在本例中为ALPHA_NUMERIC
2. 将这些数字映射到源字符串，将每个数字索引转换为字符值
3. 将生成的字符列表转换为字符串，用空字符串作为分隔符将它们连接起来。
4. 返回结果字符串。

使用简单，像静态函数一样调用即可：IdHelper.generateId()

Answer 13

我认为最好的方式：

fun generateID(size: Int): String {
    val source = "A1BCDEF4G0H8IJKLM7NOPQ3RST9UVWX52YZab1cd60ef2ghij3klmn49opq5rst6uvw7xyz8"
    return (source).map { it }.shuffled().subList(0, size).joinToString("")
}

Answer 14

('A'..'z').map { it }.shuffled().subList(0, 4).joinToString("")

Answer 15

懒惰的人会这样做

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

这里不能限制字符范围，但我想在很多情况下还是可以的。

Answer 16

或者使用协程 API 来实现真正的 Kotlin 精神：

buildSequence { val r = Random(); while(true) yield(r.nextInt(24)) }
   .take(10)
   .map{(it+ 65).toChar()}
   .joinToString("")