Stack implementation peforming badly.

Question

I have a lot of data points (x and y co-ordinates) which will be added to a stack and popped off as necessary.
Initially i implemented the stack using an ArrayList however when profiling my program i have found that the 'new' operation involved when adding an element to the stack was my program's bottle-neck. So i implemented my own stack based on two integer arrays.
I thought that this would be much faster as there was no creation of new objects, however this was not the case... infact it performed almost ten times as worse then before.
Is there something inherently slow/incorrect with my stack implementation?
code is as follows:
     class MyStack
          int[] x;
          int[] y;
          int index;
          public MyStack()
               x= new int[1024];
               y= new int[1024];
               index=0;
          public int size()
               return index;
          public void add(int x1,int y1)
               if (index==x.length)
                    int[] temp= new int[2*x.length];
                    System.arraycopy(x,0,temp,0,x.length);
                    x=temp;
                    temp= new int[2*y.length];
                    System.arraycopy(y,0,temp,0,y.length);
                    y=temp;
               x[index]=x1;
               y[index]=y1;
               index++;
          public int getX()
               return x[index-1];
          public int getY()
               return y[index-1];
          public void remove()
               index--;
     }

Answer 1

Is this viable? as the stack is not firstly popluated
before pop operations are peformed, i.e. push and pop
operations can and do happen at any time. This would
mean that the timing of the stack until it reaches
"steady-state" will be by its nature much more than
the push and pops after.Yes it would, but then you will get a feeling for what takes time in your stack, internal restructuring or the actual stack operation. You can make an artificial test. First make N (quite large) pushes, so the stack grows, and time that, then make the same number of alternating push/pop operations, so the size won't change, and time that. The difference basically is the internal restructuring of the stack.
I'd say this will show that the second phase has become much faster now that you don't have to do create two new Integer objects for each push. If you can anticipate the stack-size you should make it that big from the start.