您复制的实现......有一些问题。有人可能会说这显然是错误的，因为它使用的是随机值，并且在像
这样的计算中
rank = rnd.nextInt(size);
friquency = (1.0d / Math.pow(rank, this.skew)) / this.bottom;
rank 的值是0，那么频率是Infinity，并弄乱了一些统计数据。
我试图纠正这些错误，但是没有分析了实现并且没有将其与 Zipf 分布函数的定义进行了比较.所以如果有人复制我的代码，他可能会发现它仍然“......有一些问题”。
next 函数的实现，严格来说，不是“total correct”，因为它不一定终止。没有什么可以阻止循环永远运行。根据参数的不同，它可能或多或少需要一段时间才能终止。而且我认为这也是您的“性能”问题的主要原因之一：对于某些值，(dice < frequency) 的条件不太可能发生......
不管怎样，您想要实现的目标可以更通用地表述：您有一定的概率分布。你想要一个“随机”函数，它根据这个分布返回随机值。
实现此目的的一种简单而通用的方法是使用NavigableMap 将（累积的）概率分布映射到目标值。然后可以使用此映射快速查找目标值，给定一个介于 0.0 和 1.0 之间的随机值，该值由 java.util.Random 实例提供。
对于特定情况可能有更有效的解决方案，但同样：这是非常通用和简单的（并且仍然相当有效）。
我在这里为 Zipf 发行版实现了这一点。同样，我没有详细验证所有内容，并且有一些 +1/-1 怪事（在第一段中提到），但它应该表明这个想法：FastZipfGenerator 填充了包含概率分布的地图，并且在next() 函数中，只需执行查找：
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Random;
import java.util.TreeMap;
public class ZipfGeneratorTest
{
public static void main(String[] args) {
int size = 10;
double skew = 2.0;
ZipfGenerator z0 = new ZipfGenerator(size, skew);
FastZipfGenerator z1 = new FastZipfGenerator(size, skew);
long before = 0;
long after = 0;
int n = 5000000;
before = System.nanoTime();
Map<Integer, Integer> counts0 = computeCounts(z0, size, n);
after = System.nanoTime();
System.out.println(counts0+", duration "+(after-before)/1e6);
before = System.nanoTime();
Map<Integer, Integer> counts1 = computeCounts(z1, size, n);
after = System.nanoTime();
System.out.println(counts1+", duration "+(after-before)/1e6);
}
private static Map<Integer, Integer> computeCounts(
ZipfGenerator z, int size, int n)
{
Map<Integer, Integer> counts = new LinkedHashMap<Integer, Integer>();
for (int i=1; i<=size; i++)
{
counts.put(i, 0);
}
for (int i=1; i<=n; i++)
{
int k = z.next();
counts.put(k, counts.get(k)+1);
}
return counts;
}
private static Map<Integer, Integer> computeCounts(
FastZipfGenerator z, int size, int n)
{
Map<Integer, Integer> counts = new LinkedHashMap<Integer, Integer>();
for (int i=1; i<=size; i++)
{
counts.put(i, 0);
}
for (int i=1; i<=n; i++)
{
int k = z.next();
counts.put(k, counts.get(k)+1);
}
return counts;
}
}
// Based on http://diveintodata.org/tag/zipf/
class ZipfGenerator {
private Random rnd = new Random(0);
private int size;
private double skew;
private double bottom = 0;
public ZipfGenerator(int size, double skew) {
this.size = size;
this.skew = skew;
for(int i=1;i <=size; i++) {
this.bottom += (1/Math.pow(i, this.skew));
}
}
// the next() method returns an random rank id.
// The frequency of returned rank ids are follows Zipf distribution.
public int next() {
int rank;
double friquency = 0;
double dice;
rank = rnd.nextInt(size)+1;
friquency = (1.0d / Math.pow(rank, this.skew)) / this.bottom;
dice = rnd.nextDouble();
while(!(dice < friquency)) {
rank = rnd.nextInt(size)+1;
friquency = (1.0d / Math.pow(rank, this.skew)) / this.bottom;
dice = rnd.nextDouble();
}
return rank;
}
// This method returns a probability that the given rank occurs.
public double getProbability(int rank) {
return (1.0d / Math.pow(rank, this.skew)) / this.bottom;
}
}
class FastZipfGenerator
{
private Random random = new Random(0);
private NavigableMap<Double, Integer> map;
FastZipfGenerator(int size, double skew)
{
map = computeMap(size, skew);
}
private static NavigableMap<Double, Integer> computeMap(
int size, double skew)
{
NavigableMap<Double, Integer> map =
new TreeMap<Double, Integer>();
double div = 0;
for (int i = 1; i <= size; i++)
{
div += (1 / Math.pow(i, skew));
}
double sum = 0;
for(int i=1; i<=size; i++)
{
double p = (1.0d / Math.pow(i, skew)) / div;
sum += p;
map.put(sum, i-1);
}
return map;
}
public int next()
{
double value = random.nextDouble();
return map.ceilingEntry(value).getValue()+1;
}
}
它会打印随机样本结果（基本上是“直方图”）和一些计时结果。计时结果类似于
duration 6221.835052
duration 304.761282
表明它很可能会更快（尽管这不应被视为“基准”......）