ஜாவாவில் கட்டமைக்கப்பட்ட தரவைச் சேமிக்க hashmap ஆனதுஒரு பயனுள்ள வழியாகும். ஜாவா நிரலாக்க மொழியில், hashmap என்பது தொடர்புடைய மதிப்புகளின் பட்டியலாகும். தரவுகளைச் சேமிக்க ஜாவா ஆனது hashmapsஐ பயன்படுத்தி கொள்கிறது. நாம் நிறைய கட்டமைக்கப்பட்ட தரவுகளை வைத்தி ருந்தால், இதன்மூலம் கிடைக்கக்கூடிய பல்வேறு மீட்டெடுப்பு வழிமுறைகளை அறிந்து கொள்வது பயனுள்ளதாக இருக்கின்ற. இந்த hashmapஐ உருவாக்கிடுக அதாவது இந்த hashmapஇன் இனத்தை பதிவிறக்கம் செய்து பயன்படுத்துவதன் மூலம் ஜாவாவில் hashmapஐ உருவாக்கிடுக. இந்த hashmapஐ உருவாக்கும்போது, சரியான மதிப்பை (முழுஎண் அல்லது சரம் போன்றவை) வரையறுக்க வேண்டும் என்ற செய்தியை மட்டும் மனதில்கொள்க. ஒரு hashmap ஆனது இரட்டை மதிப்புகளைக் கொண்டுள்ளது. அதற்கான மாதிரி நிரலாக்கம்
package com.opensource.example;
import java.util.HashMap;
public class Mapping {
public static void main(String[] args) {
HashMap<String, String> myMap = new HashMap<>();
myMap.put(“foo”, “hello”);
myMap.put(“bar”, “world”);
System.out.println(myMap.get(“foo”) + ” ” + myMap.get(“bar”));
System.out.println(myMap.get(“hello”) + ” ” + myMap.get(“world”));
}
}
இதில் putஎனும் வழிமுறையானது நம்முடைய hashmapஇல் தரவைகூடுதலாகச் சேர்க்க நம்மை அனுமதிக்கிறது, மேலும் get எனும் வழிமுறையானது hashmap இலிருந்து தரவை மீட்டெடுக்கிறது. இதனுடைய வெளியீட்டைக் காண இந்த குறிமுறைவரிகளை இயக்கிடுக. நாம் main.java என்ற கோப்பில் இந்த குறிமுறைவரிகளைச் சேமித்துள்ளதாகக் கொண்டால், அதை java எனும் கட்டளைவரி மூலம் நேரடியாக இயக்கலாம்:
$ java ./main.java
hello world
null null
hashmapஇல் இரண்டாவது மதிப்புகளை அழைப்பது பூஜ்யமாக மாறும், எனவே முதல் மதிப்பு அடிப்படையில் இரண்டாவது மதிப்பு ஒரு முக்கியமானதாகும். இது சில மொழிகளில் அகராதி அல்லது துணை அணிவரிசை என அழைக்கப்படுகிறது. ஜாவாவை உருவாக்கும் போது என்ன எதிர்பார்க்க வேண்டும் என நாம் சொல்லும் வரை, hashmapஇல் நாம் வைக்கும் தரவு வகைகளை கலந்து பொருத்தலாம்அதற்கான குறிமுறைவரிகள் பின்வருமாறு:
package com.opensource.example;
import java.util.HashMap;
public class Mapping {
public static void main(String[] args) {
HashMap<Integer, String> myMap = new HashMap<>();
myMap.put(71, “zombie”);
myMap.put(2066, “apocalypse”);
System.out.println(myMap.get(71) + ” ” + myMap.get(2066));
}
}
இந்த குறிமுறைவரிகளை இயக்கிடுக:
$ java ./main.java
ஜாம்பி பேரழிவு ஒவ்வொன்றிற்கும் ஒரு hashmap மூலம் மீண்டும் செய்க hashmapஇல் அனைத்து இரட்டையானதரவுகளையும் மீட்டெடுக்க பல வழிமுறைகள் உள்ளன, ஆனால் மிகவும் நேரடியான முறை for Eachஎனும் மடக்கிவழிமுறையாகும் அதற்கான குறிமுறைவரிகள் பின்வருமாறு:
package com.opensource.example;
import java.util.HashMap;
public class Mapping {
public static void main(String[] args) {
HashMap<String, String> myMap = new HashMap<>();
myMap.put(“foo”, “hello”);
myMap.put(“bar”, “world”);
// retrieval
myMap.forEach( (key, value) ->
System.out.println(key + “: ” + value));
}
}
இந்த குறிமுறைவரிகளை இயக்கிடுக:
$ java ./main.java
bar: world
foo: hello
கட்டமைக்கப்பட்ட தரவு சில நேரங்களில் ஜாவா hashmapஐப் பயன்படுத்துவது அர்த்தமுள்ளதாக இருக்கும், எனவே நாம் ஏராளமானவகைகளில் தனிப்பட்ட மாறிகளைக் கண்காணிக்க வேண்டியதில்லை. ஒரு கணினிமொழியில் தரவை எவ்வாறு கட்டமைப்பது மீட்டெடுப்பது என்பதை புரிந்துகொண்டவுடன், சிக்கலான தரவை ஒழுங்கமைக்கப்பட்ட வசதியான முறையில் உருவாக்க நமக்கு அதிகாரம் கிடைக்கும். ஜாவாவில் நமக்கு தேவைப்படும் ஒரே தரவு அமைப்பு hashmap அன்று, ஆனால் தொடர்புடைய தரவுகளுக்கு இது மிகச்சிறந்த ஒன்றாகும் என்ற செய்தியை மனதில் கொள்க..