Java tutorial
/** * Wrapper for arrays of ordered strings. This verifies the arrays and supports * efficient lookups. * * @author Dennis M. Sosnoski */ public class StringArray { /** Ordered array of strings. */ private final String[] m_list; /** * Constructor from array of values. This checks the array values to make * sure they're ordered and unique, and if they're not throws an exception. * Once the array has been passed to this constructor it must not be * modified by outside code. * * @param list array of values */ public StringArray(String[] list) { validateArray(list); m_list = list; } /** * Constructor from array of values to be added to base instance. This * merges the array values, making sure they're ordered and unique, and if * they're not throws an exception. * * @param list array of values * @param base base instance */ public StringArray(String[] list, StringArray base) { validateArray(list); m_list = mergeArrays(list, base.m_list); } /** * Constructor from pair of base instances. This merges the values, making * sure they're unique, and if they're not throws an exception. * * @param array1 first base array * @param array2 second base array */ public StringArray(StringArray array1, StringArray array2) { m_list = mergeArrays(array1.m_list, array2.m_list); } /** * Constructor from array of values to be added to pair of base instances. * This merges the array values, making sure they're ordered and unique, and * if they're not throws an exception. * * @param list array of values * @param array1 first base array * @param array2 second base array */ public StringArray(String[] list, StringArray array1, StringArray array2) { validateArray(list); m_list = mergeArrays(list, mergeArrays(array1.m_list, array2.m_list)); } /** * Constructor from array of values to be added to three base instances. * This merges the array values, making sure they're ordered and unique, and * if they're not throws an exception. * * @param list array of values * @param array1 first base array * @param array2 second base array * @param array3 third base array */ public StringArray(String[] list, StringArray array1, StringArray array2, StringArray array3) { validateArray(list); m_list = mergeArrays(list, mergeArrays(array1.m_list, mergeArrays(array2.m_list, array3.m_list))); } /** * Constructor from array of values to be added to four base instances. * This merges the array values, making sure they're ordered and unique, and * if they're not throws an exception. * * @param list array of values * @param array1 first base array * @param array2 second base array * @param array3 third base array * @param array4 fourth base array */ public StringArray(String[] list, StringArray array1, StringArray array2, StringArray array3, StringArray array4) { validateArray(list); m_list = mergeArrays(list, mergeArrays(array1.m_list, mergeArrays(array2.m_list, mergeArrays(array3.m_list, array4.m_list)))); } /** * Merge a pair of ordered arrays into a single array. The two source arrays * must not contain any values in common. * * @param list1 first ordered array * @param list2 second ordered array * @return merged array */ private String[] mergeArrays(String[] list1, String[] list2) { String[] merge = new String[list1.length + list2.length]; int fill = 0; int i = 0; int j = 0; while (i < list1.length && j < list2.length) { int diff = list2[j].compareTo(list1[i]); if (diff > 0) { merge[fill++] = list1[i++]; } else if (diff < 0) { merge[fill++] = list2[j++]; } else { throw new IllegalArgumentException("Repeated value not allowed: \"" + list1[i] + '"'); } } if (i < list1.length) { System.arraycopy(list1, i, merge, fill, list1.length - i); } if (j < list2.length) { System.arraycopy(list2, j, merge, fill, list2.length - j); } return merge; } /** * Make sure passed-in array contains values that are in order and without * duplicate values. * * @param list */ private void validateArray(String[] list) { if (list.length > 0) { String last = list[0]; int index = 0; while (++index < list.length) { String comp = list[index]; int diff = last.compareTo(comp); if (diff > 0) { throw new IllegalArgumentException("Array values are not ordered"); } else if (diff < 0) { last = comp; } else { throw new IllegalArgumentException("Duplicate values in array"); } } } } /** * Get string at a particular index in the list. * * @param index list index to be returned * @return string at that index position */ public String get(int index) { return m_list[index]; } /** * Find index of a particular string in the array. This does * a binary search through the array values, using a pair of * index bounds to track the subarray of possible matches at * each iteration. * * @param value string to be found in list * @return index of string in array, or <code>-1</code> if * not present */ public int indexOf(String value) { int base = 0; int limit = m_list.length - 1; while (base <= limit) { int cur = (base + limit) >> 1; int diff = value.compareTo(m_list[cur]); if (diff < 0) { limit = cur - 1; } else if (diff > 0) { base = cur + 1; } else { return cur; } } return -1; } /** * Get number of values in array * * @return number of values in array */ public int size() { return m_list.length; } }