下面的打印语句将打印“hello world”。有人能解释一下吗？
System.out.println(randomString(-229985452) + " " + randomString(-147909649));
randomString（）如下所示：
public static String randomString(int i)
{
Random ran = new Random(i);
StringBuilder sb = new StringBuilder();
while (true)
{
int k = ran.nextInt(27);
if (k == 0)
break;
sb.append((char)('`' + k));
}
return sb.toString();
}
当前回答
在Java文档中，当为Random类指定种子值时，这是一个有意的特性。
如果使用同一种子创建了两个“随机”实例对每个方法调用相同的序列，它们将生成和返回相同的数字序列。为了保证这一点属性，为类Random指定特定算法。Java实现必须使用此处显示的所有算法类Random，为了Java代码的绝对可移植性。
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Random.html
奇怪的是，你会认为拥有可预测的“随机”数字存在隐性安全问题。
其他回答
该方法源自Denis Tulskiy的答案，生成种子。
public static long generateSeed(String goal, long start, long finish) {
char[] input = goal.toCharArray();
char[] pool = new char[input.length];
label:
for (long seed = start; seed < finish; seed++) {
Random random = new Random(seed);
for (int i = 0; i < input.length; i++)
pool[i] = (char) (random.nextInt(27)+'`');
if (random.nextInt(27) == 0) {
for (int i = 0; i < input.length; i++) {
if (input[i] != pool[i])
continue label;
}
return seed;
}
}
throw new NoSuchElementException("Sorry :/");
}
这是丹尼斯·图尔斯基回答的一个小改进。它把时间缩短了一半
public static long[] generateSeed(String goal, long start, long finish) {
char[] input = goal.toCharArray();
int[] dif = new int[input.length - 1];
for (int i = 1; i < input.length; i++) {
dif[i - 1] = input[i] - input[i - 1];
}
mainLoop:
for (long seed = start; seed < finish; seed++) {
Random random = new Random(seed);
int lastChar = random.nextInt(27);
int base = input[0] - lastChar;
for (int d : dif) {
int nextChar = random.nextInt(27);
if (nextChar - lastChar != d) {
continue mainLoop;
}
lastChar = nextChar;
}
if(random.nextInt(27) == 0){
return new long[]{seed, base};
}
}
throw new NoSuchElementException("Sorry :/");
}
我写了一个快速程序来寻找这些种子：
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页。
在Java文档中，当为Random类指定种子值时，这是一个有意的特性。
如果使用同一种子创建了两个“随机”实例对每个方法调用相同的序列，它们将生成和返回相同的数字序列。为了保证这一点属性，为类Random指定特定算法。Java实现必须使用此处显示的所有算法类Random，为了Java代码的绝对可移植性。
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Random.html
奇怪的是，你会认为拥有可预测的“随机”数字存在隐性安全问题。
原理是用相同的种子构建的随机类每次都会生成相同的数字模式。
