Java 时间性能，10000个元素的阵列，简单的应用程序

当我运行这段代码时，我得到了0.25秒的时间，我想改进这段代码，使时间优于0.16秒-这是极限。我知道这取决于硬件。时间是在不填充数组的情况下计算的。我必须在阵列上工作。我该如何改进这一点

更新：我想得到平均值最小的切片的第一个元素的索引

    public static void main(String[] args) {
    int[] A = new int[10000] ;
    double randomNum ;
    for(int i= 0 ; i<A.length ; i++)
    {
        randomNum = 0 + (double)(Math.random()*1); 
        if(randomNum>0.5)
            A[i]=-1;
        else
            A[i]=1;
    }

  System.out.println("Compute");   


    long start_time = System.nanoTime();
    int result = 0;
    double minavg = 100000 ;
    double avg;
    double suma = 0;
    int count = 0;

    for(int i=0 ; i<A.length-1 ; i++)
    {
        for(int k=i ; k<A.length ; k++)
        {
            suma+=A[k];
            count++;


            if(count>1)
            {
                 if(A[k]<A[k-1]) {
                avg=suma/count;
                if(minavg>avg)
                {
                    minavg=avg;
                    result =  i;
                }
                 }
            }


        } 
        suma=0;
        count=0;

    }

    long end_time = System.nanoTime();
    double difference = (end_time - start_time)/1e9;
    System.out.println(difference);
}

publicstaticvoidmain（字符串[]args）{
int[]A=新的int[10000]；
双随机数；
对于（int i=0；i0.5）
A[i]=-1；
其他的
A[i]=1；
}
System.out.println（“计算”）；
长启动时间=System.nanoTime（）；
int结果=0；
双倍minavg=100000；
双平均值；
双suma=0；
整数计数=0；
对于（int i=0；i我尝试在javascript中研究这个问题。我从平均时间0.101开始，经过一些小的修改，一直到0.076：

function main() {
    var A = new Array() ;
    var randomNum ;
    for(var i= 0 ; i<1000 ; i++)
    {
        randomNum = 0 + Math.random(); 
        if(randomNum>0.5)
            A[i]=-1;
        else
            A[i]=1;
    }

  console.log("Compute");   


    var start_time = new Date().getTime();;
    var result = 0;
    var minavg = 100000 ;

    for(var i=0 ; i<A.length-1 ; i++)
    {
        var suma= A[i];
        var count=1;
        for(var k=i+1 ; k<A.length ; k++)
        {
            suma+=A[k];
            count++;
            if(A[k]<A[k-1]) {
                var avg=suma/count;
                if(minavg>avg)
                {
                    minavg=avg;
                    result =  i;
                }
            }
        } 
     }

    var end_time = new Date().getTime();
    var difference = (end_time - start_time)*1e-3;

    console.log(difference);

}

main();

函数main（）{
var A=新数组（）；
随机变量；
对于（var i=0；i0.5）
A[i]=-1；
其他的
A[i]=1；
}
console.log（“Compute”）；
var start_time=new Date（）.getTime（）；；
var结果=0；
var minavg=100000；
对于（var i=0；i您可以做的一件事是将
suma
的数据类型更改为
int
，但请记住在
avg
计算中将其转换回
double
。这将避免增量中的大量数据类型转换，在我的情况下，它花费了大约1/7的时间

其次，我不确定这种情况：

if (A[k] < A[k - 1]) 

if（A[k]

Imho应该是这样的（需要花费1/2的时间）：

if（A[k]

但我不确定最终结果是否正确，但它解决了@Crferreira提到的问题


我仍然不确定你的原始算法和任务。这是我对它的重写。平均来说，它需要时间进一步降低到上次测量的1/3

private static void calculateB(int[] A) {
    if (A == null || A.length < 2) {
        return;
    }
    long start_time = System.nanoTime();
    int result = 0;
    double minavg = 100000;
    double avg;
    int suma = A[A.length - 1];
    int count = 1;

    for (int i = A.length - 2; i >= 0; i--) {
        count += 1;
        int previous = A[i];
        suma += previous;

        if (previous < minavg) {
            avg = (double) suma / count;
            if (minavg > avg) {
                minavg = avg;
                result = i;
            }
        }
    }

    long end_time = System.nanoTime();
    double difference = (end_time - start_time) / 1e6;
    System.out.println(result + " " + minavg + " " + difference);
}

private静态无效计算b（int[]A）{
如果（A==null | | A.length<2）{
回来
}
长启动时间=System.nanoTime（）；
int结果=0；
双倍minavg=100000；
双平均值；
int suma=A[A.长度-1]；
整数计数=1；
对于（int i=A.length-2；i>=0；i--）{
计数+=1；
int previous=A[i]；
suma+=以前的；
如果（先前的平均值）{
minavg=平均值；
结果=i；
}
}
}
long end_time=System.nanoTime（）；
双差=（结束时间-开始时间）/1e6；
System.out.println（结果+“”+minavg+“”+差异）；
}

但这一次的结果与原始结果不同，您必须检查它是否根据赋值进行验证。我确实手动进行了计算，结果似乎没有问题。这一次，从最后开始迭代表。由于这一点，我们有了一个求和的基础，我们可以在进一步的迭代中重用。
至于一般规则——我不确定你在计算什么——从代码来看，它似乎是以下项目中平均值最低的项目的索引，包括索引上的项目——这是正确的吗？
一个优化是通过如下重新排列代码来删除count>1测试

for(int i=0 ; i<A.length-1 ; i++) {
    suma=A[i];
    for(int k=i+1 ; k<A.length ; k++) {
        suma+=A[k];
        count++;
        if(A[k]<A[k-1]) {

for（int i=0；我想请你解释一下你想用这个算法做什么？两个建议：（1）学习使用分析器；（2）阅读Nano-，SI和其他单位制中表示因子10的前缀−9（十亿分之一）。你用
1e6
除以差值，得到
秒*10^3
或
毫秒
。如果可能的话，最好改进你的算法。你是对的，我用正确的时间值和除以nano更新了主要帖子。尝试10000个元素，时间不会线性增加，在我的代码中我看不到差别，但谢谢H10K，我现在有了8.096s和9.533的原始代码（快了16%）@kxyzand时间呢？几乎一样，稍好一些~0.1s，对不起，我将双和改为int，并将其改进为1.7s^^^谢谢
for(int i=0 ; i<A.length-1 ; i++) {
    suma=A[i];
    for(int k=i+1 ; k<A.length ; k++) {
        suma+=A[k];
        count++;
        if(A[k]<A[k-1]) {