java - ordenado - cómo obtener la entrada de hashmap sin iterar

recorrer hashmap java foreach

Question

¿Existe una forma elegante de obtener solo una Entry<K,V> de HashMap, sin iterar, si la clave no se conoce?

Como el orden de entrada no es importante, podemos decir algo como

hashMapObject.get(zeroth_index);

Aunque soy consciente de que no existe tal método de obtener por índice.

Si probé el enfoque mencionado a continuación, todavía tendría que obtener todo el conjunto de entrada del hashmap .

for(Map.Entry<String, String> entry : MapObj.entrySet()) {
    return entry;
}

Sugerencias son bienvenidas.

EDITAR: sugiera cualquier otra estructura de datos para un requisito suficiente.

Answer 1

¿Por qué quiere evitar llamar a entrySet() generalmente no crea un objeto completamente nuevo con su propio contexto, sino que solo proporciona un objeto de fachada. Simplemente hablando, entrySet() es una operación bastante barata.

Answer 2

¿Qué quieres decir con "sin iterar"?

Puede usar map.entrySet().iterator().next() y no puede iterar a través del mapa (en el sentido de "tocar cada objeto"). Sin embargo, no puede obtener una Entry<K, V> sin usar un iterador. El Javadoc de Map.Entry dice:

El método Map.entrySet devuelve una vista de colección del mapa, cuyos elementos son de esta clase. La única forma de obtener una referencia a una entrada de mapa es desde el iterador de esta vista de colección. Estos objetos Map.Entry son válidos solo durante la iteración.

¿Puedes explicar con más detalle qué estás tratando de lograr? Si quiere manejar objetos primero, que coincidan con un criterio específico (como "tener una clave particular") y recurrir a los objetos restantes de lo contrario, entonces busque en PriorityQueue . Ordenará sus objetos según el orden natural o un Comparator que proporcione.

Answer 3

Después de su EDIT, esta es mi sugerencia:

Si solo tiene una entrada, puede reemplazar el Mapa por un objeto dual. Dependiendo de los tipos y sus preferencias:

• una matriz (de 2 valores, clave y valor)
• un objeto simple con dos propiedades

Answer 4

Esto obtendría una sola entrada del mapa, que casi tan cerca como se puede obtener, dado que ''primero'' no se aplica realmente.

import java.util.*;

public class Friday {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();

        map.put("code", 10);
        map.put("to", 11);
        map.put("joy", 12);

        if (! map.isEmpty()) {
            Map.Entry<String, Integer> entry = map.entrySet().iterator().next();
            System.out.println(entry);
        }
    }
}

Answer 5

La respuesta de Jesper es buena. Otra solución es usar TreeMap (solicitó otras estructuras de datos).

TreeMap<String, String> myMap = new TreeMap<String, String>();
String first = myMap.firstEntry().getValue();
String firstOther = myMap.get(myMap.firstKey());

TreeMap tiene una sobrecarga, por lo que HashMap es más rápido, pero solo como un ejemplo de una solución alternativa.

Answer 6

Los mapas no están ordenados, por lo que no existe la ''primera entrada'', y esa es también la razón por la cual no hay un método get-by-index en Map (o HashMap ).

Podrías hacer esto:

Map<String, String> map = ...;  // wherever you get this from

// Get the first entry that the iterator returns
Map.Entry<String, String> entry = map.entrySet().iterator().next();

(Nota: Verificar si se omite un mapa vacío).

Su código no obtiene todas las entradas en el mapa, regresa inmediatamente (y sale del bucle) con la primera entrada que se encuentra.

Para imprimir la clave y el valor de este primer elemento:

System.out.println("Key: "+entry.getKey()+", Value: "+entry.getValue());

Nota: Llamar a iterator() no significa que estés iterando sobre todo el mapa.

Answer 7

Obtenga valores, conviértalos en una matriz, obtenga el primer elemento de la matriz:

map.values().toArray()[0]

W.

Answer 8

Obtuve la respuesta: (Es simple)

Toma una ArrayList, luego muévela y encuentra el tamaño de la lista de arrays. Aquí está :

    ArrayList count = new ArrayList();
    count=(ArrayList) maptabcolname.get("k1"); //here "k1" is Key
    System.out.println("number of elements="+count.size());

Mostrará el tamaño. (Dar sugerencia). Esta funcionando.

Answer 9

Si está utilizando Java 8, es tan simple como findFirst() :

Ejemplo rápido:

Optional<Car> theCarFoundOpt = carMap.values().stream().findFirst();

if(theCarFoundOpt.isPresent()) {
    return theCarFoundOpt.get().startEngine();
}

Answer 10

Si realmente desea la API que sugirió, puede crear una subclase HashMap y realizar un seguimiento de las claves en una lista, por ejemplo. No veo el punto en esto realmente, pero te da lo que quieres. Si explica el caso de uso previsto, tal vez podamos encontrar una mejor solución.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SuppressWarnings("unchecked")
public class IndexedMap extends HashMap {

    private List<Object> keyIndex;

    public IndexedMap() {
        keyIndex = new ArrayList<Object>();
    }

    /**
     * Returns the key at the specified position in this Map''s keyIndex.
     * 
     * @param index
     *            index of the element to return
     * @return the element at the specified position in this list
     * @throws IndexOutOfBoundsException
     *             if the index is out of range (index < 0 || index >= size())
     */
    public Object get(int index) {
        return keyIndex.get(index);
    }

    @Override
    public Object put(Object key, Object value) {

        addKeyToIndex(key);
        return super.put(key, value);
    }

    @Override
    public void putAll(Map source) {

        for (Object key : source.keySet()) {
            addKeyToIndex(key);
        }
        super.putAll(source);
    }

    private void addKeyToIndex(Object key) {

        if (!keyIndex.contains(key)) {
            keyIndex.add(key);
        }
    }

    @Override
    public Object remove(Object key) {

        keyIndex.remove(key);
        return super.remove(key);
    }
}

EDITAR: deliberadamente no profundicé en el lado genérico de esto ...

Answer 11

Supongo que el iterador puede ser la solución más simple.

return hashMapObject.entrySet().iterator().next();

Otra solución (no bonita):

return new ArrayList(hashMapObject.entrySet()).get(0);

O aún (no mejor):

return hashMapObject.entrySet().toArray()[0];

Answer 12

Tropecé aquí buscando lo mismo ... Entonces recordé la clase Iterables de la biblioteca de Guava .

Para obtener el "primer" elemento: Iterables.getFirst( someMap.values(), null ); .
Básicamente hace lo mismo que Map.values().iterator().next() , pero también le permite especificar un valor predeterminado (en este caso nulo) si no hubiera nada en el mapa.

Iterables.getLast( someMap.values(), null ); devuelve el último elemento en el mapa.

Iterables.get( someMap.values(), 7, null ); devuelve el 7mo elemento en el Mapa si existe, de lo contrario un valor predeterminado (en este caso nulo).

Sin embargo, recuerde que los HashMaps no están ordenados ... así que no espere que Iterables.getFirst devuelva el primer elemento que arrojó allí ... del mismo modo con Iterables.getLast . Sin embargo, quizás sea útil para obtener un valor mapeado.

Puede que no valga la pena agregar la biblioteca de Guava por eso, pero si está utilizando alguna de las otras utilidades geniales dentro de esa biblioteca ...

Answer 13

import java.util.*;

public class Friday {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();

        map.put("code", 10);
        map.put("to", 11);
        map.put("joy", 12);

        if (! map.isEmpty()) {
            Map.Entry<String, Integer> entry = map.entrySet().iterator().next();
            System.out.println(entry);
        }
    }
}

Este enfoque no funciona porque usaste HashMap. Supongo que usar LinkedHashMap será la solución correcta en este caso.