Java中是否有任何SDK函数可将数字推入堆栈并计算平均值？

Question

I tried to Google for an answer but I think I am using wrong keywords. What I am trying to do is - I have a collection of numbers (ints), and as I add new numbers I am computing the new average. I noticed that as my array grows, once I get to a certain count of elements (lets say 200), the calculation time becomes noticeable. I was wondering if there are any built-in SDK functions I can utilize to speed up my codes performance? I will be running the code on Android.

int[] numbers = new int[3];

private int average(int number){
    //some buildin operation to push in array an int?
    for(int i=0; i < numbers.length -1 ; i++){
        numbers[i]=numbers[i+1];
    }
    numbers[numbers.length -1] = number;
                    ;                
    //numbers[0] = numbers[1];
    //numbers[1] = numbers[2];
    //numbers[2] = number;

    int sum = 0;

    //any operation to get average?
    for(int i=0; i < numbers.length ; i++)
        sum = sum + numbers[i];

    //calculate average value
    double average = sum / numbers.length;

    return (int)average;
 }

Answer 1

A running average (on integer types) can be efficiently calculated as:

sum -= oldest_value;
sum += new_value;
avg = (double)sum / num_elements;

To avoid having to shift all your elements through your array each time, you should use your array as a circular buffer .

Answer 2

A bit late, but here's one way:

public class RunningAverage
{
    ArrayList<Integer> numList = new ArrayList<Integer>();
    private int runningSum = 0;
    private int sampleSize;
    public RunningAverage(int[] initialSetOfValues)
    {
        if(initialSetOfValues == null || initialSetOfValues.length == 0)
        {
            // Abort gracefully
            // left as an exercise... 
        }
        sampleSize = initialSetOfValues.length;
        for (int num : initialSetOfValues)
        {
            numList.add(num);
            runningSum += num;
        }
    }

    public int getRunningAverage(int newestVal)
    {
        numList.add(newestVal);
        int oldestVal = numList.remove(0);

        runningSum = runningSum - oldestVal + newestVal;
        return runningSum / sampleSize;
    }

    public static void main(String args[])
    {
        RunningAverage r = new RunningAverage(new int[]{4, 5 , 6, 7});
        System.out.println(r.getRunningAverage(8));
        System.out.println(r.getRunningAverage(9));
        System.out.println(r.getRunningAverage(10));
    }
}

Answer 3

Now I just made ​​myself a circular buffer (as suggested Oli Charlesworth ).

And this is my implementation:

/** Circular buffer */
private class WindowBuffer {
    private final float [] values;
    private final int capacity;
    private float sum;
    private float average;
    private int head = -1;
    private boolean full = false;

    WindowBuffer(final int capacity) {
        this.capacity = capacity;
        values = new float[capacity];
        for (int i = 0; i < capacity; i++) {
            values[i] = 0f;
        }
    }
    void clean() {
        if (head == -1) return;
        for (int i = 0; i < capacity; i++) {
            values[i] = 0f;
        }               
        sum = 0;
        average = 0;
        head = -1;
        full = false;
    }

    void put(final float value) {
        head++;
        if (head >= capacity) {
            head = 0;
            full = true;
        }
        sum -= values[head];
        sum += value;
        values[head] = value;
        calculateAverage();
    }

    private void calculateAverage() {
        if (full) {
            average = sum / capacity;
        } else {
            average = sum / (head + 1);
        }
    }

    float getAverage() {
        return average;
    }
}

UPD

void clean() {
            if (head == -1) return;
            if (full) {
                for (int i = 0; i < capacity; i++) {
                    values[i] = 0f;
                }
            } else {
                for (int i = 0; i <= head; i++) {
                    values[i] = 0f;
                }
            }
            sum = 0;
            average = 0;
            head = -1;
            full = false;
        }

Answer 4

I would have been using an ArrayList if I were you. Take a look at a code that does exactly the same thing as your code do.

ArrayList<Integer> numbers = new ArrayList<Integer>();
private Integer average(Integer number){
    numbers.add(number);
    Integer sum = 0;    
    for(Integer num : numbers)  {
        sum = sum + num;
    }
    double average = sum / numbers.size();
   return (Integer)average;
}

And also, if you can save the variable sum for reuse, then you know how to find the new average for sure :)

Answer 5

There aren't better algotithm that calculate the average. The optimized code (using the same data structure) would be:

private int average(int number){
      int sum = 0;
      for(int i=0; i<(numbers.length-1); i++){
          numbers[i] = numbers[i+1];
          sum += numbers[i];
      } 
      numbers[numbers.length -1] = number;

      return (int)((sum+number) / numbers.length);
}

Answer 6

im struggling to understand your question and your code. i have no idea what that first loop is for at all.

but if your just trying to find the average your pretty much right

int sum =0;
for(int i=0; i<array.length();i++){
  sum=sum+array[i];
}
average = sum/array.length();

not the fastest way but every easy to read