两种方法实现相同的算法一种在java中比另一种方法占用更多的运行时间

我试图使用

newdate（）.getTime（）

计算两个方法的运行时间。这两种方法遵循相同的算法，其中一种方法增加了一些步骤，但是步骤较少的方法需要更多的时间

我对此感到困惑。以下是两种方法： 这是第一种方法，它使用较少的步骤并花费更多的时间：

public void encryptFiles(List<BloomFilter> bfList1) {
    Matrix matrix2 = new Matrix(400,400);
    Matrix matrix3 = new Matrix(400,400);

    matrix2.setMat(value1);
    matrix3.setMat(value2);

    a2 = matrix2.transpose();
    b2 = matrix3.transpose();

    startTime2 = new Date().getTime();
    for (BloomFilter bfList2 : bfList1) {
        Random raa = new Random();
        int g1 = raa.nextInt();
        double m1 = (double) ((double) Math.round(g1 * 10) / 10.0);

        List<double[]>  res1 = new ArrayList<>();
        double[] e1 = new double[400];
        double[] k1 = new double[400];

        Vector<Double> j = new Vector<Double>(400);
        Vector<Double> h = new Vector<Double>(400);

        //System.out.println("bloom filter in bloom filter list:" + Arrays.toString(bfList2.getBitSet().data));
        String bfName = bfList2.getName();
        for (int i = 0; i < s.size(); i++) {
            if (s.get(i) == 1) {
                j.add( (double) bfList2.getBitSet().getWord(i));
                h.add((double) bfList2.getBitSet().getWord(i));
            } else {
                j.add(0.5 * (bfList2.getBitSet().getWord(i))+m1);
                h.add(0.5 * (bfList2.getBitSet().getWord(i))+m1 );
            }
        }

        for (int u = 0; u < 400; u++) {
            for (int y = 0; y < 400; y++) {
                e1[u] += a2[u][y]*j.get(y);
                k1[u] += b2[u][y]*h.get(y);
            }
        }
        res1.add(e1);
        res1.add(k1);
        hasssh.put(bfName,res1 );
    }
    encryptedBFListInTime = (new Date().getTime())-startTime2;
    encryptedBFListInTime /= 1000.0; 
    System.out.println("encrypt files only in "+encryptedBFListInTime);
}

public void加密文件（列表bfList1）{
矩阵matrix2=新矩阵（400400）；
矩阵matrix3=新矩阵（400400）；
matrix2.setMat（值1）；
matrix3.setMat（值2）；
a2=矩阵2.转置（）；
b2=矩阵3.转置（）；
startTime2=新日期（）.getTime（）；
对于（BloomFilter bfList2:bfList1）{
随机raa=新随机（）；
int g1=raa.nextInt（）；
双m1=（双）（（双）数学四舍五入（g1*10）/10.0）；
List res1=new ArrayList（）；
双精度[]e1=新双精度[400]；
double[]k1=新的double[400]；
向量j=新向量（400）；
向量h=新向量（400）；
//System.out.println（“bloom过滤器列表中的bloom过滤器：“+Arrays.toString（bfList2.getBitSet（）.data））；
字符串bfName=bfList2.getName（）；
对于（int i=0；i

以下是第二种方法，步骤多，时间少：

public  BloomFilterIndex encryptTree(BloomFilterIndex tree) {

    startTime9 = new Date().getTime();
    for(int m = 0; m < tree.root.children.size(); m++){
        BloomFilterIndex.BFINode<Integer> n =(BloomFilterIndex.BFINode<Integer>)tree.root.children.get(m);
        encrypt(n);
    }
    end = new Date().getTime() - startTime9;
    //end1 = end - startTime9;
    end /= 1000.0;
    System.out.println("encrypt node in :"+end);
    return tree;
}

公共BloomFilterIndex加密树（BloomFilterIndex树）{
startTime9=新日期（）.getTime（）；
for（int m=0；m

调用以下方法：

public void encrypt(BloomFilterIndex.BFINode<Integer> root) {

    List<double[]> ress = new ArrayList<>();
    if (!root.isLeaf()) {
        c = new double[root.value.size()];
        // c = new double[4];
        for (int i = 0; i < root.value.size(); i++) {
        //  for(int i = 0; i < 4; i++){
            c[i] = root.value.getBitSet().getWord(i);
        }
        ress.add(c);
        root.value = null;
        root.value2 = ress;

        for (BloomFilterIndex.BFINode<Integer> g : root.children) {
            encrypt(g);
        }

    } else {
        //String bfName1 = root.value.getName(); 
        double[] y = new double[400];
        double[] z = new double[400];
        Random r = new Random();
        Integer g1 = r.nextInt();
        double m5 = (double) ((double) Math.round(g1 * 10) / 10.0);
        Vector<Double> m6 = new Vector<Double>(400);
        Vector<Double> n1 = new Vector<Double>(400);

        for (int i = 0; i < s.size(); i++) {
            //  for(int i = 0;i < 400; i++) {
            if (s.get(i) == 1) {
                m6.add((double) root.value.getBitSet().getWord(i));
                n1.add((double) root.value.getBitSet().getWord(i));
            } else {
                m6.add(0.5 * (root.value.getBitSet().getWord(i)) + m5);
                n1.add(0.5 * (root.value.getBitSet().getWord(i)) + m5);
            }
        }

        for (int i = 0; i < 400; i++) {
            for (int j = 0; j < 400; j++) {
                y[i] += a2[i][j] * m6.get(j);
                z[i] += b2[i][j] * n1.get(j);
            }
        }
        ress.add(y);
        ress.add(z);
        root.value = null;
        root.value2 = ress;
        //  hasssh1.put(bfName1, ress);
    }
}

public void encrypt（BloomFilterIndex.BFINode root）{
List ress=新的ArrayList（）；
如果（！root.isLeaf（））{
c=新的双精度[root.value.size（）]；
//c=新的双精度[4]；
对于（int i=0；i

---

问题在哪里。运行时间取决于代码的关键部分。要确定关键部分，请记住，关键部分包含在嵌套最深的for或while循环中。其他代码行只执行一次

在第二个方法中，您从for循环中的调用helper方法！这意味着您正在执行ALLfor循环，并在helper方法树

中嵌套for循环。root.children.size（）

次，因为helper方法被调用了那么多次

当考虑嵌套循环时，乘法！例如

for (int i= 0; i < 5; i++) {
  for (int j= 0; j < 5; j++) {
    DOTHING();
  }
}

for（int i=0；i<5；i++）{
对于（int j=0；j<5；j++）{
DOTHING（）；
}
}

DOTHING将执行25次！为什么？ 外部循环执行5次！ 嵌套循环执行5次！ 5 x 5=25次

---

从for循环中调用该helper方法及其所有嵌套for循环就像添加了另一个嵌套循环。这就是n*n执行与n*n*n或n^2与n^3之间的区别！我希望这会有所帮助！

是否在同一JVM中逐个测试它们？如果是，可能会遇到“启动”延迟。换句话说，JVM必须为第一个方法“预热”，而不是第二个方法。读取