[java] 동일한 키 아래에 여러 값이있는 HashMap

당신은 할 수 있습니다 :

1. 목록이있는 맵을 값으로 사용하십시오. Map<KeyType, List<ValueType>>.
2. 새 랩퍼 클래스를 작성하고이 랩퍼의 인스턴스를 맵에 배치하십시오. Map<KeyType, WrapperType>.
3. 클래스와 같은 튜플을 사용하십시오 (래퍼를 많이 만들어 저장). Map<KeyType, Tuple<Value1Type, Value2Type>>.
4. 여러지도를 나란히 사용하십시오.

예

1. 목록을 값으로 사용하여 매핑

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

이 방법의 단점은 목록이 정확히 두 값에 바인딩되지 않는다는 것입니다.

2. 랩퍼 클래스 사용

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

이 접근 방식의 단점은 이러한 매우 간단한 컨테이너 클래스에 대해 많은 보일러 플레이트 코드를 작성해야한다는 것입니다.

3. 튜플 사용

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

이것은 내 의견으로는 최고의 솔루션입니다.

4. 여러지도

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

이 솔루션의 단점은 두 맵이 관련되어 있다는 것이 확실하지 않으며 프로그래밍 오류로 인해 두 맵이 동기화되지 않은 것을 볼 수 있다는 것입니다.

답변

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

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

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

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

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

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

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

bar: foo
first: hello, foo, hello