Weblogism

Reverse an Array

Reversing an array. I can’t really remember the last time I needed to do this, but one thing is for sure, if I did, I didn’t write an ad hoc piece of code to do this: I probably used an ArrayList to do the trick, or some third-party library. But for the sake of education, let’s have a quick look at different solutions.

The Classic way

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);
		}
	}
}

Recursion

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);
		}
	}
}

Using Collections

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);
		}
	}
}

The Sensible Solution

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);
		}
	}
}