Introduction

In this article, I hope to start a series of articles discussing Java Generic Code. I will start with a problem that although easily solved, reared up its ugly head in many code sessions with my peers. ;)

Java Generic Code - Convert Array Contents to a String in a Generic Way

Imagine that you have the following code:

public static void main(String[] args) {
  Object[] arrayList = {
    new int[] {0, 1, 2 ,3},
    new double[] {0.1d, 1.0d, 3.2d ,3.5d},
    new java.awt.Color[] {java.awt.Color.BLACK, java.awt.Color.WHITE},
    new boolean[] {true, false, true, true, false, false}
  };
  for (int i = 0; i < arrayList.length; i++) {
    System.out.println("Array[" + (i + 1) + "] = " + arrayToString(arrayList[i]));
  }
}

And somehow (due to the "miracle" of the arrayToString() method) the output looks like this:

Array[1] = [0, 1, 2, 3] 
Array[2] = [0.1, 1.0, 3.2, 3.5] 
Array[3] = [java.awt.Color[r=0,g=0,b=0], java.awt.Color[r=255,g=255,b=255]] 
Array[4] = [true, false, true, true, false, false]

You'd be happy with such a method because it means you can now easily get the contents of any Java Array object, formatted as a String using one simple method, instead of repeatedly writing code to iterate the Arrays and process each item individually.

Why This is Actually Important

This may sound like a trivial problem, but let me emphasize that a lot of programmers working in teams will attempt to write their own code to solve this. Having many components carry out the same functionality is a waste, and be warned that while some programmers will get it right and won't have any bugs in solving this problem, other programmers may accidentally write a method to display an Array's contents suffering from bugs! I actually wasted 20 minutes, together with another programmer, because his debug code did not display the LAST item in an Array object, causing us to think the last item actually was never sent properly.

NOT FUNNY! :(

On With the Show

Such a method does not exist in the JDK but it is very short and easy to understand; examine the following code:

 1  public static String arrayToString(Object array) {
 2    if (array == null) {
 3      return "[NULL]";
 4    } else {
 5      Object obj = null;
 6      if (array instanceof Hashtable) {
 7        array = ((Hashtable)array).entrySet().toArray();
 8      } else if (array instanceof HashSet) {
 9        array = ((HashSet)array).toArray();
10      } else if (array instanceof Collection) {
11        array = ((Collection)array).toArray();
12      }
13      int length = Array.getLength(array);
14      int lastItem = length - 1;
15      StringBuffer sb = new StringBuffer("[");
16      for (int i = 0; i < length; i++) {
17        obj = Array.get(array, i);
18        if (obj != null) {
19          sb.append(obj);
20        } else {
21          sb.append("[NULL]");
22        }
23        if (i < lastItem) {
24          sb.append(", ");
25        }
26      }
27      sb.append("]");
28      return sb.toString();
29    }
30  }

Let's examine the code in detail.

Lines 2-4

First off, we check if the array passed to us is null, if so, lines 2-3 will return "[NULL]" and we're done!

Lines 5-12

If the array is not null, then lines 6-12 make sure that if - by mistake? - we were handed a Hashtable/HashSet/Collection object, it will be properly converted to an array object for us!

Line 13

Here we use Java's Array class to generically retrieve the length of the array in question; this of course is needed because if you remember, we receive the array as an Object and not as a proper Array of any Java native type.

Lines 14-16

Calculate the index of the last item; create a StringBuffer to collect the text output; initiate a for-loop to go through all the items in the array.

Line 17

Here again, we use Java's Array class to generically retrieve the currently indexed item.

Line 18-26

Given the currently indexed item in the array, we either add the item's contents - as expressed by its toString() method - and add it to the StringBuffer, or if the current item is null, we add "[NULL]" to the StringBuffer to show there is nothing in this slot. At line 23, we check if the item was the last one, if it is not, line 24 will add a comma and a space so we can continue to build the text output properly.

Line 27-30

Now, we append a "]" character to the end of the StringBuffer, and return the whole text out of the StringBuffer back to our calling method.

I hope this little method will help, I know I have found it very helpful when I had to debug code that had a lot of different types of Array objects which were all to be printed, formatted into Java Exceptions and other interesting things which required the contents of the Array to be easily converted into a text String.

Enjoy.

History

7^th April, 2004: Initial post