ວິທີການ HashMap Java



HashMap Java ແຜນທີ່ Java

HashMap Class ໃນ Java ເກັບຮັກສາຂໍ້ມູນໃນຮູບແບບຂອງ ຄ່າທີ່ ສຳ ຄັນ ຄູ່ທີ່ຂໍ້ມູນ ສຳ ຄັນຄວນເປັນເອກະລັກສະເພາະ. ພວກເຮົາສາມາດເຂົ້າເຖິງຄຸນຄ່າຕ່າງໆໂດຍອີງໃສ່ຂໍ້ມູນຫຼັກທີ່ສອດຄ້ອງກັນ. HashMap ແມ່ນມີຢູ່ໃນກອບການເກັບຂອງ Java ແລະເປັນສ່ວນ ໜຶ່ງ ຂອງຊຸດ java.util. ມັນເຮັດວຽກກ່ຽວກັບຫຼັກການຂອງເຕັກນິກ Hashing.

Java HashMap ລຳ ດັບຊັ້ນ

ຫ້ອງຮຽນ HashMap ໃນ Java ຂະຫຍາຍ ບົດຄັດຫຍໍ້ ລະດັບ ແຜນທີ່ບົດສະຫຼຸບ ແລະປະຕິບັດ ແຜນທີ່ ໃນການໂຕ້ຕອບເປັນສະແດງໃຫ້ເຫັນຂ້າງລຸ່ມນີ້.

HashMap ໃນ Java

ໂຄງສ້າງ HashMap ແລະຫຼັກການເຮັດວຽກ

HashMap ໃນ Java ເຮັດວຽກຕາມຫຼັກການຂອງ ເຮື້ອຮັງ ເຕັກນິກ. ໃນ hashing, ພວກເຮົາໃຊ້ຫນ້າທີ່ hash ເພື່ອເຊື່ອມຕໍ່ຄີແລະຄຸນຄ່າໃນ HashMap. The HashMap ເກັບຮັກສາຄູ່ຄ່າ ສຳ ຄັນໃນຮູບແບບຂອງ an array ຂອງຂໍ້ທີ່ບ່ອນທີ່ເຂົ້າແຕ່ລະຄົນຖືກຖືວ່າເປັນຖັງ. ຖັງແມ່ນບໍ່ມີຫຍັງແຕ່ເປັນສ່ວນປະກອບໃນຂບວນ. ແຕ່ລະ node ມີ 3 ຄ່າ: ທີ່ສໍາຄັນ, ມູນຄ່າ, ແລະເຊື່ອມຕໍ່ກັບ ຕໍ່ໄປ ຂໍ້. ເມື່ອຫລາຍກ່ວາ 1 node ແບ່ງປັນດັດສະນີດຽວກັນ, ມັນສະແດງເຖິງລາຍຊື່ທີ່ເຊື່ອມໂຍງ. ທຸກໆໂຫນດແມ່ນຖືກ ໝາຍ ໃສ່ດັດສະນີໃນຖັງທີ່ຖືກຄິດໄລ່ໂດຍໃຊ້ hashcode ().

HashMap ໃນ Java

ຜົນງານ HashMap

ການປະຕິບັດງານຂອງ HashMap ໃນ Java ແມ່ນຂື້ນກັບພາລາມິເຕີຂ້າງລຸ່ມນີ້:

  • ຄວາມສາມາດໃນເບື້ອງຕົ້ນ - ມັນສະແດງເຖິງ ຈຳ ນວນຖັງທີ່ HashMap ສາມາດເກັບໄວ້ໄດ້ເມື່ອມັນເລີ່ມຕົ້ນ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ມັນແມ່ນ 16 ຄູ່ທີ່ມີຄ່າ
  • ປັດໄຈການໂຫຼດ - ມັນແມ່ນເປີເຊັນຂອງຄວາມສາມາດທີ່ຕ້ອງໄດ້ເພີ່ມຂື້ນ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ມັນແມ່ນ 0.75
  • Threshold - ນີ້ແມ່ນຜະລິດຕະພັນຂອງປັດໃຈການໂຫຼດແລະຄວາມສາມາດເຊິ່ງຄ່າເລີ່ມຕົ້ນຂອງມັນແມ່ນ 12 (16 * 0.75)
  • ການຟື້ນຟູ - ນີ້ແມ່ນຂະບວນການເພີ່ມຄວາມອາດສາມາດສອງເທົ່າຫຼັງຈາກທີ່ມັນຮອດມູນຄ່າໃກ້ຈະເຂົ້າສູ່ແລ້ວ.

ການປະກາດ Java HashMap

ເພື່ອໃຊ້ HashMap ໃນ Java, ພວກເຮົາຕ້ອງການ ນຳ ເຂົ້າ java.util.HashMap ຊຸດ. syntax ແມ່ນໃຫ້ຢູ່ຂ້າງລຸ່ມນີ້:

HashMap<KeyType,ValueType> map = new HashMap<>();

ປະເພດຄີ - ມັນແມ່ນປະເພດຂອງຂໍ້ມູນທີ່ ສຳ ຄັນ.Eg: String ຫຼື Integer

ValueType - ມັນແມ່ນປະເພດຂໍ້ມູນມູນຄ່າ. ຕົວຢ່າງ: ສະຕິງຫລືແບບຄົບວົງຈອນ

ຄຸນລັກສະນະ HashMap

ຂ້າງລຸ່ມນີ້ແມ່ນຄຸນລັກສະນະຂອງ HashMap ໃນ Java:

  • ຄຸນຄ່າຂອງຮ້ານທີ່ສອດຄ້ອງກັບແຕ່ລະຄີ
  • ມີພຽງແຕ່ປຸ່ມທີ່ເປັນເອກະລັກເທົ່ານັ້ນ
  • ບໍ່ອະນຸຍາດໃຫ້ໃຊ້ປຸ່ມຊ້ ຳ ກັນແຕ່ສາມາດມີຄ່າທີ່ຊ້ ຳ ກັນ
  • ມັນບໍ່ໄດ້ຮັກສາ ຄຳ ສັ່ງໃດໆເຊິ່ງ ໝາຍ ຄວາມວ່າ ຄຳ ສັ່ງທີ່ຂໍ້ມູນໃສ່ແມ່ນບໍ່ຄືກັບ ຄຳ ສັ່ງທີ່ເອົາມາ.
  • ມັນບໍ່ແມ່ນການປະສານກັນ

ຜູ້ກໍ່ສ້າງ Java HashMap Class Java

HashMap ສະ ໜັບ ສະ ໜູນ 4 ຜູ້ສ້າງທີ່ແຕກຕ່າງກັນດັ່ງທີ່ທ່ານເຫັນໃນຕາຕະລາງລຸ່ມນີ້:

ຜູ້ກໍ່ສ້າງລາຍລະອຽດ
HashMap ()ເລີ່ມຕົ້ນ HashMap ເລີ່ມຕົ້ນ
HashMap (Mapm)ເລີ່ມຕົ້ນ Hashmap ດ້ວຍສ່ວນປະກອບຂອງ Map m
HashMap (ຄວາມສາມາດສູງສຸດ)ເລີ່ມຕົ້ນ hashmap ດ້ວຍມູນຄ່າຄວາມສາມາດທີ່ລະບຸໄວ້
HashMap (ຄວາມສາມາດ int, float loadfactor)ເລີ່ມຕົ້ນ hashmap ດ້ວຍຄວາມສາມາດແລະ loadfactor ທີ່ລະບຸ

ວິທີການ HashMap

Java HashMap ສະ ໜັບ ສະ ໜູນ ທຸກໆວິທີທີ່ເປັນຂອງອິນເຕີເຟດ Map ພ້ອມກັບວິທີການຕ່າງໆທີ່ກ່າວມາໃນຕາຕະລາງຂ້າງລຸ່ມ

ວິທີການລາຍລະອຽດພາລາມິເຕີ
ໂມຄະຈະແຈ້ງ ()ລຶບແຜນທີ່ທັງ ໝົດ ອອກໃນແຜນທີ່ນີ້ ໝາຍ ຄວາມວ່າແຜນທີ່ຈະຫວ່າງຢູ່
ໂຄນວັດຖຸ ()ສົ່ງຄືນ ສຳ ເນົາຕື້ນໆຂອງຕົວຢ່າງ HashMap ນີ້. ກຸນແຈແລະຄຸນຄ່າຂອງຕົວມັນເອງບໍ່ໄດ້ຖືກກ້ອນຫີນ
Boolean containsKey (ຄີວັດຖຸ)ກັບຄືນມາເປັນຄວາມຈິງຖ້າມີມູນຄ່າແຜນທີ່ ສຳ ລັບລະຫັດທີ່ລະບຸkey - ກຸນແຈທີ່ພວກເຮົາຕ້ອງການດຶງເອົາມູນຄ່າ
Boolean ມີ Value (ຄ່າວັດຖຸ)ກັບມາເປັນຄວາມຈິງຖ້າມີການສ້າງແຜນທີ່ ສຳ ຄັນ ສຳ ລັບຄ່າທີ່ລະບຸvalue - ມູນຄ່າທີ່ຄີ ກຳ ນົດສະເພາະໄດ້ຖືກສ້າງແຜນທີ່
ຕັ້ງ entrySet ()ກັບຄືນມຸມມອງທີ່ ກຳ ນົດໄວ້ໃນແຜນທີ່ຂອງແຜນທີ່
Boolean ເທົ່າກັນ (ວັດຖຸ o)ກັບຄືນມາເປັນຄວາມຈິງຖ້າວ່າວັດຖຸມີແຜນທີ່ດຽວກັນຂອງແຜນທີ່o - ວັດຖຸທີ່ຈະຖືກປຽບທຽບ
ໄດ້ຮັບເລກເຕັມ (key object)ສົ່ງຄືນຄ່າຂອງຄີທີ່ລະບຸໄວ້ໃນແຜນທີ່. ມັນຈະກັບຄືນມາຖ້າບໍ່ມີແຜນທີ່key - ກະແຈ ສຳ ລັບການສ້າງແຜນທີ່ມູນຄ່າ
GetOrDefault (ເລກວັດຖຸ, ຄ່າເລີ່ມຕົ້ນຂອງຕົວເລກເຕັມ)ສົ່ງຄືນຄ່າຂອງຄີທີ່ລະບຸໄວ້ຖ້າຖືກຄັດເລືອກ, ກໍ່ຈະສົ່ງຄືນຄ່າເລີ່ມຕົ້ນຖ້າບໍ່ມີແຜນທີ່key - ກະແຈ ສຳ ລັບສິ່ງທີ່ພວກເຮົາເຫັນຄຸນຄ່າຕ້ອງໄດ້ສົ່ງຄືນ
defaultvalue - ຄ່າເລີ່ມຕົ້ນທີ່ຈະສົ່ງຄືນເມື່ອບໍ່ມີແຜນທີ່
int hashCode ()ສົ່ງຄືນມູນຄ່າ hashcode ຂອງແຜນທີ່
Boolean isEmpty ()ຜົນຕອບແທນທີ່ແທ້ຈິງແມ່ນ hashmap ບໍ່ມີຄູ່ຄ່າ ສຳ ຄັນໃດໆ
ຕັ້ງ keySet ()ກັບຄືນມຸມມອງທີ່ຕັ້ງໄວ້ຂອງຄີທີ່ມີຢູ່ໃນແຜນທີ່
ໃສ່ເລກເຊືອກ (key String, int ມູນຄ່າ)ເຊື່ອມໂຍງຄີກັບມູນຄ່າ. ຖ້າກຸນແຈມີຢູ່ແລ້ວ, ມັນຈະປ່ຽນແທນຄ່າເກົ່າດ້ວຍຄ່າ ໃໝ່key - ກຸນແຈ ສຳ ລັບການສ້າງແຜນທີ່
ມູນຄ່າ - ມູນຄ່າ ສຳ ລັບຄີທີ່ລະບຸ
void putAll (ແຜນທີ່ m)ເຊື່ອມໂຍງທຸກສິ່ງທີ່ ສຳ ຄັນ - ການສ້າງແຜນທີ່ມູນຄ່າຂອງ m ໃສ່ແຜນທີ່ປະຈຸບັນm - ສຳ ເນົາຂອງແຜນທີ່ທີ່ຈະຖືກເພີ່ມໃສ່ແຜນທີ່ປະຈຸບັນ
putIfAbsent (ເລກລະຫັດ, ຄ່າເລກເຕັມ)ເຊື່ອມໂຍງມູນຄ່າຖ້າຍັງບໍ່ໄດ້ວາງແຜນໃສ່ປຸ່ມອື່ນທີ່ຈະສົ່ງຄືນມູນຄ່າປັດຈຸບັນkey - ກຸນແຈ ສຳ ລັບການສ້າງແຜນທີ່
ມູນຄ່າ - ມູນຄ່າທີ່ຈະພົວພັນ
ເອົາເລກເຕັມ (ປຸ່ມວັດຖຸ)ກຳ ຈັດແຜນທີ່ ສຳ ລັບຄີທີ່ລະບຸໄວ້ໃນແຜນທີ່key - ຄີໃນແຜນທີ່ທີ່ຕ້ອງໄດ້ຖອດອອກ
Boolean ເອົາອອກ (ປຸ່ມວັດຖຸ, ຄ່າວັດຖຸ)ລົບລາຍການທີ່ຖືກລະບຸໄວ້ເທົ່ານັ້ນຖ້າມັນຖືກແຕ້ມໃສ່ກັບມູນຄ່າທີ່ລະບຸໄວ້key - key ໃນແຜນທີ່
ມູນຄ່າ - ມູນຄ່າທີ່ຖືກຈັບກັບກຸນແຈ
ການທົດແທນເລກເຕັມ (key String, ມູນຄ່າ Integer)ປ່ຽນແທນຄ່າຂອງຄີທີ່ລະບຸໄວ້ກັບຄ່າເທົ່ານັ້ນຖ້າມັນປະຈຸບັນມີແຜນທີ່ບາງຄ່າkey - key ໃນແຜນທີ່
ມູນຄ່າ - ມູນຄ່າທີ່ຈະທົດແທນ
ປ່ຽນແທນບູຕິກ (key String, integer oldvalue, Integer newvalue)ປ່ຽນແທນການປ້ອນຂໍ້ມູນຂອງຄີທີ່ລະບຸໄວ້ດ້ວຍມູນຄ່າ ໃໝ່ ເທົ່ານັ້ນຖ້າມັນມີແຜນທີ່ແລ້ວກັບຄ່າເກົ່າທີ່ລະບຸໄວ້key - ຄີໃນແຜນທີ່
oldvalue - oldvalue ສ້າງເປັນຄີ
newvalue - newvalue ທີ່ຈະຖືກແຕ້ມໃສ່ກະແຈ
ຂະ ໜາດ int ()ສົ່ງຄືນຂະ ໜາດ ຂອງແຜນທີ່
String toString ()ກັບຄືນຕົວແທນສະຕິງຂອງແຜນທີ່
ຄ່າສະສົມ ()ກັບມາເບິ່ງການສະສົມຂອງຄ່າຕ່າງໆທີ່ມີຢູ່ໃນແຜນທີ່

ຂໍ້ຍົກເວັ້ນ HashMap

ມັນຖິ້ມຂໍ້ຍົກເວັ້ນຂ້າງລຸ່ມນີ້ໃນ Java:

  • ConcurrentModificationException
  • IllelgalMonitorStateException
  • NullPointerException
  • ການຂັດຂວາງການຍົກເວັ້ນ
  • ຜິດກົດAາຍຂໍ້ຍົກເວັ້ນ

ເພີ່ມອົງປະກອບເຂົ້າໃນ HashMap

ດັ່ງທີ່ທ່ານສາມາດເຫັນໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ທຳ ອິດພວກເຮົາສ້າງ HashMap ທີ່ມີຊື່ວ່າ 'ນັກຮຽນ' ທີ່ມີກຸນແຈປະເພດ String ແລະຄຸນຄ່າຂອງປະເພດ Integer. ຈາກນັ້ນພວກເຮົາເພີ່ມຄູ່ ສຳ ຄັນຂອງຄ່າໃຊ້ຈ່າຍສ່ວນບຸກຄົນໂດຍ ນຳ ໃຊ້ ເອົາໃຈໃສ່ ວິທີການ. ທ່ານສາມາດສັງເກດເຫັນໃນຜົນຜະລິດວ່າ ຄຳ ສັ່ງທີ່ອົງປະກອບຕ່າງໆຖືກດຶງມາບໍ່ຄືກັບ ຄຳ ສັ່ງທີ່ມັນຖືກໃສ່.

ຕໍ່ໄປ, ພວກເຮົາສ້າງ HashMap ທີສອງທີ່ມີຊື່ວ່າ 'stu' ແລະຫຼັງຈາກນັ້ນຕື່ມ 2 ຄູ່ທີ່ມີຄ່າ ສຳ ຄັນ. ນີ້ພວກເຮົາຈະເພີ່ມໃສ່ແຜນທີ່ 'ນັກຮຽນ' ໂດຍໃຊ້ ໃສ່ທັງົດ ວິທີການ.

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    HashMap<String,Integer> stu = new HashMap<>();
    stu.put("Ravi",110);
    stu.put("Tejas", 112);
    System.out.println("Elements in stu map:");
    System.out.println(stu);
    
    student.putAll(stu);
    
    System.out.println("Elements in student map after invoking putAll method:");
    System.out.println(student);
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
Elements in stu map:
{Ravi=110, Tejas=112}
Elements in student map after invoking putAll method:
{Dev=105, Ravi=110, Tejas=112, Banu=102, Rishi=108, Arthi=100}

ກວດເບິ່ງວ່າແຜນທີ່ປະກອບມີກຸນແຈຫລືຄຸນຄ່າສະເພາະ

ພວກເຮົາໃຊ້ ບັນຈຸ ວິທີການໃນການກວດສອບວ່າມີຄີໃດ ໜຶ່ງ ຢູ່ໃນແຜນທີ່ຫຼືບໍ່. ໃນກໍລະນີນີ້, Dev ມີຢູ່ແລະເພາະສະນັ້ນມັນກັບຄືນມາເປັນຄວາມຈິງແລະ Ravi ບໍ່ມີຢູ່ແລະເພາະສະນັ້ນຈຶ່ງກັບຄືນມາບໍ່ຖືກຕ້ອງ.

ເຊັ່ນດຽວກັນ, ບັນຈຸມີຄ່າ ວິທີການກວດສອບຖ້າມີຄຸນຄ່າສະເພາະ. ນີ້, 102 ແມ່ນມີຢູ່ແຕ່ວ່າ 110 ແມ່ນບໍ່ມີຢູ່ແລະເພາະສະນັ້ນຈຶ່ງກັບຄືນມາບໍ່ຖືກຕ້ອງ.

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    System.out.println(student.containsKey("Dev"));
    System.out.println(student.containsKey("Ravi"));
    
    System.out.println(student.containsValue(102));
    System.out.println(student.containsValue(110));
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
true
false
true
false

ເອົາອອກແລະປ່ຽນແທນຄູ່ທີ່ມີຄ່າ

ນີ້, ພວກເຮົາສ້າງ hashmap ໃນ Java ຂອງ Integer ແລະ string ພິມເພື່ອເກັບຮັກສາພາສາຕ່າງໆ. ພວກເຮົາປ່ຽນແທນຄ່າທີ 2 ດ້ວຍຂໍ້ມູນ ໃໝ່ ແລະແທນມູນຄ່າທີ 3 ຖ້າຄູ່ຄ່າທີ່ມີຄ່າ ສຳ ຄັນສະເພາະຢູ່ໃນແຜນທີ່ ນຳ ໃຊ້ ທົດແທນ () ວິທີການ.

ຈາກນັ້ນ, ພວກເຮົາເອົາອົງປະກອບທີ 3 ອອກໂດຍໃຊ້ຄີແລະເອົາປັດໃຈທີ 1 ອອກໂດຍໃຊ້ຄ່າທີ່ ສຳ ຄັນໂດຍໃຊ້ ເອົາ () ວິທີການ.

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    lang.putIfAbsent(3, "C++");
    System.out.println(lang);
    
    lang.replace(2, "PHP");
    System.out.println(lang);
    
    lang.replace(3, "C++", "JavaScript");
    System.out.println(lang);
    
    lang.remove(3);
    System.out.println(lang);
    
    lang.remove(1, "Java");		
    System.out.println(lang);
    
    
  }

}
{1=Java, 2=C, 3=C++}
{1=Java, 2=PHP, 3=C++}
{1=Java, 2=PHP, 3=JavaScript}
{1=Java, 2=PHP}
{2=PHP}

ຕົວຢ່າງຂອງວິທີການທີ່ຈະແຈ້ງແລະເປົ່າ

HashMap ໃນ Java ໃຊ້ ຈະແຈ້ງ () ວິທີການໃນການລຶບແຜນທີ່ຂອງຄູ່ທີ່ມີຄ່າໃນແຜນທີ່ແລະ ຫວ່າງເປົ່າ ວິທີການກວດສອບຖ້າແຜນທີ່ຫວ່າງເປົ່າ. ຜົນໄດ້ຮັບທີ 1 ແມ່ນບໍ່ຖືກຕ້ອງເນື່ອງຈາກການສ້າງແຜນທີ່ແລະຜົນຜະລິດທີ 2 ແມ່ນຖືກຕ້ອງເພາະວ່າແຜນທີ່ບໍ່ມີຄູ່ຄ່າ ສຳ ຄັນໃດໆຫຼັງຈາກບອກວິທີການທີ່ຊັດເຈນ ()

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    
    System.out.println(lang.isEmpty());
    lang.clear();
    
    System.out.println(lang.isEmpty());
    
  }

}
false
true

ການປະສົມຜ່ານອົງປະກອບຂອງ HashMap ໂດຍໃຊ້ entrySet

ເພື່ອດຶງເອົາຄູ່ HashMap ໃນ Java, ພວກເຮົາສາມາດໃຊ້ ຊຸດເຂົ້າ ວິທີການຂອງ HashMap ພ້ອມດ້ວຍ Entry ວິທີການໂຕ້ຕອບຂອງ Map ໂດຍໃຊ້ a ສໍາລັບແຕ່ລະ loop. ວິທີການເຂົ້າຂອງອິນເຕີເຟດ Map ມີວິທີການທີ່ສ້າງຂຶ້ນເຊັ່ນ: geyKey () ເພື່ອໃຫ້ໄດ້ກຸນແຈແລະ getValue () ເພື່ອໃຫ້ໄດ້ຄ່າທີ່ສອດຄ້ອງກັນ. ພວກເຮົາສາມາດໃຊ້ ຂະ ໜາດ () ວິທີການເພື່ອໃຫ້ມີຂະ ໜາດ ຂອງແຜນທີ່.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Size of map is : " + cityState.size());
    
    for(Map.Entry<String,String> m : cityState.entrySet())
    {
      System.out.println(m.getKey() + " : " + m.getValue());
    }

  }

}
Size of map is : 4
Chennai : TamilNadu
Madurai : TamilNadu
Mumbai : Maharashtra
Bangalore : Karnataka

Loop ຜ່ານອົງປະກອບຕ່າງໆໂດຍໃຊ້ keySet () ແລະຄຸນຄ່າ ()

ອີກວິທີ ໜຶ່ງ ທີ່ຈະ ໝຸນ ຜ່ານອົງປະກອບຂອງ Hashmap ແມ່ນໂດຍການໃຊ້ keySet () ວິທີການ. ການ ນຳ ໃຊ້ສິ່ງນີ້, ພວກເຮົາສາມາດໄດ້ຮັບຊຸດຂອງຄີທັງ ໝົດ ແຍກຕ່າງຫາກດັ່ງທີ່ເຫັນໃນຕົວຢ່າງລຸ່ມນີ້. ເພື່ອໃຫ້ໄດ້ຄຸນຄ່າທັງ ໝົດ ແຍກຕ່າງຫາກ, ພວກເຮົາສາມາດໃຊ້ ຄຸນຄ່າ () ວິທີການແລະການພິມໃຫ້ເຂົາເຈົ້າໃນ loop.

ການໃຊ້ keySet, ພວກເຮົາຍັງສາມາດພິມຄູ່ຄ່າທີ່ ສຳ ຄັນໄດ້ໂດຍການແກ້ແຄ້ນ ສຳ ລັບ loop ໂດຍການ ນຳ ໃຊ້ ໄດ້ຮັບ () ວິທີການເພື່ອໃຫ້ໄດ້ຄຸນຄ່າທີ່ສອດຄ້ອງກັນ.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Printing only keys:");
    for(String s : cityState.keySet())
    {
      System.out.println(s);
    }
    System.out.println();
    System.out.println("Printing only values: ");
    for(String c : cityState.values())
    {
      System.out.println(c);
    }
    System.out.println();
    System.out.println("Printing both key-value pairs:");
    for(String v : cityState.keySet())
    {
      System.out.println("Key: " + v + " | value: " + cityState.get(v));
    }
  }

}
Printing only keys:
Chennai
Madurai
Mumbai
Bangalore

Printing only values: 
TamilNadu
TamilNadu
Maharashtra
Karnataka

Printing both key-value pairs:
Key: Chennai | value: TamilNadu
Key: Madurai | value: TamilNadu
Key: Mumbai | value: Maharashtra
Key: Bangalore | value: Karnataka

ສະຫຼຸບ

ໃນບົດສອນນີ້, ທ່ານໄດ້ຮຽນຮູ້ກ່ຽວກັບ HashMap ແລະວິທີການທີ່ແຕກຕ່າງກັນພ້ອມກັບຕົວຢ່າງຕ່າງໆ.

ກະສານອ້າງອີງ