HashMap com vários valores sob a mesma chave

É possível implementar um HashMap com uma chave e dois valores. Assim como o HashMap?

Por favor, me ajude, dizendo também (se não houver maneira) qualquer outra maneira de implementar o armazenamento de três valores com um como chave?

Você poderia:

1. Use um mapa que tenha uma lista como valor. Map<KeyType, List<ValueType>>.
2. Crie uma nova classe de wrapper e coloque instâncias desse wrapper no mapa. Map<KeyType, WrapperType>.
3. Use uma tupla como classe (economiza a criação de muitos wrappers). Map<KeyType, Tuple<Value1Type, Value2Type>>.
4. Use vários mapas lado a lado.

Exemplos

1. Mapa com lista como o valor

// create our map
Map<String, List<Person>> peopleByForename = new HashMap<>();    

// populate it
List<Person> people = new ArrayList<>();
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];

A desvantagem dessa abordagem é que a lista não está vinculada exatamente a dois valores.

2. Usando a classe wrapper

// 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<>();

// 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.get("Bob");
Person bob1 = bobs.getPerson1;
Person bob2 = bobs.getPerson2;

A desvantagem dessa abordagem é que você precisa escrever muito código da placa de caldeira para todas essas classes de contêineres muito simples.

3. Usando uma 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<>();

// 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 é a melhor solução na minha opinião.

4. Vários mapas

// create our maps
Map<String, Person> firstPersonByForename = new HashMap<>();
Map<String, Person> secondPersonByForename = new HashMap<>();

// 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"];

A desvantagem desta solução é que não é óbvio que os dois mapas estão relacionados; um erro programático pode fazer com que os dois mapas fiquem fora de sincronia.

Não, não apenas como HashMap. Você precisaria basicamente HashMapde uma chave para uma coleção de valores.

Se você gosta de usar bibliotecas externas, o Guava tem exatamente esse conceito em Multimapimplementações como ArrayListMultimape HashMultimap.

Outra boa opção é usar o MultiValuedMap do Apache Commons. Dê uma olhada nas Classes de implementação conhecidas na parte superior da página para implementações especializadas.

Exemplo:

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

poderia ser substituído por

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

Assim,

map.put(key, "A");
map.put(key, "B");
map.put(key, "C");

Collection<String> coll = map.get(key);

resultaria em uma coleção collcontendo "A", "B" e "C".

Dê uma olhada nas Multimapbibliotecas da goiaba e sua implementação -HashMultimap

Uma coleção semelhante a um mapa, mas que pode associar vários valores a uma única chave. Se você chamar put (K, V) duas vezes, com a mesma chave, mas com valores diferentes, o multimapa conterá mapeamentos da chave para os dois valores.

eu uso Map<KeyType, Object[]> para associar vários valores a uma chave em um mapa. Dessa forma, eu posso armazenar vários valores de diferentes tipos associados a uma chave. Você deve tomar cuidado, mantendo a ordem correta de inserção e recuperação de Object [].

Exemplo: considere, queremos armazenar informações do aluno. A chave é id, enquanto gostaríamos de armazenar o nome, endereço e e-mail associado ao aluno.

       //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];

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);

Apenas para constar, a solução JDK8 pura seria usar o Map::computemétodo:

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

Tal 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);
}

com saída:

bar: foo
first: hello, foo, hello

Observe que, para garantir consistência, caso vários threads acessem essa estrutura de dados ConcurrentHashMape , CopyOnWriteArrayListpor exemplo, precisem ser usados.

Se você usa o Spring Framework . Há sim:org.springframework.util.MultiValueMap .

Para criar um mapa de múltiplos valores não modificável:

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

Ou use org.springframework.util.LinkedMultiValueMap

Sim e não. A solução é criar um clas Wrapper para seus valores que contenha os 2 (3 ou mais) valores que correspondem à sua chave.

Sim, isso costuma ser chamado de multimap.

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

A maneira mais fácil seria usar uma biblioteca de coleções do Google:

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

public class 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
    }

}

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

mais sobre isso: http://tomjefferys.blogspot.be/2011/09/multimaps-google-guava.html

String key= "services_servicename"

ArrayList<String> data;

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);
}

Eu tenho os melhores resultados.

Você apenas tem que criar novos HashMapcomo

HashMap<String, String> servicesNameHashmap = new HashMap<String, String>();

no seu forloop. Terá o mesmo efeito que a mesma chave e vários valores.

 import java.io.*;
 import java.util.*;

 import com.google.common.collect.*;

 class finTech{
public static void main(String args[]){
       Multimap<String, String> multimap = ArrayListMultimap.create();
       multimap.put("1","11");
       multimap.put("1","14");
       multimap.put("1","12");
       multimap.put("1","13");
       multimap.put("11","111");
       multimap.put("12","121");
        System.out.println(multimap);
        System.out.println(multimap.get("11"));
   }                                                                                            
 }                                                                    

Resultado:

     {"1"=["11","12","13","14"],"11"=["111"],"12"=["121"]}

      ["111"]

Esta é a biblioteca Google-Guava para funcionalidades de utilitários. Esta é a solução necessária.

Não consegui postar uma resposta no comentário de Paul, por isso estou criando um novo comentário para Vidhya aqui:

O wrapper será um SuperClasspara as duas classes que queremos armazenar como um valor.

e dentro da classe wrapper, podemos colocar as associações como objetos de variável de instância para os dois objetos de classe.

por exemplo

class MyWrapper {

 Class1 class1obj = new Class1();
 Class2 class2obj = new Class2();
...
}

e no HashMap , podemos colocar dessa maneira,

Map<KeyObject, WrapperObject> 

WrapperObj terá variáveis ​​de classe:class1Obj, class2Obj

Você pode fazer isso implicitamente.

// 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";

Isso é muito simples e eficaz. Se você deseja valores de classes diferentes, pode fazer o seguinte:

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

Pode ser feito usando um identityHashMap, sujeito à condição de que a comparação de chaves seja feita pelo operador == e não seja igual a ().

Eu prefiro o seguinte para armazenar qualquer número de variáveis ​​sem precisar criar uma classe separada.

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

Estou tão acostumado a fazer isso com um Dicionário de dados no Objetivo C. Foi mais difícil obter um resultado semelhante no Java para Android. Acabei criando uma classe personalizada e depois fazendo um mapa de hash da minha classe 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;
    }

}

Podemos criar uma classe para ter várias chaves ou valores e o objeto dessa classe pode ser usado como parâmetro no mapa. Você pode consultar https://stackoverflow.com/a/44181931/8065321

Usando Java Collectors

// Group employees by department
Map<Department, List<Employee>> byDept = employees.stream()
                    .collect(Collectors.groupingBy(Employee::getDepartment));

onde o departamento é sua chave

Experimente o LinkedHashMap , exemplo:

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

resultado:

chaves: 1,1,2,3

valores: vinculado, hash, mapa, java