คำตอบสำหรับคำถามยอดนิยมเกี่ยวกับอินเทอร์เฟซแผนที่

สวัสดี! วันนี้เราจะให้คำตอบสำหรับคำถามที่พบบ่อยที่สุดเกี่ยวกับ Map แต่ก่อนอื่น เรามาทำความเข้าใจกันก่อนว่ามันคืออะไร แผนที่เป็นโครงสร้างข้อมูลที่มีชุดคู่คีย์-ค่า โครงสร้างข้อมูลของมันคล้ายกับพจนานุกรม ซึ่งเป็นเหตุว่าทำไมจึงมักเรียกเช่นนั้น ในเวลาเดียวกัน Map เป็นอินเทอร์เฟซและใน jdk มาตรฐานนั้นประกอบด้วยการใช้งานหลัก: Hashmap, LinkedHashMap, Hashtable, TreeMap การใช้งานที่ใช้มากที่สุดคือ Hashmap ดังนั้นเราจะใช้ในตัวอย่างของเรา นี่คือลักษณะของการสร้างและการเติมแผนที่มาตรฐาน:

Map<Integer, String> map = new HashMap<>();
map.put(1, "string 1");
map.put(2, "string 2");
map.put(3, "string 3");

และนี่คือวิธีรับค่าด้วยคีย์:

String string1 = map.get(1);
String string2 = map.get(2);
String string3 = map.get(3);

หากทั้งหมดที่กล่าวมาข้างต้นมีความชัดเจน เรามาตอบคำถามยอดนิยมกันต่อ!

0. วิธีวนซ้ำค่าแผนที่ทั้งหมด

การวนซ้ำค่าเป็นการดำเนินการทั่วไปที่คุณดำเนินการกับแผนที่ คู่คีย์-ค่าทั้งหมดจะถูกจัดเก็บไว้ในอินเทอร์เฟซ Map.Entry ภายใน และเพื่อให้ได้มาซึ่งคุณจะต้องเรียกใช้entrySet(). มันจะส่งคืนชุดของคู่ที่สามารถวนซ้ำได้:

for(Map.Entry<Integer, String> entry: map.entrySet()) {
   // get key
   Integer key = entry.getKey();
   // get value
   String value = entry.getValue();
}

Или используя итератор:
Iterator<Map.Entry<Integer, String>> itr = map.entrySet().iterator();
while(itr.hasNext()) {
   Map.Entry<Integer, String> entry =  itr.next();
   // get key
   Integer key = entry.getKey();
   // get value
   String value = entry.getValue();
}

1. วิธีแปลงแผนที่เป็นรายการ

อินเทอร์เฟซแผนที่มี 3 วิธีที่ส่งคืนรายการองค์ประกอบ:

• keySet() - ส่งคืนชุดคีย์;
• ค่า () - ส่งกลับชุดของค่า;
• entrySet() - ส่งคืนชุดของชุดคีย์-ค่า

หากคุณดูที่ตัวสร้างของคลาสArrayListคุณจะสังเกตเห็นว่ามีตัวสร้างที่มีอาร์กิวเมนต์ประเภท Collection เนื่องจาก Set เป็นลูกหลานของ Collection ผลลัพธ์ของวิธีการข้างต้นทั้งหมดจึงสามารถส่งผ่านไปยัง Constructor ของคลาสArrayListได้ ดังนั้นเราจะสร้างรายการใหม่และเติมค่าจากMap:

// key list
List<Integer> keyList = new ArrayList<>(map.keySet());
// value list
List<String> valueList = new ArrayList<>(map.values());
// key-value list
List<Map.Entry<Integer, String>> entryList = new ArrayList<>(map.entrySet());

2. วิธีจัดเรียงคีย์แผนที่

การเรียงลำดับแผนที่ยังเป็นการดำเนินการที่ค่อนข้างธรรมดาในการเขียนโปรแกรม คุณสามารถทำได้หลายวิธี:

1. ใส่ Map.Entry ลงในรายการและจัดเรียงโดยใช้ Comparator

   ในตัวเปรียบเทียบเราจะเปรียบเทียบเฉพาะคีย์ของคู่:

   List> list = new ArrayList(map.entrySet());
   Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() {
      @Override
      public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
          return o1.getKey() - o2.getKey();
      }
   });
   

   หากคุณเข้าใจ lambdas รายการนี้สามารถย่อให้สั้นลงได้มาก:

   Collections.sort(list, Comparator.comparingInt(Map.Entry::getKey));

2. ใช้SortedMapหรือถ้าให้เจาะจงกว่านั้นคือ การนำไปใช้งานTreeMapซึ่งใช้ Comparator ในตัวสร้าง ตัวเปรียบเทียบนี้จะนำไปใช้กับคีย์แผนที่ ดังนั้นคีย์จะต้องเป็นคลาสที่ใช้อินเทอร์เฟซComparable:

   SortedMap<Integer, String> sortedMap = new TreeMap<>(new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
          return o1 - o2;
      }
   });

   และแน่นอน ทุกอย่างสามารถเขียนใหม่ได้โดยใช้ lambdas:

   SortedMap<Integer, String> sortedMap = new TreeMap<>(Comparator.comparingInt(o -> o));

   ไม่เหมือนกับวิธีแรก การใช้ SortedMap เราจะจัดเก็บข้อมูลในรูปแบบที่เรียงลำดับเสมอ

3. วิธีจัดเรียงค่าแผนที่

ที่นี่คุณควรใช้แนวทางที่คล้ายกับวิธีแรกสำหรับคีย์ - รับรายการค่าและจัดเรียงในรายการ:

List <Map.Entry<Integer, String>> valuesList = new ArrayList(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() {
   @Override
   public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
       return o1.getValue().compareTo(o2.getValue());
   }
});

และแลมบ์ดาสำหรับสิ่งนี้จะมีลักษณะดังนี้:

Collections.sort(list, Comparator.comparing(Map.Entry::getValue));

4. อะไรคือความแตกต่างระหว่าง HashMap, TreeMap และ Hashtable

ตามที่กล่าวไว้ก่อนหน้านี้ มีการใช้งานหลัก 3 ประการของอินเทอร์เฟซแผนที่ แต่ละคนมีลักษณะเฉพาะของตัวเอง:

1. ลำดับขององค์ประกอบ HashMapและHashtableไม่รับประกันว่ารายการต่างๆ จะถูกจัดเก็บตามลำดับที่เพิ่มเข้ามา นอกจากนี้ ยังไม่รับประกันว่าลำดับขององค์ประกอบจะไม่เปลี่ยนแปลงเมื่อเวลาผ่านไป ในทางกลับกันTreeMapจะรับประกันการจัดเก็บองค์ประกอบตามลำดับที่เพิ่มหรือตามตัวเปรียบเทียบที่กำหนด

2. ค่าที่ถูกต้อง HashMapช่วยให้คุณมีคีย์และค่าว่างHashTableได้ TreeMap สามารถใช้ค่า Null ได้หากตัวเปรียบเทียบอนุญาตเท่านั้น หากไม่ใช้ตัวเปรียบเทียบ (โดยการจัดเก็บคู่ตามลำดับที่เพิ่ม) จะไม่อนุญาตให้มีค่า null

3. การซิงโครไนซ์ ซิงโครไนซ์ เท่านั้นHashTableส่วนที่เหลือไม่ได้ หากเธรดอื่นไม่สามารถเข้าถึงแผนที่ได้ ขอแนะนำให้ใช้ HashMap แทน HashTable

และการเปรียบเทียบการใช้งานทั่วไป:

5. วิธีสร้างแผนที่แบบสองทิศทาง

บางครั้งจำเป็นต้องใช้โครงสร้างข้อมูลที่ทั้งคีย์และค่าจะไม่ซ้ำกัน กล่าวคือ แผนที่จะมีคู่คีย์-คีย์ โครงสร้างข้อมูลนี้ช่วยให้คุณสร้าง "มุมมอง/การค้นหาแบบกลับหัว" บนแผนที่ได้ นั่นคือ เราสามารถค้นหาคีย์ได้จากค่าของมัน โครงสร้างข้อมูลนี้เรียกว่าแผนที่แบบสองทิศทาง ซึ่งน่าเสียดายที่ JDK ไม่รองรับ แต่โชคดีที่การใช้งานสามารถพบได้ในไลบรารี Apache Common Collections หรือ Guava ที่นั่นเรียกว่า BidiMap และ BiMap ตามลำดับ การใช้งานเหล่านี้กำหนดข้อจำกัดเกี่ยวกับเอกลักษณ์ของคีย์และค่า สิ่งนี้สร้างความสัมพันธ์แบบหนึ่งต่อหนึ่ง

6. วิธีสร้างแผนที่เปล่า

มีสองวิธีในการสร้างแผนที่เปล่า:

1. การเริ่มต้นวัตถุปกติ:

   Map<Integer, String> emptyMap = new HashMap<>();

2. การสร้างแผนที่ว่างที่ไม่เปลี่ยนรูป:

   Map<Integer, String> emptyMap =  Collections.emptyMap();

เมื่อเราพยายามเพิ่มข้อมูลลงในแผนที่ดังกล่าว เราจะได้รับ: UnsupportedOperationExceptionข้อยกเว้น ในบทความนี้ เราได้ดูคำถามที่พบบ่อยที่สุดที่คุณอาจมีเมื่อใช้อินเทอร์เฟซแผนที่