Why System.arraycopy(srcarray,destarray,destpos,length)

Question

Hi,
In the quest for writing an application that uses an int array the changes its length very often, I still find myself wondering why Sun did not add a few simple methods to work directly on the primitive arrays. Mehtods such as add(), delteat(pos) etc.
OK, I can use a Vector or a hashtable. The hashtable is MUCH slower to iterate than the primitive array, so that is not an option. Instead I constantly create a new array og size +1 and copy the old array as well as inserts the new value.
Why did they not at least give some System. functions to link two arrays together in a fast way instead of the slow copy this and that?
rasped

Answer 1

million steps per second on my machine. Is that not
fast enough for your application? Is the amount of
processing per array or list element so small that
iter.next() will make a difference?
The program is for machine learning, so it spends
basically all its time iterating arrays.Not to be an ass, just trying to be helpful, honest, but are you sure? Have you put it on a profiler, or even run some reasonable "hand timing" tests to verify that that's the case? Even if it does boogazillions of array iterations, for the "go to the next element" part to slow things down, the amount of stuff it does to each element would have to be really small. Let's say lists lead you to spend 5 hours doing just the "iter.next()" part, and arrays take only 5 minutes. If your program runs for 5 days, does that 4 hour and 55 minute difference really matter? import java.util.*;
import java.text.*;
public class ArrSpeed2 {
    public static void main(String[] args) {
        int count = Integer.parseInt(args[0]);
        List list = new ArrayList(count);
        DecimalFormat df = new DecimalFormat("#,##0");
        for (int ix = 0; ix < count; ix++) {
            list.add(new Integer(ix));
        long start = System.currentTimeMillis();
        for (Iterator iter = list.iterator(); iter.hasNext(); ) {
            iter.next();
            int ii = ((Integer)iter.next()).intValue();
            int jj = ii + 1;
        long end = System.currentTimeMillis();
        System.out.println(df.format(end - start));
}The above code as is took about 800 ms for me. If I got rid of the bare iter.next() call and uncommented the two lines in the middle, it took about 1200 ms. In other words, those two lines that do almost nothing at all added 50% to the time needed to just do the iteration.
If your loop bodies are more than extract, cast to int, add one, then the work of the loop body will dwarf the iteration cost very quickly.