Problems with a while loop within a method... (please help so I can sleep)

Question

Crud, I keep getting the wrong outputs for the reverseArray. I keep getting "9 7 5 7 9" instead of "9 7 5 3 1". Can you guys figure it out? T.I.A (been trying to figure this prog out for quite some time now)
* AWT Sample application
* @author Weili Guan
* @version 1999999999.2541a 04/02/26
public class ArrayMethods{
   private static int counter, counter2, ndx, checker, sum, a, size, zero;
   private static int length;
   private static int [] output2, output3, reverse, array;
   private static double output;
   private static double dblsum, dblchecker, average;
   public static void main(String[] args) {
      //int
      //int [] reverse;
      System.out.println("Testing with array with the values [1,3,5,7,9]");
      size = 5;
      array = new int [size];
      reverse = new int [size];
      array[0] = 1;
      array[1] = 3;
      array[2] = 5;
      array[3] = 7;
      array[4] = 9;
      System.out.println("Testing with sumArray...");
      output = sumArray(array);
      System.out.println("Sum of the array: " + sum);
      System.out.println();
      System.out.println("Testing with countArray...");
      output = countArray(array);
      System.out.println("Sum of the elements : " + checker);
      System.out.println();
      System.out.println("Testing with averageArray...");
      output = averageArray(array);
      System.out.println("The average of the array : " + average);
      System.out.println();
      System.out.println("Testing with reverseArray...");
      output2 = reverseArray(array);
      output3 = reverseArray(reverse);
      //System.out.print(reverse[4]);
      System.out.print("The reverse of the array : ");
      for(ndx = 0; ndx < array.length; ndx++){
         System.out.print(reverse[ndx] + " ");
   private ArrayMethods(){
   public static int sumArray(int[] array){
      checker = 0;
      ndx = 0;
      counter = 0;
      sum = 0;
      while(counter < array.length){
         if (array[ndx] > 0){
            checker++;
         counter++;
      if(array.length > 0 && checker == array.length){
         while(ndx < array.length){
            sum += array[ndx];
            ndx++;
         return sum;
      else{
         sum = 0;
         return sum;
    /*Computes the sum of the elements of an int array. A null input, or a
    zero-length array are summed to zero.
    Parameters:
        array - an array of ints to be summed.
    Returns:
        The sum of the elements.*/
   public static int countArray(int[] array){
      checker = 0;
      ndx = 0;
      counter = 0;
      sum = 0;
      while(counter < array.length){
         if(array[ndx] > 0 && array[ndx] != 0){
            checker++;
         counter++;
      return checker;
    /*Computes the count of elements in an int array. The count of a
    null reference is taken to be zero.
    Parameters:
        array - an array of ints to be counted.
    Returns:
        The count of the elements.*/
   public static double averageArray(int[] array){
      dblchecker = 0;
      ndx = 0;
      counter = 0;
      dblsum = 0;
      while(counter < array.length){
         if(array[ndx] > 0){
            dblchecker++;
         counter++;
      if(array.length > 0 && checker == array.length){
         while(ndx < array.length){
            dblsum += array[ndx];
            ndx++;
         average = dblsum / dblchecker;
         return (int) average;
      else{
         average = 0;
         return average;
    /*Computes the average of the elements of an int array. A null input,
    or a zero-length array are averaged to zero.
    Parameters:
        array - an array of ints to be averaged.
    Returns:
        The average of the elements.*/
   public static int[] reverseArray(int[] array){
      ndx = 0;
      counter = 0;
      counter2 = 0;
      if(array.length == 0){
         array[0] = 0;
         return array;
      else{
            //reverse = array;
         while(ndx <= size - 1){
               reverse[ndx] = array[4 - counter];
               counter++;
               ndx++;
               System.out.print("H ");
      return reverse;
    /*Returns a new array with the same elements as the input array, but
    in reversed order. In the event the input is a null reference, a
    null reference is returned. In the event the input is a zero-length array,
    the same reference is returned, rather than a new one.
    Parameters:
        array - an array of ints to be reversed.
    Returns:
        A reference to the new array.*/
}

Answer 1

What was the original question? I thought it was
getting the desired output, " 9 7 5 3 1."
He didn't ask for improving the while loop or the
reverseArray method, did he?
By removing "output3 = reverseArray(reverse):," you
get the desired output.Okay, cranky-pants. Your solution provides the OP with the desired output. However, it only addresses the symptom rather than the underlying problem. If you'd bother yourself to look at the overall design, you might see that hard-coding magic numbers and returning static arrays as the result of reversing an array passed as an argument probably isn't such a great idea. That's why I attempted to help by providing a complete, working example of a method that "reverses" an int[].
Removing everything and providing "System.out.println("9 7 5 3 1");" gets him the desired output as well, but (like your solution) does nothing to address the logic problems inherent in the method itself and the class as a whole.