Tatalakayin ng write-up na ito ang mga diskarte sa pag-ulit ng 'HashMap' sa Java.
Ano ang HashMap sa Java?
isang ' HashMap 'nag-iimbak ng mga item sa anyo ng ' key-value ” pares at ang mga ito ay maaaring gamitin ng isang index ng anumang iba pang uri (hal., String). Pinapayagan din nito ang pag-iimbak ng mga null key.
Paano Mag-ulit ng isang HashMap sa Java?
Ang isang HashMap sa Java ay maaaring ulitin gamit ang ibinigay na mga diskarte sa ibaba:
Diskarte 1: Ulitin ang isang HashMap sa Java Gamit ang 'para sa' Loop
Ang ' entrySet() ” paraan ay nagbibigay ng isang set view ng lahat ng mga entry/elemento na nilalaman sa isang hashmap. Ang ' getKey() 'at' getValue() Kinukuha ng mga pamamaraan ang susi at halaga mula sa entry, ayon sa pagkakabanggit. Ang mga pamamaraang ito ay maaaring ilapat sa kumbinasyon upang unang ma-access ang hashmap at umulit sa pamamagitan ng mga naipong key at value gamit ang “ para sa ” loop.
Syntax
hashmap. entrySet ( )
Sa syntax sa itaas, ' hashmap 'ay tumutukoy sa isang' HashMap ” bagay ng klase.
Halimbawa
Tingnan natin ang halimbawang ibinigay sa ibaba:
angkat java.util.HashMap ;
angkat java.util.Map ;
pampubliko klase Halimbawa {
pampubliko static walang bisa pangunahing ( String args [ ] ) {
Mapa < Integer , String > custom_hashmap = bago HashMap < Integer , String > ( ) ;
custom_hashmap. ilagay ( 1 , 'Harry' ) ;
custom_hashmap. ilagay ( 2 , 'David' ) ;
custom_hashmap. ilagay ( 3 , 'Sara' ) ;
para sa ( Mapa . Pagpasok < Integer , String > itakda : custom_hashmap. entrySet ( ) ) {
Sistema . palabas . println ( itakda. getKey ( ) + ':' + itakda. getValue ( ) ) ;
} }
}
Sa ibinigay na code sa itaas:
- Una, lumikha ng ' HashMap ' pinangalanan ' custom_hashmap ” na ang susi ay tinukoy bilang isang “ integer ” at halaga bilang “ string ” na kinakatawan sa code bilang “ Mapa
- Pagkatapos nito, iugnay ang ' ilagay() 'paraan na may hashmap upang ipasok ang mga nakasaad na halaga sa anyo ng ' key-value ” pares.
- Ngayon, ilapat ang ' para sa ' loop na sinamahan ng ' entrySet() ” paraan para umulit sa hashmap.
- Tandaan na ang tinukoy na ' Mapa.Entry ” interface ay nagbibigay-daan sa gumagamit na magtrabaho sa isang entry sa mapa.
- Panghuli, ilapat ang ' getKey() 'at' getValue() ” na paraan upang ma-access ang mga inilalaang key at value at ipakita ang mga ito.
Output
Sa output na ito, masusuri na ang nakatakdang key-value pairs ay inuulit at ipinapakita.
Diskarte 2: Ulitin ang isang HashMap sa Java Gamit ang Paraang 'forEach()'.
Ang ' forEach() 'Ang paraan ay ginagamit upang maglapat ng isang partikular na operasyon para sa bawat elemento. Ang pamamaraang ito ay maaaring ipatupad upang simpleng umulit sa bawat pares ng key-value sa ' HashMap ” at ipakita ito.
Syntax
para sa bawat ( kasama sobrang AT > x )Sa syntax sa itaas, ang pamamaraang ito ay tumatagal ng isang parameter ' x ” na tumutugma sa aksyon na kailangang isagawa para sa bawat elemento.
Halimbawa
Sundin natin ang nakasaad sa ibaba na code:
angkat java.util.HashMap ;angkat java.util.Map ;
pampubliko klase Halimbawa {
pampubliko static walang bisa pangunahing ( String args [ ] ) {
Mapa < Integer , String > custom_hashmap = bago HashMap < Integer , String > ( ) ;
custom_hashmap. ilagay ( 1 , 'Harry' ) ;
custom_hashmap. ilagay ( 2 , 'David' ) ;
custom_hashmap. ilagay ( 3 , 'Sara' ) ;
custom_hashmap. para sa bawat ( ( susi, halaga ) -> Sistema . palabas . println ( susi + ':' + halaga ) ) ;
} }
Sa ilustrasyon sa itaas:
- Alalahanin ang mga tinalakay na paraan upang makabuo ng ' HashMap ” at ilaan ang mga halaga sa anyo ng “ key-value ” pares.
- Ngayon, iugnay ang ' forEach() 'paraan na may nilikhang HashMap at ipakita ang bawat isa sa inuulit na ' key-value ” pares sa console.
Output
Tulad ng makikita mo na ang mga susi at ang kanilang mga katumbas na halaga sa ' HashMap ” ay inuulit.
Diskarte 3: Ulitin ang isang HashMap sa Java Gamit ang Bagay na 'Iterator'.
Ang ' Tagapag-ulit 'Ang bagay ay ginagamit upang i-loop ang mga elemento nang paisa-isa, at ang ' iterator() ” na paraan ay maaaring gamitin upang kumuha ng Iterator. Ang ' mayNext() Ang 'paraan ay nagbibigay' totoo ” kung mayroong susunod na elemento na nakapaloob sa hashmap, at ang “ susunod() ” paraan ay nagbibigay ng susunod na elemento ng hashmap. Ang mga pamamaraang ito ay maaaring ilapat sa kumbinasyon upang umulit sa pamamagitan ng HashMap, tingnan kung may susunod na pares ng key-value, at kunin ito.
Syntax
Tagapag-ulit iter = x. umuulit ( ) ;Sa syntax na ito:
- “ x ” ay isang bagay na koleksyon.
- “ iter Ang ” ay may uri na interface ng Iterator at tumutugma sa “ x ”.
Halimbawa
Tingnan natin ang halimbawang ibinigay sa ibaba:
angkat java.util.Iterator ;angkat java.util.Map.Entry ;
angkat java.util.HashMap ;
angkat java.util.Map ;
pampubliko klase Halimbawa {
pampubliko static walang bisa pangunahing ( String args [ ] ) {
Mapa < Integer , String > custom_hashmap = bago HashMap < Integer , String > ( ) ;
custom_hashmap. ilagay ( 1 , 'Harry' ) ;
custom_hashmap. ilagay ( 2 , 'David' ) ;
custom_hashmap. ilagay ( 3 , 'Sara' ) ;
Tagapag-ulit < Pagpasok < Integer , String >> iter = custom_hashmap. entrySet ( ) . umuulit ( ) ;
habang ( iter. maySusunod ( ) ) {
Mapa . Pagpasok < Integer , String > italaga = ( Mapa . Pagpasok < Integer , String > ) iter. susunod ( ) ;
Sistema . palabas . println ( italaga. getKey ( ) + ':' + italaga. getValue ( ) ) ;
} } }
Sa demonstrasyon sa itaas, ilapat ang mga sumusunod na hakbang:
- Ulitin ang tinalakay na mga pamamaraan para sa paglikha ng ' HashMap 'at paglalaan ng' key-value ” pares.
- Ngayon, iugnay ang ' Tagapag-ulit ” object gamit ang nilikhang HashMap at i-loop ang key-value pairs sa tulong ng “ entrySet() 'at' iterator() ' paraan.
- Panghuli, suriin ang HashMap sa pamamagitan ng pagsuri sa susunod na elemento sa pamamagitan ng inilapat na “ mayNext() ” paraan. Kung gayon, ipakita ang susunod na elemento gamit ang ' susunod() ” paraan.
- Ang kalakip na ' getKey() 'at' getValue() Ang mga pamamaraan ay titiyakin na ang naipon na elemento ay kinukuha sa anyo ng isang ' key-value ” pares.
Output
Ang output sa itaas ay nagpapahiwatig na ang pag-ulit ay tapos na nang naaangkop.
Konklusyon
isang ' HashMap 'nag-iimbak ng mga item sa ' key-value ” pares. Maaari itong ulitin sa tulong ng ' para sa 'loop, ang' forEach() 'paraan, o ang' Tagapag-ulit ” bagay. Ang pag-ulit sa isang HashMap ay maaaring gawin nang simple, sa pamamagitan ng pag-access sa bawat pares ng key-value, o sa pamamagitan ng pagsangguni sa susunod na elemento, ayon sa pagkakabanggit. Ang blog na ito ay nagpaliwanag sa mga diskarte sa pag-ulit ng isang HashMap sa Java.