Java: get Object values from Hashtable<Integer,Hashtable<String,Object>>

Question

I have coded some object properties in a Hashtable<Integer,Hashtable<String,Object>> , where:

• Integer is the key for the primary Hashtable (representing the object number)
• Every Hashtable<String,Object> represents respectively the property name (String) and the property value(Object) .

I would like to put all properties values into an ArrayList (or array...) containing the values of the properties, and then would like to access every Object . How can I do this?

Answer 1

if you want only a list for this purpose the Maxim's solutions is very good or you can create a custom class that implements collection and internally manage hashtable & objects. I like the second way if you need to use this in many points of your program.

for example you can modify this class and add as Element T the custom class that have all proprerties and hastable linked to a string key, and in this class add a custo mmethod for search throught key name (excuse for my english):

  public class NList<T> implements Iterable<T> //, List<T>
  {
     private boolean synchron;
     public List<T>  list;

     public NList(boolean synchron)
     {
        this(15, synchron);
     }

     public NList(int initialCapacity, boolean synchron)
     {
        this.synchron = synchron;
        this.list = synchron ? new Vector<T>(initialCapacity) : new ArrayList<T>(initialCapacity);
     }

     public NList(Collection<T> c, boolean synchron)
     {
        this.synchron = synchron;
        this.list = synchron ? new Vector<T>(c) : new ArrayList<T>(c);
     }

     public final boolean isSynchronized()
     {
        return synchron;
     }

     //@Override
     public final boolean add(T element)
     {
        return list.add(element);
     }

     //@Override
     public final void add(int index, T element)
     {
        list.add(index, element);
     }

     //@Override
     public final T remove(int index)
     {
        return list.remove(index);
     }

     //@Override
     public final List<T> subList(int fromIndex, int toIndex)
     {
        return list.subList(fromIndex, toIndex);
     }

     //@Override
     @SuppressWarnings("unchecked")
     public final T[] toArray()
     {
        return (T[])list.toArray();
     }

     //@Override
     public final T get(int index)
     {
        return list.get(index);
     }

     //@Override
     public final int size()
     {
        return list.size();
     }

     //@Override
     public final boolean isEmpty()
     {
        return list.isEmpty();
     }

     //@Override
     public final void clear()
     {
        list.clear();
     }

     @Override
     public final Iterator<T> iterator()
     {
        return list.iterator();
     }

     //@Override
     public final boolean contains(Object element)
     {
        return list.contains(element);
     }

     //@Override
     @SuppressWarnings("hiding")
     public final <T> T[] toArray(T[] a)
     {
        return list.toArray(a);
     }

     //@Override
     public final boolean remove(Object element)
     {
        return list.remove(element);
     }

     //@Override
     public final boolean containsAll(Collection<?> c)
     {
        return list.containsAll(c);
     }

     //@Override
     public final boolean addAll(Collection<? extends T> c)
     {
        return list.addAll(c);
     }

     //@Override
     public final boolean addAll(int index, Collection<? extends T> c)
     {
        return list.addAll(index, c);
     }

     //@Override
     public final boolean removeAll(Collection<?> c)
     {
        return list.removeAll(c);
     }

     //@Override
     public final boolean retainAll(Collection<?> c)
     {
        return list.retainAll(c);
     }

     //@Override
     public final T set(int index, T element)
     {
        return list.set(index, element);
     }

     //@Override
     public final int indexOf(Object o)
     {
        return list.indexOf(o);
     }

     //@Override
     public final int lastIndexOf(Object o)
     {
        return list.lastIndexOf(o);
     }

     //@Override
     public final ListIterator<T> listIterator()
     {
        return list.listIterator();
     }

     //@Override
     public final ListIterator<T> listIterator(int index)
     {
        return list.listIterator(index);
     }
  }

Answer 2

Something like this:

List<HashTable<Integer,Object>> list = new ArrayList<HashTable<Integer,Object>>();

for order use LinkedHashTable .

And this is how can you access HashTable :

Hashtable<Integer, Hashtable<String, Object>> properties = new Hashtable<Integer, Hashtable<String, Object>>(); 

    Enumeration<Integer> nmExt;
    Enumeration<String> nmInt;

    Hashtable<String, Object> innerHash;
    int externalKey;
    String interanlKey;
    Object obj;

    nmExt = properties.keys();

       while (nmExt.hasMoreElements()){
           externalKey = nmExt.nextElement();

           innerHash =  properties.get(externalKey);

           nmInt = innerHash.keys();

           while (nmExt.hasMoreElements()){
               interanlKey = nmInt.nextElement();

               obj = innerHash.get(interanlKey);

               // .....
           }

        }