Java: получить значение объектов из Hashtable <Integer, Hashtable <String, Object >>

Question

Я закодированном некоторые свойства объекта в Hashtable<Integer,Hashtable<String,Object>>, где:

• Integer является ключом для первичного Hashtable (представляющего объект номер)
• Каждые Hashtable<String,Object> соответственно представляют собой имущество name (String) и имущество value(Object).

Я хотел бы поставить все свойства значения в ArrayList (или массив ...), содержащий значения свойств, а затем хотел бы получить доступ к каждому Object. Как я могу это сделать?

Answer 1

Что-то вроде этого:

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

для заказа LinkedHashTable.

И это, как вы можете получить доступ к 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); 

       // ..... 
      } 

     } 

Answer 2

если вы хотите только список для этого решения, предложенного Максима очень хорошо, или вы можете создать собственный класс, который реализует коллекцию и внутренне управлять Хеш & объекты. Мне нравится второй способ, если вам нужно использовать это во многих точках вашей программы.

например, вы можете изменить этот класс и добавить в качестве элемента T пользовательский класс, который имеет все proprerties и hastable, связанный с строковым ключом, и в этом классе добавьте custo mmethod для поиска по ключевому имени (извините за мой английский) :

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); 
    } 
    }