相关疑难解决方法(0)

我是java的新手,并且昨晚运行了一些代码,这真让我烦恼.我正在构建一个简单的程序来显示for循环中的每个X输出,当我使用模数作为variable % variablevs variable % 5000或诸如此类时,我注意到性能的大幅下降.有人可以向我解释为什么会这样,是什么导致它？所以我可以更好......

这是"高效"代码(对不起,如果我得到一些语法错误我现在不在计算机上的代码)

long startNum = 0;
long stopNum = 1000000000L;

for (long i = startNum; i <= stopNum; i++){
    if (i % 50000 == 0) {
        System.out.println(i);
    }
}

这是"效率低下的代码"

long startNum = 0;
long stopNum = 1000000000L;
long progressCheck = 50000;

for (long i = startNum; i <= stopNum; i++){
    if (i % progressCheck == 0) {
        System.out.println(i);
    }
}

请注意,我有一个日期变量来衡量差异,一旦它变得足够长,第一个花了50毫秒而另一个花了12秒或类似的东西.如果你的电脑比我的电脑更有效,你可能不得不增加stopNum或减少progressCheck.

我在网上找了这个问题,但我找不到答案,也许我只是没有问它.

编辑:我没想到我的问题如此受欢迎,我很欣赏所有答案.我确实在每一半的时间内执行了一个基准测试,效率低下的代码需要相当长的时间,1/4秒与10秒的时间相比.当然他们正在使用println,但他们都做了相同的数量,所以我不认为这会扭曲很多,特别是因为差异是可重复的.至于答案,因为我是Java新手,我会让投票现在决定哪个答案最好.我会在星期三之前选择一个.

EDIT2:我今晚要进行另一次测试,而不是模数,它只是递增一个变量,当它达到progressCheck时,它将执行一次,然后将该变量重置为0.对于第三个选项.

EDIT3.5:

我使用了这段代码,下面我将展示我的结果..谢谢大家的精彩帮助!我也尝试将long的短值与0进行比较,因此我所有的新检查都会发生"65536"次,使其在重复中相等.

public …

标题基本上都说明了一切.我通常在一起测试这个string == null,所以我并不真正关心一个零安全测试.我应该使用哪个？

String s = /* whatever */;
...
if (s == null || "".equals(s))
{
    // handle some edge case here
}

要么

if (s == null || s.isEmpty())
{
    // handle some edge case here
}

在那个笔记 - isEmpty()甚至做除了return this.equals("");或以外的任何事情return this.length() == 0;？

他们之间有什么区别？我知道

LinkedHashSet是HashSet的有序版本,它维护所有元素的双向链接列表.在关心迭代顺序时,请使用此类而不是HashSet.当您遍历HashSet时,顺序是不可预测的,而LinkedHashSet允许您按照插入顺序迭代元素.

但是在LinkedHashSet的源代码中,只有HashSet的调用构造函数.那么双链接列表和插入顺序在哪里？

通常的构造函数ArrayList是:

ArrayList<?> list = new ArrayList<>();

但是还有一个重载的构造函数,其初始容量有一个参数:

ArrayList<?> list = new ArrayList<>(20);

ArrayList当我们可以随意添加时,为什么创建具有初始容量的产品很有用？

我是Java 8的新手.我仍然不深入了解API,但我已经做了一个小的非正式基准测试来比较新Streams API与优秀旧Collections的性能.

测试包括过滤一个列表Integer,并为每个偶数计算平方根并将其存储在结果List中Double.

这是代码:

    public static void main(String[] args) {
        //Calculating square root of even numbers from 1 to N       
        int min = 1;
        int max = 1000000;

        List<Integer> sourceList = new ArrayList<>();
        for (int i = min; i < max; i++) {
            sourceList.add(i);
        }

        List<Double> result = new LinkedList<>();


        //Collections approach
        long t0 = System.nanoTime();
        long elapsed = 0;
        for (Integer i : sourceList) {
            if(i % 2 == 0){
                result.add(Math.sqrt(i));
            } …

我在Surface Pro 2平板电脑上运行带有Java 7更新45 x64(没有安装32位Java)的Windows 8.1 x64.

当i的类型为long时,下面的代码需要1688ms,当i是int时,代码需要109ms.为什么在具有64位JVM的64位平台上,long(64位类型)比int慢一个数量级？

我唯一的猜测是,CPU需要更长的时间来添加64位整数而不是32位整数,但这似乎不太可能.我怀疑Haswell不使用纹波进位加法器.

我在Eclipse Kepler SR1中运行它,顺便说一句.

public class Main {

    private static long i = Integer.MAX_VALUE;

    public static void main(String[] args) {    
        System.out.println("Starting the loop");
        long startTime = System.currentTimeMillis();
        while(!decrementAndCheck()){
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Finished the loop in " + (endTime - startTime) + "ms");
    }

    private static boolean decrementAndCheck() {
        return --i < 0;
    }

}

编辑:以下是VS 2013(下面),同一系统编译的等效C++代码的结果. 长:72265ms int:74656ms 这些结果是在调试32位模式下.

在64位发布模式下: 长:875ms long long:906ms int:1047ms

这表明我观察到的结果是JVM优化怪异而不是CPU限制.

#include "stdafx.h"
#include "iostream"
#include …

标题是参考为什么处理排序数组比未排序数组更快？

这也是分支预测效果吗？注意:这里对排序数组的处理速度较慢 !!

请考虑以下代码:

private static final int LIST_LENGTH = 1000 * 1000;
private static final long SLOW_ITERATION_MILLIS = 1000L * 10L;

@Test
public void testBinarySearch() {
    Random r = new Random(0);
    List<Double> list = new ArrayList<>(LIST_LENGTH);
    for (int i = 0; i < LIST_LENGTH; i++) {
        list.add(r.nextDouble());
    }
    //Collections.sort(list);
    // remove possible artifacts due to the sorting call
    // and rebuild the list from scratch:
    list = new ArrayList<>(list);

    int nIterations = 0;
    long startTime = System.currentTimeMillis(); …

我有两个整数x和y.我需要计算x/y,结果我想浮动.例如,作为3/2我希望有1.5的结果.我认为,最简单的(或唯一的)的方式来做到这一点是转换x和y成float类型.不幸的是,我找不到一个简单的方法来做到这一点.你能帮帮我吗？

有没有人使用秒表基准测试,还是应该总是使用性能工具？有没有适合Java的免费工具？你用什么工具？

为了澄清我的担忧,由于操作系统调度,秒表基准测试会出错.在程序的给定运行中,操作系统可能会在您正在计时的函数中间安排另一个(或多个)进程.在Java中,如果你试图为一个线程化的应用程序计时,事情会更糟糕,因为JVM调度程序会在混合中引入更多的随机性.

基准测试时如何解决操作系统调度问题？

我听说过这个术语,但我不完全确定它是什么意思,所以:

• 它意味着什么,它意味着什么？
• IS和IS不是微基准测试的一些例子是什么？
• 微基准测试的危险是什么,你如何避免它？
  • (或者这是件好事吗？)