Weblogism

This method is a classic of algorithm classes: use a temporary value to swap two indexes in the array:

public class NumberReversal {

  public static void reverseArray(int[] array) {
        if (array == null) {
            return;
        }
        int i = 0;
        int j = array.length - 1;
        int tmp;
        while (j > i) {
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
            j--;
            i++;
        }
    }

  public static void main(String[] args) {
        int[] test = { 1, 2, 3, 4 };
        reverseArray(test);
        for (int i : test) {
            System.out.println(i);
        }
    }
}

Recursions make CS teachers happy, so here is a solution that uses one. I personally find it hard to read, and recursions, despite being teachers’ pet, are usually frowned upon in real life. It relies on 2 key methods: System.arraycopy, which copies an array into another, and Arrays.copyOfRange. The 2 methods do pretty much the same thing, except Arrays.copyOfRange does some bond checking… and uses System.arraycopy. I used them both so that you are aware of them.

import java.util.Arrays;

public class NumberReversal {

  static int[] concat(int[] a, int[] b ) {
        int[] c = new int[a.length + b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
        return c;
    }

  public static int[] reverseArray(int[] array) {
        if (array.length == 0) {
            return new int[] {};
        } else if (array.length == 1) {
            return array;
        } else {
            // recursion: concatenate the reverse of the end of the array 
            // to the first element (put at the end)
            return concat(
                    reverseArray(Arrays.copyOfRange(array, 1, array.length)),
                    new int[] { array[0] }
            );
        }
    }

  public static void main(String[] args) {
        int[] test = {1, 2, 3, 4};
        int[] reversed = reverseArray(test);
        for (int i: reversed) {
            System.out.println(i);
        }
    }
}

This solution forces you to deal with the int[] to Integer[] conversion, which is a bit of a pain. So this solution actually cheats by only using Integer objects. But if you wanted to use int[], you would have to do the conversion either “manually”, or using Apache common lang’s ArrayUtils.toPrimitive and ArrayUtils.toObject…

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class NumberReversal {

  public static void reverseArray(Integer[] array) {
        List list = Arrays.asList(array);
        Collections.reverse(list);

      array = (Integer[])list.toArray(new Integer[array.length]);
    }

  public static void main(String[] args) {
        Integer[] test = { 1, 2, 3, 4 };
        reverseArray(test);
        for (int i : test) {
            System.out.println(i);
        }
    }
}

This one uses the Apache commons lang library which, a few days ago I was mentioning as one of my favourite libs.

import org.apache.commons.lang.ArrayUtils;

public class NumberReversal {
    public static void main(String[] args) {
        int[] test = {1, 2, 3, 4};
        ArrayUtils.reverse(test);
        for (int i: test) {
            System.out.println(i);
        }
    }
}