ordenado - recorrer hashmap java foreach

Seleccionar conjuntos aleatorios de claves y valores de un mapa en Java

Question

Quiero obtener claves aleatorias y sus respectivos valores de un Mapa. La idea es que un generador aleatorio escogería una clave y mostraría ese valor. La parte difícil es que tanto la clave como el valor serán cadenas, por ejemplo myMap.put("Geddy", "Lee") .

Answer 1

Copiaría el mapa en una matriz y seleccionaría la entrada que desee al azar. Esto evita la necesidad de buscar también el valor de la clave.

Map<String, String> x = new HashMap<String, String>();
Map.Entry<String,String>[] entries = x.entrySet().toArray(new Map.Entry[0]);
Random rand = new Random();

// call repeatedly
Map.Entry<String, String> keyValue = entries[rand.nextInt(entries.length)];

Si desea evitar la duplicación, puede aleatorizar el orden de las entradas

Map<String, String> x = new HashMap<String, String>();
List<Map.Entry<String,String>> entries = new ArrayList<Map.Entry<String, String>> (x.entrySet());
Collections.shuffle(entries);
for (Map.Entry<String, String> entry : entries) {
    System.out.println(entry);
}

Answer 2

Esta pregunta debería ser de ayuda para usted ¿Hay alguna manera de obtener el valor de un HashMap aleatoriamente en Java? y este también seleccionando un elemento aleatorio de un conjunto porque HashMap está respaldado por un HashSet . Sería O(n) tiempo y espacio constante o sería O(n) espacio extra y tiempo constante.

Answer 3

Ha pasado un tiempo desde que se jugó con Java, pero KeySet () no le da una lista que puede seleccionar utilizando un índice numérico. Creo que podría elegir un número aleatorio y seleccionarlo de keySet of myMap, luego seleccionar el valor correspondiente de myMap. No puedo probar esto ahora, pero parece que me parece posible.

Answer 4

Si no te importa el espacio desperdiciado, un enfoque sería guardar por separado una List de todas las claves que están en el Map . Para obtener el mejor rendimiento, querrá una List que tenga un buen rendimiento de acceso aleatorio (como una ArrayList ). Luego, simplemente obtenga un número aleatorio entre 0 (inclusive) y list.size() (exclusivo), extraiga la clave de ese índice y busque esa clave.

Random rand = something
int randIndex = rand.nextInt(list.size());
K key = list.get(randIndex);
V value = map.get(key);

Este enfoque también significa que agregar un par clave-valor es mucho más barato que eliminar uno. Para agregar el par de clave-valor, debería probar para ver si la clave ya está en el mapa (si sus valores pueden ser nulos, deberá llamar por separado a map.containsKey ; de lo contrario, puede agregar la clave- par de valores y ver si el "valor anterior" que devuelve es null) . Si la clave ya está en el mapa, la lista no se modifica, pero si no, agrega la clave a la lista (una operación O (1) para la mayoría de las listas). Sin embargo, eliminar un par de clave-valor implica una operación O (N) para eliminar la clave de la lista.

Si el espacio es una gran preocupación, pero el rendimiento es menor, también puede obtener un Iterator sobre el conjunto de entrada del mapa ( Map.entrySet() ) y omitir randIndex entradas de randIndex antes de devolver el que desea. Pero eso sería una operación de O (N), que un poco derrota el punto entero de un mapa.

Finalmente, puede obtener el conjunto de entrada en toArray() e indexar aleatoriamente eso. Eso es más simple, aunque menos eficiente.

Answer 5

Utilice el muestreo de yacimientos para seleccionar una lista de claves aleatorias, luego insértelas en un mapa (junto con sus valores correspondientes en el mapa fuente).

De esta forma, no es necesario copiar todo el conjunto de keySet en una matriz, solo las teclas seleccionadas.

public static <K, V>Map<K, V> sampleFromMap(Map<? extends K, ? extends V> source, int n, Random rnd) {
    List<K> chosenKeys = new ArrayList<K>();
    int count = 0;
    for (K k: source.keySet()) {
        if (count++ < n) {
            chosenKeys.add(k);
            if (count == n) {
                Collections.shuffle(chosenKeys, rnd);
            }
        } else {
            int pos = rnd.nextInt(count);
            if (pos < n) {
                chosenKeys.set(pos, k);
            }
        }
    }
    Map<K, V> result = new HashMap<K, V>();
    for (K k: chosenKeys) {
        result.put(k, source.get(k));
    }
    return Collections.unmodifiableMap(result);
}

Answer 6

si sus claves son un número entero, o algo similar, puede usar TreeMap para hacer eso.

TreeMap<Integer, Integer> treeMap = new TreeMap<>();
int key = RandomUtils.ranInt(treeMap.lastKey());
int value = treeMap.ceilingKey(key);

Answer 7

HashMap<String, String> x;

Random       random    = new Random();
List<String> keys      = new ArrayList<String>(x.keySet());
String       randomKey = keys.get( random.nextInt(keys.size()) );
String       value     = x.get(randomKey);

Answer 8

In some cases you might want to preserve an order you put the elements in the Set,
In such scenario you can use, This 

Set<Integer> alldocsId = new HashSet<>();
            for (int i=0;i<normalized.length;i++)
            {
                String sql = "SELECT DISTINCT movieID FROM postingtbl WHERE term=?";
                PreparedStatement prepstm = conn.prepareStatement(sql);
                prepstm.setString(1,normalized[i]);
                ResultSet rs = prepstm.executeQuery();
                while (rs.next())
                {
                    alldocsId.add(rs.getInt("MovieID"));
                }
                prepstm.close();
            }

        List<Integer> alldocIDlst = new ArrayList<>();
        Iterator it = alldocsId.iterator();
        while (it.hasNext())
        {
            alldocIDlst.add(Integer.valueOf(it.next().toString()));
        }