ordenado - mapping en java

HashMap con múltiples valores bajo la misma clave

Question

¿Es posible para nosotros implementar un HashMap con una clave y dos valores? ¿Así como HashMap?

Por favor, ayúdenme, también diciéndole (si no hay forma) alguna otra forma de implementar el almacenamiento de tres valores con uno como clave.

Answer 1

Aquí está LA RESPUESTA:):)

String key = "services_servicename"

Datos de ArrayList;

for (int i = 0; i lessthen data.size (); i ++) {

 HashMap<String, String> servicesNameHashmap = new HashMap<String, String>();
servicesNameHashmap.put(key,data.get(i).getServiceName());
mServiceNameArray.add(i,servicesNameHashmap); }

Tengo los mejores resultados.

Solo tiene que crear un nuevo HashMap Me gusta

HashMap servicesNameHashmap = new HashMap ();

en Your For Loop. Tendrá el mismo efecto como la misma clave y múltiples valores.

Happy Coding :)

Answer 2

Eche un vistazo a Multimap de guava-libraries y su implementación - HashMultimap

Una colección similar a un Mapa, pero que puede asociar valores múltiples con una sola clave. Si llama put (K, V) dos veces, con la misma clave pero diferentes valores, el multimap contiene asignaciones de la clave para ambos valores.

Answer 3

Estoy tan acostumbrado a hacer esto con un diccionario de datos en Objective C. Era más difícil obtener un resultado similar en Java para Android. Terminé creando una clase personalizada, y luego simplemente haciendo un hashmap de mi clase personalizada.

public class Test1 {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.addview);
//create the datastring
HashMap<Integer, myClass> hm = new HashMap<Integer, myClass>();
hm.put(1, new myClass("Car", "Small", 3000));
hm.put(2, new myClass("Truck", "Large", 4000));
hm.put(3, new myClass("Motorcycle", "Small", 1000));
//pull the datastring back for a specific item.
//also can edit the data using the set methods. this just shows getting it for display.
myClass test1 = hm.get(1);
String testitem = test1.getItem();
int testprice = test1.getPrice();
Log.i("Class Info Example",testitem+Integer.toString(testprice));
}
}
//custom class. You could make it public to use on several activities, or just include in the activity if using only here
class myClass{
private String item;
private String type;
private int price;
public myClass(String itm, String ty, int pr){
this.item = itm;
this.price = pr;
this.type = ty;
}
public String getItem() {
return item;
}
public void setItem(String item) {
this.item = item;
}
public String getType() {
return item;
}
public void setType(String type) {
this.type = type;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
}

Answer 4

La forma más fácil sería usar una biblioteca de colecciones de google:

import com.google.common.collect.ArrayListMultimap; importar com.google.common.collect.Multimap;

clase pública Test {

public static void main(final String[] args) {
// multimap can handle one key with a list of values
final Multimap<String, String> cars = ArrayListMultimap.create();
cars.put("Nissan", "Qashqai");
cars.put("Nissan", "Juke");
cars.put("Bmw", "M3");
cars.put("Bmw", "330E");
cars.put("Bmw", "X6");
cars.put("Bmw", "X5");
cars.get("Bmw").forEach(System.out::println);
// It will print the:
// M3
// 330E
// X6
// X5
}

}

enlace maven: https://mvnrepository.com/artifact/com.google.collections/google-collections/1.0-rc2

más sobre esto: http://tomjefferys.blogspot.be/2011/09/multimaps-google-guava.html

Answer 5

No pude publicar una respuesta sobre el comentario de Paul, así que estoy creando un nuevo comentario para Vidhya aquí:

Wrapper será una SuperClass para las dos clases que queremos almacenar como valor.

y dentro de la clase contenedora, podemos poner las asociaciones como los objetos variables de instancia para los dos objetos de clase.

p.ej

class MyWrapper {
Class1 class1obj = new Class1();
Class2 class2obj = new Class2();
...
}

y en HashMap podemos ponerlo de esta manera,

Map<KeyObject, WrapperObject>

WrapperObj tendrá variables de clase: class1Obj, class2Obj

Answer 6

No, no solo como un HashMap . Básicamente necesitaría un HashMap desde una clave hasta una colección de valores.

Si está contento de utilizar bibliotecas externas, Guava tiene exactamente este concepto en Multimap con implementaciones como ArrayListMultimap y HashMultimap .

Answer 7

Otra buena opción es usar MultiValuedMap de Apache Commons. Eche un vistazo a las clases de implementación conocidas en la parte superior de la página para implementaciones especializadas.

Ejemplo:

HashMap<K, ArrayList<String>> map = new HashMap<K, ArrayList<String>>()

podría ser reemplazado con

MultiValuedMap<K, String> map = new MultiValuedHashMap<K, String>();

Asi que,

map.put(key, "A");
map.put(key, "B");
map.put(key, "C");
Collection<String> coll = map.get(key);

daría lugar a coll recopilación que contiene "A", "B" y "C".

Answer 8

Podemos crear una clase para tener múltiples claves o valores y el objeto de esta clase se puede usar como un parámetro en el mapa. Puede consultar https://.com/a/44181931/8065321

Answer 9

Prefiero lo siguiente para almacenar cualquier cantidad de variables sin tener que crear una clase separada.

final public static Map<String, Map<String, Float>> myMap = new HashMap<String, Map<String, Float>>();

Answer 10

Pruebe LinkedHashMap , muestra:

Map<String,String> map = new LinkedHashMap<String,String>();
map.put(''1'',''linked'');map.put(''1'',''hash'');
map.put(''2'',''map'');map.put(''3'',''java'');..

salida:

llaves: 1,1,2,3

valores: vinculado, hash, mapa, java

Answer 11

Puedes hacerlo implícitamente.

// Create the map. There is no restriction to the size that the array String can have
HashMap<Integer, String[]> map = new HashMap<Integer, String[]>();
//initialize a key chosing the array of String you want for your values
map.put(1, new String[] { "name1", "name2" });
//edit value of a key
map.get(1)[0] = "othername";

Esto es muy simple y efectivo. Si desea valores de diferentes clases en su lugar, puede hacer lo siguiente:

HashMap<Integer, Object[]> map = new HashMap<Integer, Object[]>();

Answer 12

Sí, esto se llama frecuentemente multimap .

Consulte: http://google-collections.googlecode.com/svn/trunk/javadoc/index.html?com/google/common/collect/Multimap.html

Answer 13

Se puede hacer usando un identificadorHashMap, sujeto a la condición de que la comparación de claves sea hecha por == operador y no igual ().

Answer 14

Si usa Spring Framework . Hay: org.springframework.util.MultiValueMap .

Para crear un mapa de valor múltiple no modificable:

Map<String,List<String>> map = ...
MultiValueMap<String, String> multiValueMap = CollectionUtils.toMultiValueMap(map);

O use org.springframework.util.LinkedMultiValueMap

Answer 15

Si y no. La solución es crear un clasificador Wrapper para sus valores que contenga los 2 (3 o más) valores que corresponden a su clave.

Answer 16

Solo para el registro, la solución JDK8 pura sería usar el método Map::compute :

map.compute(key, (s, strings) -> strings == null ? new ArrayList<>() : strings).add(value);

Como

public static void main(String[] args) {
Map<String, List<String>> map = new HashMap<>();
put(map, "first", "hello");
put(map, "first", "foo");
put(map, "bar", "foo");
put(map, "first", "hello");
map.forEach((s, strings) -> {
System.out.print(s + ": ");
System.out.println(strings.stream().collect(Collectors.joining(", ")));
});
}
private static <KEY, VALUE> void put(Map<KEY, List<VALUE>> map, KEY key, VALUE value) {
map.compute(key, (s, strings) -> strings == null ? new ArrayList<>() : strings).add(value);
}

con salida:

bar: foo
first: hello, foo, hello

Tenga en cuenta que para garantizar la coherencia en caso de que varios subprocesos accedan a esta estructura de datos, se debe utilizar ConcurrentHashMap y CopyOnWriteArrayList por ejemplo.

Answer 17

Tú podrías:

1. Use un mapa que tenga una lista como valor. Map<KeyType, List<ValueType>> .
2. Cree una nueva clase de contenedor y coloque instancias de este contenedor en el mapa. Map<KeyType, WrapperType> .
3. Usa una clase de tupla (ahorra creando muchos envoltorios). Map<KeyType, Tuple<Value1Type, Value2Type>> .
4. Usa varios mapas uno al lado del otro.

Ejemplos

1. Mapa con la lista como el valor

// create our map
Map<string, List<Person>> peopleByForename = new HashMap<string, List<Person>>();
// populate it
List<Person> people = new ArrayList<Person>();
people.add(new Person("Bob Smith"));
people.add(new Person("Bob Jones"));
peopleByForename.put("Bob", people);
// read from it
List<Person> bobs = peopleByForename["Bob"];
Person bob1 = bobs[0];
Person bob2 = bobs[1];

La desventaja de este enfoque es que la lista no está ligada exactamente a dos valores.

2. Usando la clase de contenedor

// define our wrapper
class Wrapper {
public Wrapper(Person person1, Person person2) {
this.person1 = person1;
this.person2 = person2;
}
public Person getPerson1 { return this.person1; }
public Person getPerson2 { return this.person2; }
private Person person1;
private Person person2;
}
// create our map
Map<string, Wrapper> peopleByForename = new HashMap<string, Wrapper>();
// populate it
Wrapper people = new Wrapper()
peopleByForename.put("Bob", new Wrapper(new Person("Bob Smith"),
new Person("Bob Jones"));
// read from it
Wrapper bobs = peopleByForename["Bob"];
Person bob1 = bobs.Person1;
Person bob2 = bobs.Person2;

La desventaja de este enfoque es que debe escribir mucho código de placa de caldera para todas estas clases de contenedores muy simples.

3. Usando una tupla

// you''ll have to write or download a Tuple class in Java, (.NET ships with one)
// create our map
Map<string, Tuple2<Person, Person> peopleByForename = new HashMap<string, Tuple2<Person, Person>>();
// populate it
peopleByForename.put("Bob", new Tuple2(new Person("Bob Smith",
new Person("Bob Jones"));
// read from it
Tuple<Person, Person> bobs = peopleByForename["Bob"];
Person bob1 = bobs.Item1;
Person bob2 = bobs.Item2;

Esta es la mejor solución en mi opinión.

4. Múltiples mapas

// create our maps
Map<string, Person> firstPersonByForename = new HashMap<string, Person>();
Map<string, Person> secondPersonByForename = new HashMap<string, Person>();
// populate them
firstPersonByForename.put("Bob", new Person("Bob Smith"));
secondPersonByForename.put("Bob", new Person("Bob Jones"));
// read from them
Person bob1 = firstPersonByForename["Bob"];
Person bob2 = secondPersonByForename["Bob"];

La desventaja de esta solución es que no es obvio que los dos mapas estén relacionados, un error programático podría hacer que los dos mapas no se sincronicen.

Answer 18

Uso Map<KeyType, Object[]> para asociar varios valores con una clave en un Map. De esta forma, puedo almacenar múltiples valores de diferentes tipos asociados con una clave. Debe tener cuidado al mantener el orden correcto de inserción y recuperación desde Object [].

Ejemplo: Considere, queremos almacenar información del Estudiante. La clave es id, mientras que nos gustaría almacenar el nombre, la dirección y el correo electrónico asociado al estudiante.

 //To make entry into Map
Map<Integer, String[]> studenMap = new HashMap<Integer, String[]>();
String[] studentInformationArray = new String[]{"name", "address", "email"};
int studenId = 1;
studenMap.put(studenId, studentInformationArray);
//To retrieve values from Map
String name = studenMap.get(studenId)[1];
String address = studenMap.get(studenId)[2];
String email = studenMap.get(studenId)[3];

Answer 19

HashMap<Integer,ArrayList<String>> map = new HashMap<Integer,ArrayList<String>>();
ArrayList<String> list = new ArrayList<String>();
list.add("abc");
list.add("xyz");
map.put(100,list);