Java 中的 java.util.Random 和递归

Question

首先我想说这是一个比较笼统的问题；与我给出的具体示例无关，而只是一个概念性主题。

示例 #1： 我正在使用 UUID.java 创建一个真正的随机字符串。假设我永远不想生成相同的 UUID。这里有一个想法： （假设我在顶部保存/加载列表 - 这不是重点）

Gist URL (I'm new to StackExchange- sorry!)

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class Example {

    /**
     * A final List<String> of all previous UUIDs generated with
     * generateUniqueID(), turned into a string with uuid.toString();
     */
    private static final List<String> PREVIOUS = new ArrayList<String>();

    /**
     * Generates a truly unique UUID.
     * 
     * @param previous
     *            A List<String> of previous UUIDs, converted into a string with
     *            uuid.toString();
     * @return a UUID generated with UUID.randomUUID(); that is not included in
     *         the given List<String>.
     */
    public static UUID generateUniqueID(List<String> previous) {
        UUID u = UUID.randomUUID();
        if (previous.contains(u.toString())) {
            return generateUniqueID(previous);
        }
        return u;
    }

    /**
     * Generates a truly unique UUID using the final List<String> PREVIOUS
     * variable defined at the top of the class.
     * 
     * @return A truly random UUID created with generateUniqueID(List<String>
     *         previous);
     */
    public static UUID generateUniqueID() {
        UUID u = generateUniqueID(PREVIOUS);
        PREVIOUS.add(u.toString());
        return u;
    }

}

示例 #2：好吧，也许 UUID 是一个不好的示例，所以让我们使用 Random 和 double。这是另一个例子：

Gist URL

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Example2 {

    /**
     * A final List<Double> of all previous double generated with
     * generateUniqueDouble(), turned into a string with Double.valueOf(d);
     */
    private static final List<Double> PREVIOUS = new ArrayList<Double>();

    /**
     * The RANDOM variable used in the class.
     */
    private static final Random RANDOM = new Random();

    /**
     * Generates a truly unique double.
     * 
     * @param previous
     *            A List<Double> of previous doubles, converted into a Double
     *            with Double.valueOf(d);
     * @return a UUID generated with UUID.randomUUID(); that is not included in
     *         the given List<Double>.
     */
    public static double generateUniqueDouble(List<Double> previous) {
        double d = RANDOM.nextDouble();
        if (previous.contains(Double.valueOf(d))) {
            return generateUniqueDouble(previous);
        }
        return d;
    }

    /**
     * Generates a truly unique double using the final List<Double> PREVIOUS
     * variable defined at the top of the class.
     * 
     * @return A truly random double created with generateUnique(List<Double>
     *         previous);
     */
    public static double generateUnique() {
        double d = RANDOM.nextDouble();
        PREVIOUS.add(Double.valueOf(d));
        return d;
    }

}

要点：这是做这种事情的最有效方法吗？请记住，我给了你一些例子，所以它们很模糊。最好我不想为此使用任何库，但如果它们确实在效率上有很大差异，请告诉我。

请在回复中告诉我你的想法：)

Answer 1

我建议您将生成的 ID 设为序列号，而不是双精度数或 uuid。如果您希望它们在最终用户看来是随机的，请在 base64 中显示数字的 sha1。

Answer 2

在 cmets 中已经讨论了一些要点。在这里总结和阐述它们：

您不太可能两次创建相同的double 值。 There are roughly 7*10¹² different double values（假设随机数生成器可以提供“大部分”）。对于 UUID，两次创建相同值的机会甚至更低，因为 there are 2¹²² different UUIDs。如果您创建了足够多的元素以产生不可忽略的碰撞机会，那么无论如何您都会耗尽内存。

所以这种方法在实践中没有意义。

---

但是，从纯理论的角度来看：

性能

在此操作中使用List 不是最佳选择。对您而言，“最佳情况”（也是迄今为止最常见的情况）是新元素不包含在列表中。但是为了检查元素是否被包含，这是最坏的情况：你必须检查列表中的每一个元素，只是为了检测到新元素还没有出现。据说这是线性的complexity，或简称为O(n)。您可以使用不同的数据结构来更快地检查是否包含元素，即在 O(1) 中。例如，您可以替换该行

private static final List<Double> PREVIOUS = new ArrayList<Double>();

与

private static final Set<Double> PREVIOUS = new HashSet<Double>();

---

性能和正确性

（这里一般指递归方式）

性能

从性能的角度来看，当递归很容易被迭代解决方案替换时，您不应该使用递归。在这种情况下，这将是微不足道的：

public static double generateUniqueDouble(List<Double> previous) {
    double d = RANDOM.nextDouble();
    while (previous.contains(d)) {
        d = RANDOM.nextDouble();
    }
    PREVIOUS.add(d);
    return d;
}

（它可以写得更紧凑一点，但现在没关系）。

正确性

这更微妙：当有很多递归调用时，你可能会得到一个StackOverflowError。所以你应该从不使用递归除非你可以证明递归会结束（或者更好：它会在“几步之后”结束)。

但这是你的主要问题：

算法有缺陷。您无法证明它能够创建新的随机数。对于double（或UUID）值，即使是单个新元素已经包含在PREVIOUS 元素集合中的可能性也非常低。但它不是零。没有什么可以阻止随机数生成器连续数万亿次无限期地创建随机数0.5。

---

（再次：这些纯粹是理论上的考虑。但与实践相距不远，因为它们乍一看：如果您没有创建随机的double 值，而是随机的byte 值，那么，在 256 之后调用，将不会返回“新”值 - 您实际上会收到 StackOverflowError...)

Answer 3

使用哈希表比使用列表更好。生成您的候选值，检查哈希表中的冲突，如果没有冲突则接受它。如果使用列表，则生成新值是 O(n) 操作。如果使用哈希表，生成新值是O(1) 操作。