È possibile ottenere l'elemento da HashMap dalla sua posizione?

Question

Come recuperare un elemento da HashMap in base alla sua posizione, è possibile a tutti?

Answer 1

HashMaps non custodiamo ordinazione:

Questa classe non rilascia alcuna garanzia da l'ordine della mappa; in particolare, non garantisce che l'ordine rimanga costante nel tempo.

Dai uno sguardo allo LinkedHashMap, che garantisce un ordine di iterazione prevedibile.

Answer 2

Uso LinkedHashMap:

tabella di hash e lista collegata implementazione dell'interfaccia Map, con ordine di iterazione prevedibile. Questa implementazione differisce da HashMap in quanto mantiene una lista doppiamente collegata che attraversa tutte le sue voci.

Answer 3

HashMap - e la struttura dati sottostante - tabelle hash, non hanno una nozione di posizione. A differenza di LinkedList o Vector, la chiave di input viene trasformata in un 'bucket' in cui è memorizzato il valore. Questi bucket non sono ordinati in un modo che ha senso al di fuori dell'interfaccia di HashMap e, in quanto tali, gli elementi inseriti in HashMap non sono in ordine, nel senso che ci si aspetterebbe con le altre strutture dati

Answer 4

HashMap non ha alcun concetto di posizione quindi non c'è modo di ottenere un oggetto in base alla posizione. Gli oggetti in Maps sono impostati e ottengono le chiavi.

Answer 5

Suppongo che per "posizione" ci si riferisca all'ordine in cui sono stati inseriti gli elementi in HashMap. In tal caso, si desidera utilizzare una LinkedHashMap. La LinkedHashMap non offre tuttavia un metodo di accesso; avrete bisogno di scrivere uno come

public Object getElementAt(LinkedHashMap map, int index) { 
    for (Map.Entry entry : map.entrySet()) { 
     if (index-- == 0) { 
      return entry.value(); 
     } 
    } 
    return null; 
} 

Answer 6

HashMaps non consentono l'accesso in base alla posizione, si conosce solo il codice hash e ed è possibile recuperare il valore se si può calcolare il codice hash della chiave. TreeMaps ha una nozione di ordine. Le mappe Linkedhas preservano l'ordine in cui sono state inserite nella mappa.

Answer 7

Utilizzare una LinkedHashMap e quando è necessario il recupero per posizione, convertire i valori in ArrayList.

LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<String,String>(); 
/* Populate */ 
linkedHashMap.put("key0","value0"); 
linkedHashMap.put("key1","value1"); 
linkedHashMap.put("key2","value2"); 
/* Get by position */ 
int pos = 1; 
String value = (new ArrayList<String>(linkedHashMap.values())).get(pos); 

Answer 8

Utilizzare LinkedHashMap e utilizzare questa funzione.

private LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>(); 

Definire in questo modo e.

private Entry getEntry(int id){ 
     Iterator iterator = map.entrySet().iterator(); 
     int n = 0; 
     while(iterator.hasNext()){ 
      Entry entry = (Entry) iterator.next(); 
      if(n == id){ 
       return entry; 
      } 
      n ++; 
     } 
     return null; 
    } 

La funzione può restituire la voce selezionata.

Answer 9

Se si desidera mantenere l'ordine in cui sono stati aggiunti gli elementi alla mappa, utilizzare LinkedHashMap anziché HashMap.

Ecco un approccio che permetterà di ottenere un valore dal suo indice nella mappa:

public Object getElementByIndex(LinkedHashMap map,int index){ 
    return map.get((map.keySet().toArray())[ index ]); 
} 

Answer 10

Si può cercare di implementare qualcosa di simile, guarda:

Map<String, Integer> map = new LinkedHashMap<String, Integer>(); 
map.put("juan", 2); 
map.put("pedro", 3); 
map.put("pablo", 5); 
map.put("iphoncio",9) 

List<String> indexes = new ArrayList<String>(map.keySet()); // <== Parse 

System.out.println(indexes.indexOf("juan"));  // ==> 0 
System.out.println(indexes.indexOf("iphoncio"));  // ==> 3 

I spero che questo funzioni per te

Answer 11

Un altro approccio di lavoro è la trasformazione dei valori della mappa in una matrice e quindi il recupero dell'elemento all'indice. TEST DEL 100 000 elemento da ricerche di indice in LinkedHashMap di 100 000 oggetti utilizzando approcci seguenti ha portato alla seguenti risultati:

//My answer: 
public Particle getElementByIndex(LinkedHashMap<Point, Particle> map,int index){ 
    return map.values().toArray(new Particle[map.values().size()])[index]; 
} //68 965 ms 

//Syd Lambert's answer: 
public Particle getElementByIndex(LinkedHashMap<Point, Particle> map,int index){ 
    return map.get((map.keySet().toArray())[ index ]); 
} //80 700 ms 

Tutto sommato elemento recupero da indice da LinkedHashMap sembra essere un'operazione piuttosto pesante.

Answer 12

Se, per qualche ragione, dovete attaccare con il HashMap, è possibile convertire il set di tasti per un array e indice le chiavi nella matrice per ottenere i valori nella mappa in questo modo:

Object[] keys = map.keySet().toArray(); 

È quindi possibile accedere alla mappa come:

map.get(keys[i]);