在Java文档中，当为Random类指定种子值时，这是一个有意的特性。

如果使用同一种子创建了两个“随机”实例对每个方法调用相同的序列，它们将生成和返回相同的数字序列。为了保证这一点属性，为类Random指定特定算法。Java实现必须使用此处显示的所有算法类Random，为了Java代码的绝对可移植性。

http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Random.html

奇怪的是，你会认为拥有可预测的“随机”数字存在隐性安全问题。

这是关于“种子”的。相同的种子产生相同的结果。

这都是关于输入种子的。相同的种子产生相同的结果时间。即使你一次又一次地重新运行你的程序，它的输出也是一样的。

public static void main(String[] args) {

    randomString(-229985452);
    System.out.println("------------");
    randomString(-229985452);

}

private static void randomString(int i) {
    Random ran = new Random(i);
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());

}

输出

-755142161
-1073255141
-369383326
1592674620
-1524828502
------------
-755142161
-1073255141
-369383326
1592674620
-1524828502

当java.util.Random的实例使用特定的种子参数（在本例中为-22985452或-147090649）构建时，它遵循从该种子值开始的随机数生成算法。

使用相同种子构建的每个随机数每次都会生成相同的数字模式。

Random始终返回相同的序列。它用于重排数组和其他排列操作。

要获得不同的序列，需要在某个位置初始化序列，称为“种子”。

randomSting在“随机”序列的i位置（种子=-22985452）获得随机数。然后将ASCII码用于种子位置之后的序列中的下一个27个字符，直到该值等于0。这将返回“hello”。同样的操作也适用于“世界”。

我认为该代码不适用于任何其他单词。编程的人非常了解随机序列。

这是非常棒的极客代码！

我写了一个快速程序来寻找这些种子：

import java.lang.*;
import java.util.*;
import java.io.*;

public class RandomWords {
    public static void main (String[] args) {
        Set<String> wordSet = new HashSet<String>();
        String fileName = (args.length > 0 ? args[0] : "/usr/share/dict/words");
        readWordMap(wordSet, fileName);
        System.err.println(wordSet.size() + " words read.");
        findRandomWords(wordSet);
    }

    private static void readWordMap (Set<String> wordSet, String fileName) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.trim().toLowerCase();
                if (isLowerAlpha(line)) wordSet.add(line);
            }
        }
        catch (IOException e) {
            System.err.println("Error reading from " + fileName + ": " + e);
        }
    }

    private static boolean isLowerAlpha (String word) {
        char[] c = word.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] < 'a' || c[i] > 'z') return false;
        }
        return true;
    }

    private static void findRandomWords (Set<String> wordSet) {
        char[] c = new char[256];
        Random r = new Random();
        for (long seed0 = 0; seed0 >= 0; seed0++) {
            for (int sign = -1; sign <= 1; sign += 2) {
                long seed = seed0 * sign;
                r.setSeed(seed);
                int i;
                for (i = 0; i < c.length; i++) {
                    int n = r.nextInt(27);
                    if (n == 0) break;
                    c[i] = (char)((int)'a' + n - 1);
                }
                String s = new String(c, 0, i);
                if (wordSet.contains(s)) {
                    System.out.println(s + ": " + seed);
                    wordSet.remove(s);
                }
            }
        }
    }
}

我现在已经在后台运行了它，但它已经找到了足够的词来描述经典的穿山甲：

import java.lang.*;
import java.util.*;

public class RandomWordsTest {
    public static void main (String[] args) {
        long[] a = {-73, -157512326, -112386651, 71425, -104434815,
                    -128911, -88019, -7691161, 1115727};
        for (int i = 0; i < a.length; i++) {
            Random r = new Random(a[i]);
            StringBuilder sb = new StringBuilder();
            int n;
            while ((n = r.nextInt(27)) > 0) sb.append((char)('`' + n));
            System.out.println(sb);
        }
    }
}

（视频演示。）

第727295876页、第128911页、第1611659页、第235516779页。