Last Update February 20, 2000

Java Programming Tip #1, AS/400 Timestamps in Java.

Java Programming Tip #2, KeyedList Java data structure.

This KeyedList class is a useful cross between the Java Vector and Hashtable classes.

Java Vectors are data structures with elements that are accessable by index number and maintain element order. Java Hashtables are data structures with elements accessable by a java.lang.Object key (the key is often java.lang.String). All Hashtable elements may be obtained as an Enumeration but without a known order.

The source code below is for a KeyedList object. This object is an array of java.lang.Object accessable both by a java.lang.String key and by a numeric index. Order is maintained in the list and new elements may be added to the end of the list or inserted at any point. Unique keys are not enforced but you may easily add that feature. The keys are Strings so getKeys() returns a String array. No need for an enumeration of the elements just work through them by index. You determine suitability for your use, many variations are possible. More error trapping possible.

public class KeyedList
{
    private Object[] objects = new Object[0];
    private String[] keys = new String[0];

    public KeyedList()
    {
        super(); // just a reminder
    }

    public int size()
    {
        return keys.length; // how many elements
    }

    public String[] getKeys()
    {
        return keys; // all the keys, in order 0 - n
    }

    public String getKey( int index )
    {
        return keys[index]; // get key for index
    }

    public Object getListItem( int index )
    {
        return objects[index]; // get element by index
    }

    public Object getListItem( String key ) // get element by key
    {
        int x = getIndex( key );
        if ( x < 0 )
        {
            return null;
        }
        else
        {
            return objects[x];
        }
    }

    public void changeListItem( int index, Object item )
    {
        objects[ index ] = item;  // replace an element by index
    }

    public void changeListItem( String key, Object item )
    {
        objects[ getIndex( key ) ] = item;  // replace an element by key
    }

    public void deleteListItem( String key ) // remove an element by key
    {
        int index = getIndex( key );
        deleteListItem( index );
    }

    public void deleteListItem( int index ) // remove an element by index
    {
        Object[] tempObjects = new Object[ objects.length - 1 ];
        String[] tempKeys = new String[ keys.length - 1 ];
        int y = 0;
        for ( int x = 0; x < objects.length; x++ )
        {
            if ( x != index )
            {
                tempObjects[y] = objects[x];
                tempKeys[y] = keys[x];
                y++;
            }
        }
        objects = tempObjects;
        keys = tempKeys;
    }

    public void addListItem( String key, Object item )  // adds element to end of list
    {
        if ( keys.length == 0 )          // keep it simple for startup
        {
            addFirstItem( key, item );
        }
        else
        {
            Object[] tempObjects = new Object[ objects.length + 1 ];
            String[] tempKeys = new String[ keys.length + 1 ];

            System.arraycopy( objects, 0, tempObjects, 0, objects.length );
            System.arraycopy( keys, 0, tempKeys, 0, keys.length );

            tempObjects[ tempObjects.length - 1 ] = item;
            tempKeys[ tempKeys.length - 1 ] = key;

            objects = tempObjects;
            keys = tempKeys;
        }
    }

    // adds an element at index, others jog down
    public void insertListItem( int index, String key, Object item )
    {
        if ( keys.length == 0 )          // keep it simple for startup
        {
            addFirstItem( key, item );
        }
        else
        {
            Object[] tempObjects = new Object[ objects.length + 1 ];
            String[] tempKeys = new String[ keys.length + 1 ];
            System.arraycopy( objects, 0, tempObjects, 0, index );
            tempObjects[ index ] = item;
            System.arraycopy( objects, index, tempObjects, index + 1, tempObjects.length );

            System.arraycopy( keys, 0, tempKeys, 0, index );
            tempKeys[ index ] = key;
            System.arraycopy( keys, index, tempKeys, index + 1, tempKeys.length );

            objects = tempObjects;
            keys = tempKeys;
        }
    }

    private void addFirstItem( String key, Object item ) // get started
    {
        objects = new Object[1];
        keys = new String[1];
        keys[0] = key;
        objects[0] = item;
    }

    private int getIndex( String key ) // could be public
    {
         for ( int x = 0; x < keys.length; x++ )
         {
             if ( keys[x].equals( key ) )
             {
                  return x;
             }
         }
         return -1;
    }
}

South Fork Software would like to put this experience to work for you.
507 875 2428
72640.2025@compuserve.com
fpvw@sfsw.com

Mail to: South Fork Software