cómo convertir un objeto dict python a un objeto equivalente java?

Question

Necesito convertir un código python en un código java equivalente. Python hace la vida muy fácil para los desarrolladores al proporcionar muchas funcionalidades de acceso directo. Pero ahora necesito migrar lo mismo a Java. Me preguntaba ¿cuál sería el equivalente de objetos dict en java? He intentado usar HashMap, pero la vida es un infierno. Para empezar, considere esto,

# Nodes is a dictionary -> Key : (Name, Strength) 
for node, (name, strength) in nodes.items(): 
    nodes[node] = (name, new_strength) 

Entonces, ¿cómo hacer para convertir esto en Java? Para empezar he usado HashMap objeto así,

Map<Integer, List> nodesMap = new HashMap<Integer,List>(); 
/* For iterating over the map */ 
Iterator updateNodeStrengthIterator = nodesMap.entrySet().iterator(); 
while(updateNodeStrengthIterator.hasNext()){ }  

Mi problema está en conseguir el papel de lista que contiene Nombre & Fuerza & continuación, la actualización de la parte de la fuerza. ¿Hay alguna manera factible de hacer esto? ¿Debo considerar alguna estructura de datos diferente? Por favor ayuda.

Answer 1

Es probable que sea más fácil de simplemente crear una clase para el (nombre, concentración) tupla:

class NameStrength { 
    public String name; 
    public String strength; 
} 

Añadir captadores, incubadoras y una constructor si es apropiado.

continuación, puede utilizar la nueva clase en su mapa:

Map<Integer, NameStrength> nodesMap = new HashMap<Integer, NameStrength>(); 

En Java 5 y arriba, se pueden repetir como esto:

for (NameStrength nameStrength : nodesMap.values()) {} 

o como esto:

for (Entry<Integer, NameStrength> entry : nodesMap.entrySet()) {} 

Answer 2

Java no tiene el equivalente de una tupla incorporada. Tendría que crear una clase que encapsulara los dos juntos para imitarlo.

Answer 3

bien siempre hay jython. aquí hay un poco de this article que ofrece un buen lado a vista lateral del pitón/java

Los análogos de Jython a clases de colección de Java son mucho más estrechamente integrado en el núcleo del lenguaje , lo que permite más concisa descripciones y funcionalidad útil. Por ejemplo, observe la diferencia entre el código Java:

map = new HashMap(); 
map.put("one",new Integer(1)); 
map.put("two",new Integer(2)); 
map.put("three",new Integer(3)); 

System.out.println(map.get("one")); 

list = new LinkedList(); 
list.add(new Integer(1)); 
list.add(new Integer(2)); 
list.add(new Integer(3)); 

y el código Jython:

map = {"one":1,"two":2,"three":3} 
print map ["one"] 
list = [1, 2, 3] 

---

edit: lo que está mal con sólo el uso de put() para reemplazar los valores ?

map.put(key,new_value); 

aquí es un pequeño programa de ejemplo:

static public void main(String[] args){ 
    HashMap<String,Integer> map = new HashMap<String,Integer>(); 
    //name, age 
    map.put("billy", 21); 
    map.put("bobby", 19); 
    year(map); 
    for(String i: map.keySet()){ 
     System.out.println(i+ " " + map.get(i).toString()); 
    } 
} 
// a year has passed 
static void year(HashMap<String,Integer> m){ 
    for(String k: m.keySet()){ 
     m.put(k, m.get(k)+1); 
    } 
}