Как создать HashMap с двумя ключами (Key-Pair, Value)?
У меня есть 2D массив целых чисел. Я хочу, чтобы они были помещены в HashMap. Но я хочу получить доступ к элементам из HashMap на основе индекса массива. Что-то вроде:
Для A[2][5] map.get(2,5) который возвращает значение, связанное с этим ключом. Но как мне создать хэш-карту с парой ключей? Или вообще несколько ключей: Map<((key1, key2,..,keyN), Value) таким образом, что я могу получить доступ к элементу с помощью get(key1,key2,...keyN).
РЕДАКТИРОВАТЬ: 3 года после публикации вопроса, я хочу добавить немного больше к нему
Я наткнулся на другой способ NxN matrix,
Массив индексов, i а также j может быть представлен в виде одного key следующим образом:
int key = i * N + j;
//map.put(key, a[i][j]); // queue.add(key);
И индексы можно восстановить из key в этом случае:
int i = key / N;
int j = key % N;
14 ответов
Есть несколько вариантов:
2 dimensions
Map of maps
Map<Integer, Map<Integer, V>> map = //...
//...
map.get(2).get(5);
Wrapper key object
public class Key {
private final int x;
private final int y;
public Key(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Key)) return false;
Key key = (Key) o;
return x == key.x && y == key.y;
}
@Override
public int hashCode() {
int result = x;
result = 31 * result + y;
return result;
}
}
Внедрение equals() а также hashCode() имеет решающее значение здесь. Then you simply use:
Map<Key, V> map = //...
а также:
map.get(new Key(2, 5));
Table из гуавы
Table<Integer, Integer, V> table = HashBasedTable.create();
//...
table.get(2, 5);
Table uses map of maps underneath.
N dimensions
Notice that special Key class is the only approach that scales to n-dimensions. Вы также можете рассмотреть:
Map<List<Integer>, V> map = //...
but that's terrible from performance perspective, as well as readability and correctness (no easy way to enforce list size).
Maybe take a look at Scala where you have tuples and case classes (replacing whole Key class with one-liner).
Когда вы создаете свой собственный объект пары ключей, вы должны столкнуться с несколькими вещами.
Во-первых, вы должны знать о реализации hashCode() а также equals(), Вам нужно будет сделать это.
Во-вторых, при реализации hashCode()Убедитесь, что вы понимаете, как это работает. Данный пример пользователя
public int hashCode() {
return this.x ^ this.y;
}
на самом деле одна из худших реализаций, которую вы можете сделать. Причина проста: у вас много одинаковых хэшей! И hashCode() должен возвращать значения типа int, которые обычно бывают редкими, в лучшем случае уникальными. Используйте что-то вроде этого:
public int hashCode() {
return (X << 16) + Y;
}
Это быстро и возвращает уникальные хэши для ключей от -2^16 до 2^16-1 (от -65536 до 65535). Это подходит практически в любом случае. Очень редко вы выходите за эти рамки.
В-третьих, при реализации equals() также знать, для чего он используется, и знать, как вы создаете свои ключи, поскольку они являются объектами. Часто вы делаете ненужные, если заявления приводят к тому, что вы всегда будете иметь один и тот же результат.
Если вы создаете ключи, как это: map.put(new Key(x,y),V); Вы никогда не будете сравнивать ссылки ваших ключей. Потому что каждый раз, когда вы хотите получить доступ к карте, вы будете делать что-то вроде map.get(new Key(x,y));, Поэтому ваш equals() не нужно утверждение как if (this == obj), Это никогда не произойдет.
Вместо if (getClass() != obj.getClass()) в вашем equals() лучше использовать if (!(obj instanceof this)), Это будет действительно даже для подклассов.
Так что единственное, что вам нужно сравнить, это на самом деле X и Y. Так что лучший equals() Реализация в этом случае будет:
public boolean equals (final Object O) {
if (!(O instanceof Key)) return false;
if (((Key) O).X != X) return false;
if (((Key) O).Y != Y) return false;
return true;
}
В итоге ваш ключевой класс выглядит так:
public class Key {
public final int X;
public final int Y;
public Key(final int X, final int Y) {
this.X = X;
this.Y = Y;
}
public boolean equals (final Object O) {
if (!(O instanceof Key)) return false;
if (((Key) O).X != X) return false;
if (((Key) O).Y != Y) return false;
return true;
}
public int hashCode() {
return (X << 16) + Y;
}
}
Вы можете дать свои показатели измерения X а также Y уровень публичного доступа, поскольку они являются окончательными и не содержат конфиденциальной информации. Я не уверен на 100% private уровень доступа работает корректно в любом случае при Object к Key,
Если вы задаетесь вопросом о финалах, я объявляю что-либо как окончательное, значение которого задается для экземпляра и никогда не изменяется - и, следовательно, является константой объекта.
Вы не можете иметь хэш-карту с несколькими ключами, но вы можете иметь объект, который принимает несколько параметров в качестве ключа.
Создайте объект с именем Index, который принимает значения x и y.
public class Index {
private int x;
private int y;
public Index(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int hashCode() {
return this.x ^ this.y;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Index other = (Index) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
}
Тогда ваш HashMap<Index, Value> чтобы получить свой результат.:)
Реализовано в общих коллекциях [MultiKeyMap] ( https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/map/MultiKeyMap.html).
Java 7+ содержит новый Map.Entry<K,V>класс, который вы можете использовать в качестве ключа для вашей карты (или записи для вашего набора). Он также содержит
Map.entry(K k, V v) легко создавать новые
Map.Entry объекты.
Использование:
Map<Map.Entry<Integer,Integer>, Integer> map = new HashMap<>();
map.put(Map.entry(1, 2), 0);
Использовать Pair в качестве ключей для HashMap, В JDK нет пары, но вы можете использовать сторонние библиотеки, такие как http://commons.apache.org/lang или написать собственный тип пары.
Две возможности Либо используйте комбинированный ключ:
class MyKey {
int firstIndex;
int secondIndex;
// important: override hashCode() and equals()
}
Или карта карты:
Map<Integer, Map<Integer, Integer>> myMap;
Вы можете создать свой ключевой объект примерно так:
открытый класс MapKey {
public Object key1;
public Object key2;
public Object getKey1() {
return key1;
}
public void setKey1(Object key1) {
this.key1 = key1;
}
public Object getKey2() {
return key2;
}
public void setKey2(Object key2) {
this.key2 = key2;
}
public boolean equals(Object keyObject){
if(keyObject==null)
return false;
if (keyObject.getClass()!= MapKey.class)
return false;
MapKey key = (MapKey)keyObject;
if(key.key1!=null && this.key1==null)
return false;
if(key.key2 !=null && this.key2==null)
return false;
if(this.key1==null && key.key1 !=null)
return false;
if(this.key2==null && key.key2 !=null)
return false;
if(this.key1==null && key.key1==null && this.key2 !=null && key.key2 !=null)
return this.key2.equals(key.key2);
if(this.key2==null && key.key2==null && this.key1 !=null && key.key1 !=null)
return this.key1.equals(key.key1);
return (this.key1.equals(key.key1) && this.key2.equals(key2));
}
public int hashCode(){
int key1HashCode=key1.hashCode();
int key2HashCode=key2.hashCode();
return key1HashCode >> 3 + key2HashCode << 5;
}
}
Преимущество этого в том, что вы всегда будете уверены, что вы охватили все сценарии "Равных".
ПРИМЕЧАНИЕ. Ключи key1 и key2 должны быть неизменными. Только тогда вы сможете построить стабильный ключевой объект.
Если они представляют собой два целых числа, вы можете попробовать быстрый и грязный трюк: Map<String, ?> используя ключ как i+"#"+j,
Если ключ i+"#"+j такой же как j+"#"+i пытаться min(i,j)+"#"+max(i,j),
Мы можем создать класс для передачи более одного ключа или значения, и объект этого класса можно использовать в качестве параметра на карте.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;
public class key1 {
String b;
String a;
key1(String a,String b)
{
this.a=a;
this.b=b;
}
}
public class read2 {
private static final String FILENAME = "E:/studies/JAVA/ReadFile_Project/nn.txt";
public static void main(String[] args) {
BufferedReader br = null;
FileReader fr = null;
Map<key1,String> map=new HashMap<key1,String>();
try {
fr = new FileReader(FILENAME);
br = new BufferedReader(fr);
String sCurrentLine;
br = new BufferedReader(new FileReader(FILENAME));
while ((sCurrentLine = br.readLine()) != null) {
String[] s1 = sCurrentLine.split(",");
key1 k1 = new key1(s1[0],s1[2]);
map.put(k1,s1[2]);
}
for(Map.Entry<key1,String> m:map.entrySet()){
key1 key = m.getKey();
String s3 = m.getValue();
System.out.println(key.a+","+key.b+" : "+s3);
}
// }
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null)
br.close();
if (fr != null)
fr.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}
Вы также можете использовать реализацию таблицы гуавы для этого.
Таблица представляет собой специальную карту, в которой два ключа могут быть заданы комбинированным образом для ссылки на одно значение. Это похоже на создание карты карт.
//create a table
Table<String, String, String> employeeTable = HashBasedTable.create();
//initialize the table with employee details
employeeTable.put("IBM", "101","Mahesh");
employeeTable.put("IBM", "102","Ramesh");
employeeTable.put("IBM", "103","Suresh");
employeeTable.put("Microsoft", "111","Sohan");
employeeTable.put("Microsoft", "112","Mohan");
employeeTable.put("Microsoft", "113","Rohan");
employeeTable.put("TCS", "121","Ram");
employeeTable.put("TCS", "122","Shyam");
employeeTable.put("TCS", "123","Sunil");
//get Map corresponding to IBM
Map<String,String> ibmEmployees = employeeTable.row("IBM");
Создайте класс значений, который будет представлять ваш составной ключ, например:
class Index2D {
int first, second;
// overrides equals and hashCode properly here
}
заботиться о переопределении equals() а также hashCode() правильно. Если это кажется большой работой, вы можете рассмотреть некоторые готовые универсальные контейнеры, такие как Pair предоставленные Apache Commons среди других.
Здесь также есть много подобных вопросов, с другими идеями, такими как использование таблицы Гуавы, хотя она позволяет ключам иметь разные типы, что может быть избыточно (в использовании памяти и сложности) в вашем случае, так как я понимаю, что оба ключа являются целыми числами.
Вы можете скачать его по ссылке ниже:https://github.com/VVS279/DoubleKeyHashMap/blob/master/src/com/virtualMark/doubleKeyHashMap/DoubleKeyHashMap.java.
https://github.com/VVS279/DoubleKeyHashMap
Вы можете использовать двойной ключ: значение hashmap,
DoubleKeyHashMap<Integer, Integer, String> doubleKeyHashMap1 = new
DoubleKeyHashMap<Integer, Integer, String>();
DoubleKeyHashMap<String, String, String> doubleKeyHashMap2 = new
DoubleKeyHashMap<String, String, String>();
Использовать org.apache.commons.lang3.tuple.Pair очень просто;
Map<String, Pair<String, Integer>> map= new HashMap<>();
map.put("key", Pair.of("a", 1));
int value = map.get("key").getRight();