ஜாவாவில் வரைபட இடைமுகம்

ஜாவா மேப் இடைமுகம் என்றால் என்ன

ஜாவா மேப் இடைமுகம் ஜாவா சேகரிப்பு கட்டமைப்பின் ஒரு பகுதியாகும், ஆனால் இது சேகரிப்பு இடைமுகத்தின் துணை வகை அல்ல. எனவே, பட்டியல்கள் அல்லது பிற சேகரிப்புப் பொருள்களுடன் ஒப்பிடும்போது இது வேறுபட்ட முறையில் செயல்படுகிறது. Map<Key, Value> இன் ஒவ்வொரு உறுப்பும் ஒரு முக்கிய-மதிப்பு ஜோடியைக் குறிக்கிறது. விசை மற்றும் மதிப்பு இரண்டும் சில பொருள்கள். ஒரு குறிப்பிட்ட வரைபடத்தில் உள்ள அனைத்து விசைகளும் தனிப்பட்டவை, அதே சமயம் மதிப்புகள் இல்லை, எனவே அவை நகலெடுக்கப்படலாம். ஜாவாவில் ஒரு வகையான அகராதி அல்லது ஆன்லைன் ஷாப் பட்டியல் போன்ற வரைபடத்தைப் பற்றி நீங்கள் நினைக்கலாம், அங்கு நீங்கள் எந்தப் பொருளையும் அதன் தனித்துவமான குறியீட்டைப் பயன்படுத்திக் காணலாம். விசை என்பது வரைபடத்தில் உள்ள மதிப்பின் தனித்துவமான அடையாளங்காட்டியாகும். எடுத்துக்காட்டாக, Map<ஸ்ட்ரிங், உருப்படி> சரம் என்பது ஆன்லைன் கடையில் உள்ள சில பொருட்களின் ஐடி. ஆவணங்களின்படி வரைபடம் பின்வரும் துணை இடைமுகங்களைக் கொண்டுள்ளது:

பிணைப்புகள் ;

ConcurrentMap<K,V> ;

ConcurrentNavigableMap<K,V> ;

தருக்கச் செய்தி சூழல் ;

செய்தி சூழல் ;

NavigableMap<K,V> ;

SOAPMessageContext ;

வரிசைப்படுத்தப்பட்ட வரைபடம்<K,V> .

மற்றும் வகுப்புகளை செயல்படுத்துகிறது:

சுருக்க வரைபடம்
பண்புக்கூறுகள்
AuthProvider
ConcurrentHashMap
ConcurrentSkipListMap
EnumMap
ஹாஷ்மேப்
ஹேஷ்டபிள்
அடையாளம் ஹாஷ்மேப்
LinkedHashMap
பிரிண்டர்ஸ்டேட் காரணங்கள்
பண்புகள்
வழங்குபவர்
ரெண்டரிங் குறிப்புகள்
எளிய பிணைப்புகள்
டேபுலர் டேட்டா ஆதரவு
மர வரைபடம்
UIDfaults
பலவீனமான ஹாஷ்மேப்

Java AbstractMap என்பது பெரும்பாலான வரைபட இடைமுகத்தை செயல்படுத்தும் ஒரு சுருக்க வகுப்பாகும்.
ஜாவா ஹாஷ்மேப் என்பது ஹாஷ் டேபிளைப் பயன்படுத்தி விசை-மதிப்பு ஜோடிகளை சேமிப்பதற்கான தரவு கட்டமைப்பாகும்.
ஜாவா ட்ரீமேப் என்பது ஒரு மரத்தைப் பயன்படுத்துவதற்கான தரவுக் கட்டமைப்பாகும், அதாவது வரிசைப்படுத்தப்பட்ட விசைகளுடன் காட்சிப்படுத்தப்படும்.
பலவீனமான விசைகள் கொண்ட ஹாஷ் அட்டவணையைப் பயன்படுத்த WeakHashMap , குப்பை சேகரிப்பாளரால் நீக்கப்படும் மதிப்புகளுடன் காட்சிப்படுத்தவும், அவை பயன்படுத்தப்படாவிட்டால்.
LinkedHashMap என்பது உறுப்புகளைச் சேர்க்கும் வரிசையுடன் கூடிய வரைபடமாகும், இது செருகும் வரிசையில் மீண்டும் செய்ய அனுமதிக்கிறது.
EnumMap enum விசைகளுடன் பயன்படுத்த AbstractMap வகுப்பை நீட்டிக்கிறது .

IdentityHashMap ஆவணங்களை ஒப்பிட்டுப் பார்க்கும் போது குறிப்புச் சமநிலைச் சரிபார்ப்பைப் பயன்படுத்துகிறது, சமம்() முறைக்குப் பதிலாக == செயல்பாட்டைப் பயன்படுத்தி ஒப்பிடும்போது விசைகளுடன் மேப்பிங் செய்யப்படுகிறது.

வரைபட இடைமுகத்தின் மிகவும் பிரபலமான செயலாக்கங்களில் நாங்கள் ஆர்வமாக உள்ளோம்: HashMap, TreeMap மற்றும் LinkedHashMap. மூலம், வரைபட உறுப்புகளின் வரிசை குறிப்பிட்ட செயலாக்கங்களைப் பொறுத்தது. கூறுங்கள், TreeMap மற்றும் LinkedHashMap ஆகியவை கூறுகளின் யூகிக்கக்கூடிய வரிசையைக் கொண்டுள்ளன, அதே நேரத்தில் HashMap இல்லை.

வரைபட முறைகள்

எந்தவொரு வரைபடத்தின் முக்கிய செயல்பாடுகள் செருகல், நீக்குதல் மற்றும் உறுப்புகளைத் தேடுதல்.

பொதுப் பொருள் போடுதல் (பொருள் விசை, பொருள் மதிப்பு) வரைபடத்தில் ஒரு உறுப்பைச் செருகுகிறது.
public void putAll(வரைபட வரைபடம்) குறிப்பிட்ட வரைபடத்தை வரைபடத்தின் உள்ளே செருகுகிறது.
பொது பொருள் அகற்று (பொருள் விசை) குறிப்பிட்ட விசையின் படி ஒரு உள்ளீட்டை நீக்குகிறது.
பொது பொருள் பெறுதல் (பொருள் விசை) குறிப்பிட்ட விசைக்கான மதிப்பை வழங்குகிறது.
public boolean containsKey(ஆப்ஜெக்ட் கீ) இந்த வரைபடத்திலிருந்து குறிப்பிட்ட விசையைத் தேடுகிறது
public Set keySet() ஆனது அனைத்து விசைகளையும் கொண்ட ஒரு செட் காட்சியை வழங்குகிறது
public Set entrySet() ஆனது அனைத்து விசைகள் மற்றும் மதிப்புகளுடன் ஒரு செட் காட்சியை வழங்குகிறது.

ஹாஷ்மேப் என்றால் என்ன

ஹாஷ்மேப் என்றால் என்ன? இது Map<Key,Value> இடைமுகத்தின் மிகவும் பிரபலமான செயலாக்கமாகும். இந்த தரவு அமைப்பு ஹாஷிங் கொள்கையை அடிப்படையாகக் கொண்டது.

ஹாஷ்மேப் வேலையின் முக்கிய கொள்கை: ஹாஷிங்

ஹாஷ்மேப் என்றால் என்ன, அது எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்து கொள்ள, முதலில் ஹாஷிங் மற்றும் ஹாஷ் செயல்பாடுகளைப் பற்றி பேசலாம். ஒரு ஹாஷ் செயல்பாடு என்பது கணித அர்த்தத்தில் ஒரு செயல்பாடு. எனவே சில உள்ளீட்டு மதிப்பு (ஒரு பொருள், தரவுத் துண்டு) உள்ளது மற்றும் செயல்பாடு அதை சரியான விதியைப் பயன்படுத்தி வெளியீட்டு மதிப்பாக மாற்றுகிறது - ஹாஷ். பெரும்பாலும் ஹாஷ் என்பது சரியான நீளத்தின் ஹெக்ஸாடெசிமல் எண்ணாகும். செயல்முறைகளை மாற்றுவதற்கான விதிகள் வேறுபட்டிருக்கலாம், ஆனால் அவை பின்வரும் கொள்கைகளுக்கு உட்பட்டவை:

ஒரு குறிப்பிட்ட உள்ளீடு (பொருள்) ஒரு குறிப்பிட்ட ஹாஷ் குறியீட்டைக் கொண்டுள்ளது.
இரண்டு பொருள்கள் சமமாக இருந்தால், அவற்றின் ஹாஷ் குறியீடுகளும் சமமாக இருக்கும். தலைகீழ் உண்மை இல்லை.
ஹாஷ் குறியீடுகள் வேறுபட்டால், பொருள்கள் நிச்சயமாக சமமாக இருக்காது.
சில நேரங்களில் வெவ்வேறு பொருள்கள் ஒரே ஹாஷ் குறியீட்டைக் கொண்டிருக்கலாம். இது மிகவும் சாத்தியமில்லாத நிகழ்வாகும், இது "மோதல்" என்று பெயரிடப்பட்டது மற்றும் ஒரு நல்ல தரமான ஹாஷ் செயல்பாடு மோதல்களின் நிகழ்தகவைக் குறைக்க வேண்டும்.

ஜாவாவில், ஒவ்வொரு பொருளுக்கும் ஹாஷ் குறியீடு உள்ளது. இது ஆப்ஜெக்ட் கிளாஸ், அனைத்து ஜாவா ஆப்ஜெக்ட்களின் பெற்றோர் வகுப்பின் ஹாஷ்கோட் முறையால் கணக்கிடப்படுகிறது. வழக்கமாக, டெவலப்பர்கள் தங்கள் சொந்த வகுப்புகளுக்காகவும், அதனுடன் தொடர்புடைய சமமான முறைகளுக்காகவும் இந்த முறையை மீறுகின்றனர்.

ஹாஷ்மேப்: இது எப்படி வேலை செய்கிறது

ஒவ்வொரு வரைபட செயலாக்கமும் விசைகள் மற்றும் மதிப்புகளைக் கொண்டிருப்பதால் வகுப்பு HashMap<K,V>. இது ஹாஷிங் கொள்கைகளைப் பயன்படுத்தி விசைகளைச் சேமிக்கிறது. HashMap விசை-மதிப்பு ஜோடிகளுக்குள் "வாளிகளில்" சேமிக்கப்படுகிறது, இந்த வாளிகள் ஒன்றாக ஒரு "அட்டவணை"யை உருவாக்குகின்றன, இணைக்கப்பட்ட பட்டியல்களின் உள் வரிசை மற்றும் அதன் ஆரம்ப அளவு 16 ஆகும்.. ஜாவாவில் உள்ள ஹாஷ்மேப், விசை/மதிப்பு ஜோடியை வரைபடமாக்க வேண்டிய பக்கெட்டைத் தீர்மானிக்க, விசையின் ஹாஷ்கோடைப் பயன்படுத்துகிறது: ஹாஷ்மேப்பின் தந்திரமான அம்சம் என்னவென்றால், டேபிளின் ஒவ்வொரு கலமும் (வாளி) ஒரு ஜோடியை மட்டும் வைத்திருக்காது. அவை வெளிப்படையான பொருளாக (LinkedList போன்றவை) சேமிக்கப்படவில்லை, ஆனால் ஒரு மறைமுகமான சங்கிலியாக. ஒவ்வொரு ஜோடியும் அடுத்த ஜோடிக்கான இணைப்பைச் சேமித்து வைப்பதால் சங்கிலி உருவாக்கப்பட்டது. அதாவது, அனைத்து ஹாஷ்மேப் ஜோடிகளும் 16 சங்கிலிகளில் சிதறிக்கிடக்கின்றன. நீங்கள் ஒரு புதிய ஜோடியை அட்டவணையில் வைக்கும்போது, சாவியின் ஹாஷ் கருதப்படுகிறது. இந்த ஹாஷ் முக்கிய பொருளில் கட்டமைக்கப்பட்ட ஹாஷ்கோட் செயல்பாடு அல்ல. இது 0-15 வரம்பில் இருப்பதாகக் கருதப்படுகிறது. ஹாஷ் குறியீட்டுடன் வாளியில் சேமிக்கப்பட்ட ஜோடிகளின் சங்கிலியில் ஜோடி சேர்க்கப்படுகிறது. இந்த அணுகுமுறை தேடல் முடுக்கத்தை அளிக்கிறது. விசை மூலம் ஒரு ஜோடியைத் தேடும் போது, முழு அட்டவணையிலும் செல்ல வேண்டிய அவசியமில்லை. விசையின் ஹாஷ் கருதப்படுகிறது மற்றும் ஹாஷ் குறியீட்டுடன் கலத்தில் சேமிக்கப்படும் சங்கிலி மட்டுமே சரிபார்க்கப்படுகிறது. HashMap இல் பல ஜோடிகள் இருந்தால், சங்கிலிகள் மிக நீளமாகிவிடும். பின்னர் வரிசையின் அளவு அதிகரிக்கிறது, சேமிக்கப்பட்ட அனைத்து பொருட்களின் ஹாஷ் மீண்டும் கணக்கிடப்படுகிறது, மேலும் அவை புதிய சங்கிலிகளுடன் சிதறடிக்கப்படுகின்றன.

ஹாஷ்மேப் பிரகடனம்

நீங்கள் வகுப்பு HashMap குறியீட்டிற்குச் சென்றால், அடுத்த அறிவிப்பைக் காண்பீர்கள்:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

K என்பது இந்த வரைபடத்தால் பராமரிக்கப்படும் விசைகளின் வகை மற்றும் V - வரைபட மதிப்புகளின் வகை. இது உங்கள் குறியீட்டில் உள்ள முழு எண் விசை மற்றும் சர மதிப்புடன் கூடிய HashMap அறிவிப்புக்கான எடுத்துக்காட்டு:

HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

ஹாஷ்மேப் முறைகள்

ஹாஷ்மேப் முறைகளின் பட்டியல் இங்கே.

ஆப்ஜெக்ட் கெட்(ஆப்ஜெக்ட் கீ) குறிப்பிட்ட விசைக்கான மதிப்பை வழங்குகிறது;
ஆப்ஜெக்ட் புட்(விசை கே, மதிப்பு v) வரைபடத்தில் முக்கிய மதிப்பை மேப்பிங்கைச் செருகுகிறது;
ஆப்ஜெக்ட் ரிமூவ் (ஆப்ஜெக்ட் கீ) இந்த வரைபடத்தில் இருந்தால் குறிப்பிட்ட விசைக்கான மேப்பிங்கை நீக்குகிறது;
void clear() HashMap இலிருந்து அனைத்து முக்கிய-மதிப்பு ஜோடிகளையும் நீக்குகிறது;
ஆப்ஜெக்ட் குளோன்() விசைகள் மற்றும் மதிப்புகளை குளோனிங் செய்யாமல் இந்த ஹாஷ்மேப் நிகழ்வின் ஆழமற்ற நகலை வழங்குகிறது;
வரைபடத்தில் குறிப்பிட்ட விசை காணப்பட்டால் boolean containsKey(ஆப்ஜெக்ட் கீ) உண்மை என்பதைத் தரும், இல்லையெனில் தவறு;
boolean containsValue(ஆப்ஜெக்ட் மதிப்பு) வரைபடத்தில் குறிப்பிடப்பட்ட விசை காணப்பட்டால் உண்மை என்பதை வழங்கும், இல்லையெனில் தவறு;
வரைபடம் காலியாக இருந்தால் boolean isEmpty() உண்மை, இல்லையெனில் தவறு என வழங்கும்;
செட் கீசெட்() வரைபடத்திலிருந்து பெறப்பட்ட விசைகளின் தொகுப்பை வழங்குகிறது;
int size() முக்கிய மதிப்பு மேப்பிங்கின் அளவை வழங்குகிறது;
சேகரிப்பு மதிப்புகள்() வரைபடத்தின் மதிப்புகளின் தொகுப்பை வழங்குகிறது;
ஆப்ஜெக்ட் ரிமூவ் (ஆப்ஜெக்ட் கீ) குறிப்பிட்ட விசைக்கான விசை-மதிப்பு ஜோடியை நீக்குகிறது;
void putAll(Map m) வரைபடத்தின் அனைத்து கூறுகளையும் மற்ற வரைபடத்திற்கு நகலெடுக்கிறது.

ஜாவா ஹாஷ்மேப் உதாரணம்

ஜாவா ஹாஷ்மேப் எடுத்துக்காட்டுடன் ஒரு நிரலை உருவாக்குவோம், அது எவ்வாறு செயல்படுகிறது என்பதை விளக்கவும்:

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;

public class HashMap {

   public static void main(String[] args) {

       {

           // HashMap declaration
           HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

           //Adding elements into HashMap
           myHashMap.put(7, "Johnny");
           myHashMap.put(8, "Ivy");
           myHashMap.put(1, "Rick");
           myHashMap.put(4, "Stan");
           myHashMap.put(3, "Kyle");

           //print out the map content using Iterator
           Set set = myHashMap.entrySet();
           Iterator iterator = set.iterator();
           while (iterator.hasNext()) {
               Map.Entry mapEntry = (Map.Entry) iterator.next();
               System.out.print("key: " + mapEntry.getKey() + " value: ");
               System.out.println(mapEntry.getValue());
           }
           System.out.println("get an element from myHashMap via key and print the value out:");
           System.out.println(myHashMap.get(8));
           //print out hashMap on standard way:
           System.out.println(myHashMap);

           // Get values based on key
           String var = myHashMap.get(2);
           //here we'll get null, we don't have such a key
           System.out.println("Value with key 2: " + var);
           var = myHashMap.get(7);
           System.out.println("Value with key 7: " + var);

           // Remove values based on key
           myHashMap.remove(4);
           System.out.println("myHashMap after removing element:");
           System.out.println(myHashMap);
           myHashMap.clear();
           System.out.println("myHashMap after total clearing:");
           System.out.println(myHashMap);
       }

   }
}

நிரலை இயக்குவதன் முடிவு:

key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}

மர வரைபடம்

ஜாவாவில் உள்ள ட்ரீமேப் Map<Key,Value> இடைமுகத்தையும் செயல்படுத்துகிறது, ஆனால் இது சிவப்பு-கருப்பு மர தரவு கட்டமைப்பை அடிப்படையாகக் கொண்டது. ஒரு மரம் "முனைகள்" மற்றும் முனைகளை இணைக்கும் கோடுகளைக் கொண்டுள்ளது - கிளைகளை". "வேர்" முனை மரத்தின் உச்சியில் உள்ளது. வேரிலிருந்து கிளைகள் மற்றும் முனைகள் இருக்கலாம். இது ஒரு படிநிலை அமைப்பு, நீங்கள் நினைக்கலாம். இந்த முனைகள் வேரின் "குழந்தைகள்" ஆகும். குழந்தை முனை அதன் சொந்த குழந்தைகளைக் கொண்டிருக்கலாம் - கீழ் முனைகள். குழந்தைகள் இல்லாத முனைகள் "இறுதி முனைகள்" அல்லது "இலைகள்" என்று அழைக்கப்படுகின்றன. பைனரி மரம் என்பது ஒரு மரம், ஒவ்வொரு முனையிலும் பூஜ்ஜியம் உள்ளது, ஒன்று , அல்லது இரண்டு குழந்தைகள் பைனரி தேடல் மரம் என்பது ஒவ்வொரு உள் முனையும் ஒரு விசையையும், சில சமயங்களில் தொடர்புடைய மதிப்பையும் சேமித்து வைக்கும் ஒரு அமைப்பாகும், மேலும் இரண்டு தனிச்சிறப்புள்ள துணை மரங்களைக் கொண்டுள்ளது ("இடது" மற்றும் "வலது"). ஒரு சுய-சமநிலை பைனரி தேடல் மரம் என்பது ஒரு முனை அடிப்படையிலான பைனரி தேடல் மரமாகும், இது தன்னிச்சையான உருப்படி செருகல்கள் மற்றும் நீக்குதல்களை எதிர்கொள்ளும் போது தானாகவே அதன் உயரத்தை (வேருக்குக் கீழே உள்ள அதிகபட்ச எண்ணிக்கை) சிறியதாக வைத்திருக்கும். சிவப்பு-கருப்பு மரம் என்பது பண்புகளைக் கொண்ட ஒரு சமநிலையான பைனரி மரமாகும்:

ஒவ்வொரு முனையும் சிவப்பு அல்லது கருப்பு
வேர் எப்போதும் கருப்பு
ஒவ்வொரு இலையும் ஒரு NIL (வெற்று, பூஜ்ய) முனை மற்றும் அது கருப்பு
ஒரு முனை சிவப்பு நிறமாக இருந்தால், அதன் குழந்தைகள் கண்டிப்பாக கருப்பு நிறமாக இருக்கும்.
ஒரு முனையிலிருந்து சந்ததி இலை வரையிலான ஒவ்வொரு எளிய பாதையும் அதே எண்ணிக்கையிலான கருப்பு முனைகளைக் கொண்டுள்ளது.

ஒரு ட்ரீமேப் அம்சங்கள்

ஒரு ட்ரீமேப் விசைகளை முனைகளாகச் சேமிக்க மர தரவு கட்டமைப்பைப் பயன்படுத்துகிறது மற்றும் சிவப்பு-கருப்பு மர வழிமுறையைப் பயன்படுத்தி விசைகளை வரிசைப்படுத்துகிறது. எனவே, TreeMap அதன் உள்ளீடுகளை அதன் விசைகளின் இயல்பான வரிசைப்படி வரிசைப்படுத்துகிறது. எண்களுக்கு இயற்கையானது ஏறுவரிசை, சரங்களுக்கு - அகரவரிசை. நீங்கள் வரிசைப்படுத்தும் தர்க்கத்தை மாற்ற வேண்டும் என்றால் நீங்கள் ஒரு ஒப்பீட்டாளரைப் பயன்படுத்தலாம். இயற்கையான முறையில் பொருட்களை வரிசைப்படுத்துவது TreeMap இன் ஒரு பெரிய நன்மையாகும், அதே போல் வெவ்வேறு வடிகட்டிகள் மற்றும் நிபந்தனைகளைப் பயன்படுத்தி சில பொருட்களைக் கண்டறிவது.

ட்ரீமேப் முறைகள்

ஆப்ஜெக்ட் கெட்(ஆப்ஜெக்ட் கீ) தொடர்புடைய விசையின் மதிப்பை வழங்குகிறது;
பொருள் போடுதல் (பொருள் விசை, பொருள் மதிப்பு) ஒரு வரைபடத்தில் ஒரு மேப்பிங்கைச் செருகுகிறது;
பொருள் அகற்று(ஆப்ஜெக்ட் கீ) இந்த விசைக்கான மேப்பிங்கை ட்ரீமேப்பில் இருந்தால் அதை நீக்குகிறது;
இந்த வரைபடத்தில் குறிப்பிடப்பட்ட விசைக்கான மேப்பிங் இருந்தால் boolean containsKey(ஆப்ஜெக்ட் கீ) உண்மையாக இருக்கும்;
ட்ரீமேப் ஒன்று அல்லது அதற்கு மேற்பட்ட விசைகளை குறிப்பிட்ட மதிப்புக்கு வரைபடமாக்கினால் பூலியன் மதிப்பு (பொருளின் மதிப்பு) உண்மையாக இருக்கும்;
Object firstKey() தற்போது வரிசைப்படுத்தப்பட்ட வரைபடத்தில் உள்ள முதல் விசையை வழங்குகிறது;
Object lastKey() தற்போது வரிசைப்படுத்தப்பட்ட வரைபடத்தில் உள்ள கடைசி விசையை வழங்குகிறது;
void putAll(வரைபட வரைபடம்) அனைத்து மேப்பிங்குகளையும் குறிப்பிட்ட வரைபடத்திலிருந்து வரைபடத்திற்கு நகலெடுக்கிறது;
செட் என்ட்ரிசெட்() மேப்பிங்கின் செட் காட்சியை வழங்குகிறது
int size() முக்கிய மதிப்பு மேப்பிங்கின் அளவை வழங்குகிறது
சேகரிப்பு மதிப்புகள்() மதிப்புகளின் சேகரிப்பு காட்சியை வழங்கும்
பொருள் குளோன்() TreeMap இன் ஆழமற்ற நகலை வழங்குகிறது
void clear() TreeMap இலிருந்து அனைத்து மேப்பிங்குகளையும் நீக்குகிறது
வரிசைப்படுத்தப்பட்ட வரைபடம் ஹெட்மேப்(பொருள் விசை_மதிப்பு) அளவுரு key_value ஐ விட குறைவான வரைபடத்தின் பகுதியின் காட்சியை வழங்குகிறது
செட் கீசெட்() ஆனது ட்ரீமேப்பில் உள்ள விசைகளின் செட் காட்சியை வழங்குகிறது
வரிசைப்படுத்தப்பட்ட வரைபடம் துணைவரைபடம்(K fromKey, K toKey) இந்த வரைபடத்தின் பகுதியின் பார்வையை வழங்குகிறது, அதன் விசைகள் விசையிலிருந்து விசையிலிருந்து, டூகே வரை, பிரத்தியேகமாக இருக்கும்.
Object firstKey() TreeMap இலிருந்து முதல் விசையை வழங்குகிறது.

ட்ரீமேப் உதாரணம்

import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;

public class TreeMapExample {

   public static void main(String args[]) {

       //TreeMap declaration
       TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();

       //put elements to TreeMap
       myTreeMap.put(1, "Stuart");
       myTreeMap.put(23, "Michael");
       myTreeMap.put(7, "Johnny");
       myTreeMap.put(5, "Ivy");
       myTreeMap.put(2, "Alex");

       //Display and print out myTreeMap using Iterator
       Set set = myTreeMap.entrySet();
       Iterator iterator = set.iterator();
       while (iterator.hasNext()) {
           Map.Entry myEntry = (Map.Entry) iterator.next();
           System.out.print("key: " + myEntry.getKey() + " value: ");
           System.out.println(myEntry.getValue());
       }
       //TreeMap printed in classical way
       System.out.println(myTreeMap);
       //removing an element with the key =2
       myTreeMap.remove(2);
       //myTreeMap after removing:
       System.out.println(myTreeMap);
   }
}

நிரலை இயக்குவதன் முடிவு:

key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}

LinkedHashMap

LinkedHashMap என்பது இணைக்கப்பட்ட பட்டியல்கள் மற்றும் ஹாஷ் வரைபடங்களை இணைக்கும் தரவு கட்டமைப்பாகும். உண்மையில், LinkedHashMap HashMap வகுப்பை விரிவுபடுத்துகிறது மற்றும் வரைபட இடைமுகத்தை செயல்படுத்துகிறது, ஆனால் இணைக்கப்பட்ட பட்டியல்களைப் பற்றி என்ன? LinkedHashMap இன் அறிவிப்பு:

Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();

இந்த புதிய linkedHashMap ஆனது HashMap இலிருந்து பண்புகளைப் பெறுகிறது (அட்டவணை, loadFactor, threshold, size, entrySet போன்றவை), மேலும் இரண்டு சிறப்புப் பண்புகளைப் பெறுகிறது:

தலைப்பு என்பது இருமுறை இணைக்கப்பட்ட பட்டியலின் தலைப்பாகும். துவக்கத்தின் போது, அது தன்னைக் குறிக்கிறது
ஆக்சஸ்ஆர்டர், இட்ரேட்டரைப் பயன்படுத்தி உறுப்புகளுக்கான அணுகலை எவ்வாறு பெறுவது என்பதைக் குறிக்கிறது. உண்மை எனில், கடைசி அணுகல் வரிசையில். தவறு எனில், உறுப்புகள் செருகப்பட்ட வரிசையில் அணுகல் இருக்கும்.

இந்த இணைக்கப்பட்ட பட்டியல் மறு செய்கை வரிசையை வரையறுக்கிறது. வழக்கமாக, இது வரைபடத்தில் விசைகளை செருகும் வரிசையாகும்.

LinkedHashMap முறைகள்

ஆப்ஜெக்ட் கெட்(ஆப்ஜெக்ட் கீ) குறிப்பிடப்பட்ட விசை மேப் செய்யப்பட்ட மதிப்பை வழங்கும் அல்லது இந்த வரைபடத்தில் விசைக்கான மேப்பிங் இல்லை என்றால் பூஜ்யமாகும்
void clear() வரைபடத்திலிருந்து அனைத்து மேப்பிங்குகளையும் நீக்குகிறது.
குறிப்பிட்ட உறுப்பு ஒன்று அல்லது அதற்கு மேற்பட்ட விசைகளால் மேப் செய்யப்பட்டிருந்தால் boolean containsKey(ஆப்ஜெக்ட் கீ) உண்மையாக இருக்கும்
பூலியன் ரிமூவ்எல்டெஸ்ட்என்ட்ரி(வரைபடம்.நுழைவு எல்டஸ்ட்) வரைபடத்தில் இருந்து அதன் மூத்த உள்ளீட்டை அகற்றினால் அது உண்மையாக இருக்கும்
Set<Map.Entry<K,V>> entrySet() ஆனது இந்த வரைபடத்தில் உள்ள மேப்பிங்கின் செட் காட்சியை வழங்குகிறது
void forEach(BiConsumer<? super K,? super V> action) இந்த வரைபடத்தில் உள்ள ஒவ்வொரு உள்ளீட்டிற்கும் கொடுக்கப்பட்ட செயலை அனைத்து உள்ளீடுகளும் செயலாக்கப்படும் வரை அல்லது செயல் விதிவிலக்கு அளிக்கும் வரை செய்கிறது.
Object getOrDefault(Object key, V defaultValue) குறிப்பிடப்பட்ட விசை வரைபடமாக்கப்பட்ட மதிப்பை வழங்குகிறது. வரைபடத்தில் மேப்பிங் இல்லை என்றால், விசை இயல்புநிலை மதிப்பை வழங்குகிறது.
Set<K> keySet() ஆனது வரைபடத்தில் உள்ள விசைகளின் தொகுப்பு காட்சியை வழங்குகிறது
boolean removeEldestEntry(Map.Entry<K,V> eldest) இந்த வரைபடம் அதன் மூத்த உள்ளீட்டை நீக்க வேண்டும் எனில் உண்மை என வழங்கும்
void replaceAll(BiFunction<? super K,? super V,? extends V> function) எல்லா உள்ளீடுகளும் செயலாக்கப்படும் வரை அல்லது செயல்பாடு ஒரு விதிவிலக்கு அளிக்கும் வரை அந்த உள்ளீட்டில் கொடுக்கப்பட்ட செயல்பாட்டை செயல்படுத்துவதன் விளைவாக ஒவ்வொரு நுழைவு மதிப்பையும் மாற்றுகிறது.
சேகரிப்பு<v>மதிப்புகள்() வரைபடத்தில் உள்ள மதிப்புகளின் சேகரிப்பு காட்சியை வழங்குகிறது

LinkedHashMap உதாரணம்

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
   public class HashLinkedListExample {
       public static void main(String args[]) {
           // LinkedHashMap Declaration
           LinkedHashMap<Integer, String> myLinkedHashMap =
                   new LinkedHashMap<Integer, String>();

           //Adding elements into LinkedHashMap
           myLinkedHashMap.put(7, "Johnny");
           myLinkedHashMap.put(12, "Rick");
           myLinkedHashMap.put(1, "Kyle");
           myLinkedHashMap.put(5, "Percy");
           myLinkedHashMap.put(85, "Sebastian");

           // Generate a Set of entries
           Set set = myLinkedHashMap.entrySet();

           // Display and print out the nodes  of LinkedHashMap
           Iterator iterator = set.iterator();
           while(iterator.hasNext()) {
               Map.Entry me = (Map.Entry)iterator.next();
               System.out.print("key: "+ me.getKey() +
                       " value: "+me.getValue()+"\n");
           }
           //print out HashLinkedMap on standard way:
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(21, "Ivy");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.remove(12);
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(12, "Ronny");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(1, "Stan");
           System.out.println(myLinkedHashMap);
       }
   }

இங்கே நாம் ஒரு புதிய LinkedHashMap ஐ உருவாக்கி, ஐந்து கூறுகளைச் சேர்த்து, அதை இடிரேட்டரைப் பயன்படுத்தி கிளாசிக்கல் முறையில் அச்சிடுகிறோம். நீங்கள் பார்க்க முடியும் என, LinkedHashMap செருகும் வரிசையை பராமரிக்கிறது. அதன் பிறகு, எங்கள் வரைபடத்திலிருந்து ஒரு உறுப்பை நீக்கி, புதியதைச் சேர்க்கவும், பின்னர் - விசையுடன் மேலும் ஒரு உறுப்பு, அது ஏற்கனவே வரைபடத்தில் உள்ளது. இது இந்த விசையுடன் இணைக்கப்பட்ட பழைய மதிப்பை மாற்றுகிறது. இயங்கும் நிரலின் முடிவு:

key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}

HashMap, TreeMap, LinkedHashMap ஒப்பீடு

HashMap, TreeMap மற்றும் LinkedHashMap ஆகியவை வரைபட இடைமுகங்களின் செயலாக்கங்கள். HashMap மற்றும் LinkedHashMap ஆகியவை ஹாஷ் விசைகளைக் கொண்ட தரவு கட்டமைப்புகள். TreeMap ஒரு தேடல் மரத்தை ஒழுங்கமைக்க அதன் விசைகளின் இயல்பான வரிசையைப் பயன்படுத்துகிறது. ஆர்டர்:

HashMap எந்த வரிசையையும் பராமரிக்கவில்லை.
TreeMap விசைகளின் ஏறுவரிசையில் உள்ளீடுகளை வரிசைப்படுத்துகிறது.
LinkedHashMap செருகும் வரிசையை பராமரிக்கிறது.

பூஜ்ய விசைகள்:

HashMap மற்றும் LinkedHashMap ஒரு பூஜ்ய விசையை வைத்திருக்க அனுமதிக்கிறது.
LinkedHashMap பூஜ்ய விசைகளை அனுமதிக்காது, விசைகள் இயற்கையான வரிசையைப் பயன்படுத்தினால் அல்லது ஒப்பீட்டாளர் பூஜ்ய லேகளில் ஒப்பிடுவதை ஆதரிக்காது.

இந்தக் கட்டுரையில் மதிப்பாய்வு செய்யப்பட்ட மூன்று செயலாக்கங்களையும் உள்ளடக்கிய ஜாவா வரைபட உதாரணத்தைப் பார்ப்போம்:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class CompMapImpl {


    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        hashMap.put(5, "Ivy");
        hashMap.put(null, "Joker");
        hashMap.put(1, "First");
        hashMap.put(2, "Kyle");
        hashMap.put(-2, "Paul");
        hashMap.put(3, "Sandy");


        treeMap.put(5, "Ivy");
        //treeMap.put(null,"Joker");
        treeMap.put(1, "First");
        treeMap.put(2, "Kyle");
        treeMap.put(-2, "Paul");
        treeMap.put(3, "Sandy");

        linkedHashMap.put(5, "Ivy");
        linkedHashMap.put(null, "Joker");
        linkedHashMap.put(1, "First");
        linkedHashMap.put(2, "Kyle");
        linkedHashMap.put(-2, "Paul");
        linkedHashMap.put(3, "Sandy");
        System.out.println("HashMap");
        System.out.println(hashMap);
        System.out.println("TreeMap");
        System.out.println(treeMap);
        System.out.println("LinkedHashMap");
        System.out.println(linkedHashMap);


        LinkedHashMap<String, String> linkedHashMap1= new LinkedHashMap<> ();
        linkedHashMap1.put(null, "Andy");
        System.out.println(linkedHashMap1);
    }
}

இந்த நிரலை இயக்குவதன் முடிவு இங்கே:

HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}

நாம் பார்க்க முடியும் என, HashMap இல் உள்ள உறுப்புகளின் வரிசை தெளிவாக இல்லை, ட்ரீமேப்பில் இது விசைகளைப் பொறுத்தது, LinkedHashMap இல் இது செருகும் வரிசையைப் பற்றியது. LinkedHashMap இல் பூஜ்ய விசையை வைக்க முயற்சித்தால், NullPointerException கிடைக்கும், ஆனால் linkedHashMap1 இல், விசைகள் சரமாக இருக்கும், அதை நாம் செய்யலாம். ஹாஷ் வரைபடம் என்பது சிறந்த பொது நோக்கத்திற்கான வரைபடச் செயலாக்கமாகும். இது அதிகபட்ச தேடல் வேகம், வேகமான சேமிப்பு மற்றும் மீட்டெடுப்பு செயல்பாடுகளை வழங்குகிறது, ஆனால் அதன் குழப்பமான வரிசையை நீங்கள் நினைவில் கொள்ள வேண்டும். இணைக்கப்பட்ட ஹாஷ் வரைபடம் HashMap நன்மைகளைப் பெறுகிறது மற்றும் விசைகளுக்கான ஆர்டரைப் பெறுகிறது. இருப்பினும், இது இணைக்கப்பட்ட பட்டியலைக் கொண்டுள்ளது, இது நினைவகத்தின் அடிப்படையில் ஒப்பீட்டளவில் விலை உயர்ந்தது. இது தேடலில் HashMap ஐ விட மெதுவாகவும், இணைக்கப்பட்ட பட்டியலை பராமரிப்பதன் காரணமாக சேர்/அகற்றுவதற்கு சற்று மெதுவாகவும் உள்ளது. ஒரு மர வரைபடம் ஏறுவரிசையில் வரிசைப்படுத்தப்பட்ட விசைகளை சேமிக்கிறது. எனினும், நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்

மேலும் வாசிப்பு:
HashMap இல் ஏற்கனவே உள்ள விசையின் மதிப்பை எவ்வாறு புதுப்பிப்பது ஜாவாவில் HashMap getOrDefault முறை java.util.Map இல் கீசெட் முறை