An example is probably in order: + * + *
+ * int[] list = null; + * + * // add our ints to a list + * list = ListUtil.add(list, 2); + * list = ListUtil.add(list, 5); + * + * // remove 5 from the list (does so by clearing out that index, but it + * // doesn't slide subsequent elements down) + * ListUtil.clear(list, 5); + * + * // append our objects to the end of the list letting list util know + * // that we're tracking the list size + * list = ListUtil.add(list, 0, 2); + * list = ListUtil.add(list, 1, 5); + * + * // remove the elements from the list, compacting it to preserve + * // element continuity + * ListUtil.removeAt(list, 0); + * ListUtil.remove(list, 5); + *+ * + * The array is initially assumed to be populated with zeros and zero is + * assumed to be an emty slot. + * + *
See the documentation for the individual functions for their exact
+ * behavior.
+ */
+public class IntListUtil
+{
+ /**
+ * Adds the specified value to the first empty slot in the specified
+ * list. Begins searching for empty slots at zeroth index.
+ *
+ * @param list the list to which to add the value. Can be null.
+ * @param value the value to add.
+ *
+ * @return a reference to the list with value added (might not be the
+ * list you passed in due to expansion, or allocation).
+ */
+ public static int[] add (int[] list, int value)
+ {
+ return add(list, 0, value);
+ }
+
+ /**
+ * Adds the specified value to the next empty slot in the specified
+ * list. Begins searching for empty slots at the specified index. This
+ * can be used to quickly add values to a list that preserves
+ * consecutivity by calling it with the size of the list as the first
+ * index to check.
+ *
+ * @param list the list to which to add the value. Can be null.
+ * @param startIdx the index at which to start looking for a spot.
+ * @param value the value to add.
+ *
+ * @return a reference to the list with the value added (might not be
+ * the list you passed in due to expansion, or allocation).
+ */
+ public static int[] add (int[] list, int startIdx, int value)
+ {
+ // make sure we've got a list to work with
+ if (list == null) {
+ list = new int[DEFAULT_LIST_SIZE];
+ }
+
+ // search for a spot to insert yon value; assuming we'll insert
+ // it at the end of the list if we don't find one
+ int llength = list.length;
+ int index = llength;
+ for (int i = startIdx; i < llength; i++) {
+ if (list[i] == 0) {
+ index = i;
+ break;
+ }
+ }
+
+ // expand the list if necessary
+ if (index >= list.length) {
+ list = accomodate(list, index);
+ }
+
+ // stick the value on in
+ list[index] = value;
+
+ return list;
+ }
+
+ /**
+ * Searches through the list checking to see if the value supplied is
+ * already in the list and adds it if it is not.
+ *
+ * @param list the list to which to add the value. Can be null.
+ * @param value the value to test and add.
+ *
+ * @return a reference to the list with value added (might not be
+ * the list you passed in due to expansion, or allocation) or null if
+ * the value was already in the original array.
+ */
+ public static int[] testAndAdd (int[] list, int value)
+ {
+ // make sure we've got a list to work with
+ if (list == null) {
+ list = new int[DEFAULT_LIST_SIZE];
+ }
+
+ // search for a spot to insert yon value; we'll insert it at the
+ // end of the list if we don't find a spot
+ int llength = list.length;
+ int index = llength;
+ for (int i = 0; i < llength; i++) {
+ int val = list[i];
+ if (val == 0) {
+ // only update our target index if we haven't already
+ // found a spot to put the value
+ if (index == llength) {
+ index = i;
+ }
+
+ } else if (val == value) {
+ // oops, it's already in the list
+ return null;
+ }
+ }
+
+ // expand the list if necessary
+ if (index >= list.length) {
+ list = accomodate(list, index);
+ }
+
+ // stick the value on in
+ list[index] = value;
+
+ return list;
+ }
+
+ /**
+ * Looks for an element that is equal to the supplied value. Passing a
+ * zero value to this function will cleverly tell you
+ * whether or not there are any empty elements in the array which is
+ * probably not very useful.
+ *
+ * @return true if a matching value was found, false otherwise.
+ */
+ public static boolean contains (int[] list, int value)
+ {
+ int llength = list.length; // no optimizing bastards
+ for (int i = 0; i < llength; i++) {
+ if (list[i] == value) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Looks for an element that is equal to the supplied value and
+ * returns its index in the array. Passing a zero value
+ * to this function will cleverly tell you whether or not there are
+ * any empty elements in the array which is probably not very useful.
+ *
+ * @return the index of the first matching value if one was found,
+ * -1 otherwise.
+ */
+ public static int indexOf (int[] list, int value)
+ {
+ int llength = list.length; // no optimizing bastards
+ for (int i = 0; i < llength; i++) {
+ if (list[i] == value) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Clears out the first value that is equal to the supplied
+ * value. Passing a zero value to this function will
+ * cleverly tell you the index of the first empty element in the array
+ * which it will have kindly overwritten with zero just for good
+ * measure.
+ *
+ * @return the value that was removed or zero if it was not found.
+ */
+ public static int clear (int[] list, int value)
+ {
+ // nothing to clear from an empty list
+ if (list == null) {
+ return 0;
+ }
+
+ int llength = list.length; // no optimizing bastards
+ for (int i = 0; i < llength; i++) {
+ int val = list[i];
+ if (val == value) {
+ list[i] = 0;
+ return val;
+ }
+ }
+ return 0;
+ }
+
+ /**
+ * Removes the first value that is equal to the supplied value. The
+ * values after the removed value will be slid down the array one spot
+ * to fill the place of the removed value.
+ *
+ * @return the value that was removed from the array or zero if no
+ * matching object was found.
+ */
+ public static int remove (int[] list, int value)
+ {
+ // nothing to remove from an empty list
+ if (list == null) {
+ return 0;
+ }
+
+ int llength = list.length; // no optimizing bastards
+ for (int i = 0; i < llength; i++) {
+ int val = list[i];
+ if (val == value) {
+ System.arraycopy(list, i+1, list, i, llength-(i+1));
+ list[llength-1] = 0;
+ return val;
+ }
+ }
+ return 0;
+ }
+
+ /**
+ * Removes the value at the specified index. The values after the
+ * removed value will be slid down the array one spot to fill the
+ * place of the removed value. If a null array is supplied or one that
+ * is not large enough to accomodate this index, zero is returned.
+ *
+ * @return the value that was removed from the array or zero if no
+ * value existed at that location.
+ */
+ public static int removeAt (int[] list, int index)
+ {
+ int llength = list.length;
+ if (list == null || llength <= index) {
+ return 0;
+ }
+
+ int val = list[index];
+ System.arraycopy(list, index+1, list, index, llength-(index+1));
+ list[llength-1] = 0;
+ return val;
+ }
+
+ /**
+ * Creates a new list that will accomodate the specified index and
+ * copies the contents of the old list to the first.
+ */
+ protected static int[] accomodate (int[] list, int index)
+ {
+ int size = list.length;
+ // expand size by powers of two until we're big enough
+ while (size <= index) {
+ size *= 2;
+ }
+
+ // create a new list and copy the contents
+ int[] newlist = new int[size];
+ System.arraycopy(list, 0, newlist, 0, list.length);
+ return newlist;
+ }
+
+ /**
+ * The size of a list to create if we have to create one entirely
+ * from scratch rather than just expand it.
+ */
+ protected static final int DEFAULT_LIST_SIZE = 4;
+}
diff --git a/projects/samskivert/tests/src/java/com/samskivert/util/IntListUtilTest.java b/projects/samskivert/tests/src/java/com/samskivert/util/IntListUtilTest.java
new file mode 100644
index 00000000..40b3a304
--- /dev/null
+++ b/projects/samskivert/tests/src/java/com/samskivert/util/IntListUtilTest.java
@@ -0,0 +1,129 @@
+//
+// $Id: IntListUtilTest.java,v 1.1 2001/11/06 02:13:29 mdb Exp $
+//
+// samskivert library - useful routines for java programs
+// Copyright (C) 2001 Michael Bayne
+//
+// This library is free software; you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation; either version 2.1 of the License, or
+// (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+package com.samskivert.util;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+
+import com.samskivert.Log;
+import com.samskivert.test.TestUtil;
+
+public class IntListUtilTest extends TestCase
+{
+ public IntListUtilTest ()
+ {
+ super(IntListUtilTest.class.getName());
+ }
+
+ public void runTest ()
+ {
+ int[] list = null;
+
+ list = IntListUtil.add(list, 2);
+// System.out.println("add(2): " + StringUtil.toString(list));
+ assert("add(2)", arraysEqual(list, new int[] { 2, 0, 0, 0 }));
+
+ list = IntListUtil.add(list, 5);
+// System.out.println("add(5): " + StringUtil.toString(list));
+ assert("add(5)", arraysEqual(list, new int[] { 2, 5, 0, 0 }));
+
+ IntListUtil.clear(list, 2);
+// System.out.println("clear(2): " + StringUtil.toString(list));
+ assert("clear(2)", arraysEqual(list, new int[] { 0, 5, 0, 0 }));
+
+ boolean contains5 = IntListUtil.contains(list, 5);
+// System.out.println("contains(newBar): " + contains5);
+ assert("contains(5)", contains5);
+
+ IntListUtil.removeAt(list, 1);
+// System.out.println("removeAt(1): " + StringUtil.toString(list));
+ assert("removeAt(1)", arraysEqual(list, new int[] { 0, 0, 0, 0 }));
+
+ list = IntListUtil.add(list, 0, 2);
+ list = IntListUtil.add(list, 1, 5);
+// System.out.println("add(0, 2) + add(1, 5): " +
+// StringUtil.toString(list));
+ assert("add(0, 2) + add(1, 5))",
+ arraysEqual(list, new int[] { 2, 5, 0, 0 }));
+
+ IntListUtil.remove(list, 2);
+// System.out.println("remove(2): " + StringUtil.toString(list));
+ assert("removeAt(2)", arraysEqual(list, new int[] { 5, 0, 0, 0 }));
+
+ list = IntListUtil.add(list, 0, 2);
+ list = IntListUtil.add(list, 1, 5);
+ list = IntListUtil.add(list, 2, 6);
+// System.out.println("add(0, 2) + add(1, 5) + add(2, 6): " +
+// StringUtil.toString(list));
+ assert("add(0, 2) + add(1, 5) + add(2, 6)",
+ arraysEqual(list, new int[] { 5, 2, 5, 6 }));
+
+ IntListUtil.removeAt(list, 0);
+// System.out.println("removeAt(0): " + StringUtil.toString(list));
+ assert("removeAt(0)", arraysEqual(list, new int[] { 2, 5, 6, 0 }));
+
+ int[] tl = IntListUtil.testAndAdd(list, 5);
+// if (tl == null) {
+// System.out.println("testAndAdd(5): failed: " +
+// StringUtil.toString(list));
+// } else {
+// list = tl;
+// System.out.println("testAndAdd(5): added: " +
+// StringUtil.toString(list));
+// }
+ assert("testAndAdd(5)", tl == null);
+
+ tl = IntListUtil.testAndAdd(list, 7);
+// if (tl == null) {
+// System.out.println("testAndAdd(7): failed: " +
+// StringUtil.toString(list));
+// } else {
+// list = tl;
+// System.out.println("testAndAdd(7): added: " +
+// StringUtil.toString(list));
+// }
+ assert("testAndAdd(7)", tl != null);
+
+ IntListUtil.removeAt(list, 0);
+// System.out.println("removeAt(0): " + StringUtil.toString(list));
+ assert("removeAt(0)", arraysEqual(list, new int[] { 5, 6, 7, 0 }));
+ }
+
+ protected boolean arraysEqual (int[] a1, int[] a2)
+ {
+ if (a1.length != a2.length) {
+ return false;
+ }
+
+ for (int i = 0; i < a1.length; i++) {
+ if (a1[i] != a2[i]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public static Test suite ()
+ {
+ return new IntListUtilTest();
+ }
+}