problem with System.nanoTime()

hello, and thanks for any help in advance

im having a little problem with trying to measure the time taken by a couple of algorithms to solve a problem. When the application starts the user presses a button which generates a random array of 10 integers (there is also another button which allows user to enter the 10 integers manually):

Code:

---

                .    ...if(e.getSource() == randB)
                        {
                                Random r = new Random();
                                aDisplay.setText("The current array is: {");
                               
                                for(int x = 0; x < 10; x++)
                                {
                                        array[x] = 1 + r.nextInt(100);
                                        aDisplay.append(array[x] + ", ");
                                }
                               
                                aDisplay.append("}");                               
                        }

---

each algorithm is in a separate class from the above code and the algorithms used to sort the array is determined by a checkboxes:

Code:

---

public void itemStateChanged(ItemEvent e)
                {                       
                        bubbleSelected = bubbleC.isSelected()? true: false;
                       
                        selectionSelected = selectionC.isSelected()? true: false;
                                               
                        mergeSelected = mergeC.isSelected()? true: false;
                                               
                        quickSelected = quickC.isSelected()? true: false;
                }

---

next a button is pressed which will sort the array with all the selected algorithms and display the time it took,eg if "bubbleC" checkbox was selected:

Code:

---

display.setText(" ");
                               
                                if(bubbleSelected == true)
                                {
                                        bub.setArray(array);
                                        int bubA[] = new int[10];
                                       
                                        display.append("~~~~~~~~~~~~~~~~~~Bubble Sort~~~~~~~~~~~~~~~~~~\n");                                                               
                                       
                                        long bStart = System.nanoTime();
                                        bubA = bub.sort();
                                        long bEnd = System.nanoTime();
                                        long bTook = bEnd - bStart;                                                                       
                                       
                                        display.append("The sorted array is: {");
                                        for(int x = 0; x < 10; x++)
                                        {
                                                display.append(bubA[x] + ", ");
                                        }
                                        display.append("}\n");
                                       
                                        display.append("The time taken to sort the array is: " + bTook + " nanoseconds\n\n");                                       
                                }

---

bub is a BubbleSort object. here is the BubbleSort class:

Code:

---

public class BubbleSort
{
        private int A[];
       
        public BubbleSort()
        {
                A = new int[1];
                A[0] = 0;
        }
       
        public BubbleSort(int array[])
        {
                A = array;
        }       
       
        public int[] sort()       
        {
                int temp;
               
                for(int x = 0; x < A.length; x++)
                {
                        for(int y = 0; y < ( (A.length)-1 ); y++)
                        {
                                if(A[y] > A[y+1])
                                {
                                        temp = A[y+1];
                                        A[y+1] = A[y];
                                        A[y] = temp;
                                }
                        }
                }               
                return A;
        }
       
        public void setArray(int array[])
        {
                A = array;
        }
}

---

the problem im getting is that when i initially press the sort button ill get a time taken of like around 25000 nanoseconds, however if i press the sort button again without changing the original unsorted array ill progressively get a lower and lower time. If i keep pressing it for a while it goes down to as low as less than 3000 nanoseconds when theoretically i should be getting back the same time since im using the same algorithm on the same array.

on the other hand if i generate a new random array after each time i press the sort button it seems to work fine

i dont know why this is happening because each time i press the sort button the original unsorted array is sent to bub and the array "bubA[]" which stores the sorted array returned by "bub.sort()" is cleared:

Code:

---

...if(bubbleSelected == true)
                                {
                                        bub.setArray(array);
                                        int bubA[] = new int[10];

---

any help would be greatly appreciated

Probably need the whole program to see what is happening.
Have you tried adding println() statements to see where the code is executing and when and what the different values are to see what the reasons for the different times are?
For example is array changed after the sort? Print it out before and after the sort to see. Arrays.toString(array)

Quote:

---

Originally Posted by Norm

Probably need the whole program to see what is happening.
Have you tried adding println() statements to see where the code is executing and when and what the different values are to see what the reasons for the different times are?
For example is array changed after the sort? Print it out before and after the sort to see. Arrays.toString(array)

---

o wow i feel so dumb for not doing that from the start. After doing that i realised that "array" is in fact being sorted even though im technically passing by value; it seems that because its an array its actually passing the references to each of its members as the value?

to solve it i did this:

Code:

---

if(bubbleSelected == true)
                                {
                                        int ububA[] = new int[10];
                                        for(int y = 0; y < 10; y++)
                                        {
                                                ububA[y] = array[y];
                                        }
                                       
                                        bub.setArray(ububA);
                                        int bubA[] = new int[10];

---

making a an actual copy of "array" then passing the copy to bub.sort() stops bub from modifying the original "array"

seems to work fine now when i press sort over and over without changing the value of "array"

thanks a lot Norm
(sigh, i could have saved myself an hour of frustration :()

You would do well to look into using a Java profiler here. There's a science to profiling code that you or I are likely not yet equipped to handle, and this includes improved efficiency of the Java "Hot Spot" compiler with subsequent iterations of a method, "warm-up" cycles for the JVM, and taking garbage collection into consideration. There are many profiler's out there, some are even free.

Quote:

---

an array its actually passing the references to each of its members as the value?

---

An array is treated sort of like an object. It is passes a reference to the array when calling a method. not to its elements.

Quote:

---

Originally Posted by Fubarable

You would do well to look into using a Java profiler here. There's a science to profiling code that you or I are likely not yet equipped to handle, and this includes improved efficiency of the Java "Hot Spot" compiler with subsequent iterations of a method, "warm-up" cycles for the JVM, and taking garbage collection into consideration. There are many profiler's out there, some are even free.

---

Thanks for pointing that out, i didnt even know these existed. I only started learning Java a few weeks ago but a profiler will definitely be useful. A quick google search turned up a few but is there any one that you would recommend?

EDIT:

Quote:

---

Originally Posted by Norm

An array is treated sort of like an object. It is passes a reference to the array when calling a method. not to its elements.

---

thanks i will remember this.
(come to think of it, im vaguely recalling one of my old programming teachers from about two years ago pointing out this same thing to me >.>)