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

TreeMap, HashMap மற்றும் LinkedHashMap ஆகியவற்றை ஒப்பிடுதல்

வரைபட இடைமுகத்தின் மிகவும் பயன்படுத்தப்படும் செயல்படுத்தல் HashMap ஆகும். இது பயன்படுத்த எளிதானது மற்றும் தரவை விரைவாக அணுகுவதற்கு உத்தரவாதம் அளிக்கிறது, எனவே பெரும்பாலான சிக்கல்களைத் தீர்ப்பதற்கான சிறந்த வேட்பாளராக இது உள்ளது. பெரும்பாலானவை, ஆனால் அனைத்தும் இல்லை. சில நேரங்களில் நீங்கள் ஒரு கட்டமைக்கப்பட்ட முறையில் தரவைச் சேமித்து அதன் மூலம் செல்ல முடியும். இந்த வழக்கில், வரைபட இடைமுகத்தின் மற்றொரு செயலாக்கம் (ட்ரீமேப்) மீட்புக்கு வருகிறது. TreeMap NavigableMap இடைமுகத்தை செயல்படுத்துகிறது , இது வரிசைப்படுத்தப்பட்ட வரைபடத்தைப் பெறுகிறது , இது வரைபட இடைமுகத்தைப் பெறுகிறது. NavigableMap மற்றும் SortedMapட்ரீமேப்பின் அம்சங்கள் - 2 இடைமுகங்களைச் செயல்படுத்துவதன் மூலம் , HashMap இல் இல்லாத கூடுதல் செயல்பாட்டை TreeMap பெறுகிறது, ஆனால் அது செயல்திறனின் அடிப்படையில் ஒரு விலையை செலுத்துகிறது. LinkedHashMap உள்ளதுவகுப்பு , இது ஒரு குறிப்பிட்ட வரிசையில் தரவைச் சேமிக்க உங்களை அனுமதிக்கிறது (வரைபடத்தில் நீங்கள் அதைச் சேர்க்கும் வரிசை). இந்த மூன்று வகுப்புகளுக்கு இடையிலான வேறுபாடுகளைப் புரிந்து கொள்ள , இந்த அட்டவணையைப் பார்க்கவும்:
ஹாஷ்மேப் LinkedHashMap மர வரைபடம்
தரவு வரிசைப்படுத்துதல் சீரற்ற. காலப்போக்கில் ஒழுங்கு பராமரிக்கப்படும் என்பதற்கு எந்த உத்தரவாதமும் இல்லை. தரவு சேர்க்கப்படும் வரிசையில் ஏறுவரிசையில் அல்லது குறிப்பிட்ட ஒப்பீட்டாளரின் அடிப்படையில்
நேரம் சிக்கலானது O(1) O(1) O(log(n))
செயல்படுத்தப்பட்ட இடைமுகங்கள் வரைபடம் வரைபடம் NavigableMap
வரிசைப்படுத்தப்பட்ட
வரைபடம் வரைபடம்
தரவு அமைப்பு வாளிகள் வாளிகள் சிவப்பு-கருப்பு மரம்
பூஜ்ய விசைக்கான ஆதரவா? ஆம் ஆம் ஆம், நீங்கள் ஒரு ஒப்பீட்டாளரைப் பயன்படுத்தினால், அது பூஜ்யத்தை அனுமதிக்கிறது
நூல் பாதுகாப்பானதா? இல்லை இல்லை இல்லை
நீங்கள் பார்க்க முடியும் என, இந்த வகுப்புகள் பொதுவானவை, ஆனால் பல வேறுபாடுகள் உள்ளன. TreeMap வகுப்பு மிகவும் பல்துறையாக இருந்தாலும், அது எப்போதும் பூஜ்யத்தை ஒரு விசையாக சேமிக்க முடியாது. கூடுதலாக, ட்ரீமேப்பின் கூறுகளை அணுகுவதற்கு அதிக நேரம் எடுக்கும். எனவே, நீங்கள் சில வரிசைப்படுத்தப்பட்ட வரிசையில் தரவைச் சேமிக்கத் தேவையில்லை என்றால், HashMap அல்லது LinkedHashMap ஐப் பயன்படுத்துவது நல்லது .

சிவப்பு-கருப்பு மரம்

ஹூட்டின் கீழ், ட்ரீமேப் சிவப்பு-கருப்பு மரம் எனப்படும் தரவு கட்டமைப்பைப் பயன்படுத்துவதை நீங்கள் கவனித்திருக்கலாம். இந்தக் கட்டமைப்பில் தரவைச் சேமிப்பதுதான் தரவு வரிசைப்படுத்துதலைத் துல்லியமாக வழங்குகிறது. எனவே இது என்ன வகையான மரம்? கண்டுபிடிக்கலாம்! நீங்கள் எண்-ஸ்ட்ரிங் ஜோடிகளை சேமிக்க வேண்டும் என்று கற்பனை செய்து பாருங்கள். 16, 20, 52, 55, 61, 65, 71, 76, 81, 85, 90, 93 மற்றும் 101 ஆகிய எண்கள் விசைகளாக இருக்கும். நீங்கள் ஒரு பாரம்பரிய பட்டியலில் தரவைச் சேமித்து, முக்கிய 101 உடன் உறுப்பைக் கண்டுபிடிக்க வேண்டும் என்றால், அதைக் கண்டுபிடிக்க நீங்கள் அனைத்து 13 கூறுகளிலும் செல்ல வேண்டும். 13 உறுப்புகளுக்கு, இது ஒரு பெரிய விஷயமல்ல, ஆனால் ஒரு மில்லியனுடன் பணிபுரியும் போது, ​​எங்களுக்கு பெரிய சிக்கல்கள் ஏற்படும். இந்த சிக்கல்களைத் தீர்க்க, புரோகிராமர்கள் சற்று சிக்கலான தரவு கட்டமைப்புகளைப் பயன்படுத்துகின்றனர். இங்குதான் சிவப்பு-கருப்பு மரம் மேடைக்குள் நுழைகிறது!ட்ரீமேப்பின் அம்சங்கள் - 3ஒரு தனிமத்திற்கான தேடல் மரத்தின் வேரில் தொடங்குகிறது, இது எங்கள் விஷயத்தில் 61 ஆகும். பிறகு நாம் தேடும் மதிப்புடன் முனை மதிப்புகளை ஒப்பிடுகிறோம். நமது மதிப்பு குறைவாக இருந்தால், நாம் இடதுபுறம் செல்கிறோம்; அது அதிகமாக இருந்தால், நாம் வலதுபுறம் செல்கிறோம். நாம் விரும்பிய மதிப்பைக் கண்டுபிடிக்கும் வரை அல்லது அதன் மதிப்பு பூஜ்யமான (மரத்தின் இலை) ஒரு உறுப்பை எதிர்கொள்ளும் வரை இந்த செயல்முறை மீண்டும் நிகழ்கிறது. சிவப்பு மற்றும் கருப்பு நிறங்கள் மரத்தை வழிசெலுத்துவதையும் சமநிலைப்படுத்துவதையும் எளிதாக்க பயன்படுகிறது. சிவப்பு-கருப்பு மரத்தை உருவாக்கும்போது எப்போதும் கடைபிடிக்க வேண்டிய விதிகள் உள்ளன:
  • வேர் கருப்பு நிறமாக இருக்க வேண்டும்.
  • மரத்தின் இலைகள் கருப்பு நிறமாக இருக்க வேண்டும்.
  • சிவப்பு முனையில் இரண்டு கருப்பு குழந்தை முனைகள் இருக்க வேண்டும்.
  • கருப்பு முனையில் எந்த நிறத்திலும் குழந்தை முனைகள் இருக்கலாம்.
  • ஒரு முனையிலிருந்து அதன் இலைகளுக்கு செல்லும் பாதையில் அதே எண்ணிக்கையிலான கருப்பு முனைகள் இருக்க வேண்டும்.
  • இலைகளில் புதிய முனைகள் சேர்க்கப்படுகின்றன.
நீங்கள் விதிகள் 3, 4 மற்றும் 5 ஐ ஒன்றாகக் கருத்தில் கொண்டால், முனையின் நிறம் எவ்வாறு மரத்தை விரைவாகச் செல்ல அனுமதிக்கிறது என்பதை நீங்கள் புரிந்து கொள்ளலாம்: கருப்பு முனைகள் வழியாக செல்லும் பாதை எப்போதும் சிவப்பு முனைகள் வழியாக செல்லும் பாதையை விட குறுகியதாக இருக்கும். அதன்படி, மரத்தின் மொத்த அளவு கருப்பு முனைகளின் எண்ணிக்கையால் தீர்மானிக்கப்படுகிறது, இது "கருப்பு உயரம்" என்று அழைக்கப்படுகிறது. சிவப்பு-கருப்பு மர தரவு அமைப்பு பல்வேறு நிரலாக்க மொழிகளில் செயல்படுத்தப்படுகிறது. இணையத்தில் நிறைய ஜாவா செயலாக்கங்கள் உள்ளன, எனவே நாங்கள் இங்கே தாமதிக்க மாட்டோம். அதற்குப் பதிலாக, ட்ரீமேப்பின் செயல்பாட்டைத் தொடர்ந்து தெரிந்து கொள்வோம்.

வரிசைப்படுத்தப்பட்ட வரைபடம் மற்றும் NavigableMap இடைமுகங்களிலிருந்து வரும் முறைகள்

ஹாஷ்மேப்பைப் போலவே, ட்ரீமேப் மேப் இடைமுகத்தை செயல்படுத்துகிறது, அதாவது ட்ரீமேப்பில் ஹாஷ்மேப்பில் இருக்கும் அனைத்து முறைகளும் உள்ளன. ஆனால் TreeMap வரிசைப்படுத்தப்பட்ட வரைபடம் மற்றும் NavigableMap இடைமுகங்களையும் செயல்படுத்துகிறது , மேலும் அவற்றிலிருந்து கூடுதல் செயல்பாட்டைப் பெறுகிறது. வரிசைப்படுத்தப்பட்ட வரைபடம் என்பது வரைபடத்தை நீட்டிக்கும் இடைமுகம் மற்றும் வரிசைப்படுத்தப்பட்ட தரவுத்தொகுப்புடன் தொடர்புடைய முறைகளைச் சேர்க்கிறது:
  • firstKey() : வரைபடத்தில் முதல் உறுப்பின் விசையை வழங்குகிறது
  • lastKey() : கடைசி உறுப்பின் விசையை வழங்குகிறது
  • headMap(K end) : தற்போதைய வரைபடத்தின் அனைத்து கூறுகளையும் கொண்டிருக்கும் வரைபடத்தை, தொடக்கத்தில் இருந்து முக்கிய முனையுடன் உறுப்பு வரை வழங்குகிறது
  • tailMap(K start) : தொடக்க உறுப்பு முதல் இறுதி வரை தற்போதைய வரைபடத்தின் அனைத்து கூறுகளையும் கொண்ட வரைபடத்தை வழங்குகிறது
  • subMap(K start, K ​​end) : தொடக்க உறுப்பு முதல் முக்கிய முனையுடன் உறுப்பு வரை தற்போதைய வரைபடத்தின் அனைத்து கூறுகளையும் கொண்ட வரைபடத்தை வழங்குகிறது.
NavigableMap என்பது வரிசைப்படுத்தப்பட்ட வரைபடத்தை விரிவுபடுத்தும் ஒரு இடைமுகம் மற்றும் வரைபடத்தின் கூறுகளுக்கு இடையே வழிசெலுத்துவதற்கான முறைகளைச் சேர்க்கிறது:
  • firstEntry() : முதல் விசை மதிப்பு ஜோடியை வழங்குகிறது
  • lastEntry() : கடைசி விசை மதிப்பு ஜோடியை வழங்குகிறது
  • pollFirstEntry() : முதல் ஜோடியைத் திருப்பி நீக்குகிறது
  • pollLastEntry() : கடைசி ஜோடியைத் திருப்பி நீக்குகிறது
  • சீலிங்கே(K obj) : விசை obj ஐ விட பெரிய அல்லது அதற்கு சமமான சிறிய விசை k ஐ வழங்குகிறது. அத்தகைய விசை இல்லை என்றால், பூஜ்யத்தை வழங்குகிறது
  • floorKey(K obj) : விசை obj ஐ விட குறைவான அல்லது சமமான மிகப்பெரிய விசை k ஐ வழங்குகிறது. அத்தகைய விசை இல்லை என்றால், பூஜ்யத்தை வழங்குகிறது
  • lowKey(K obj) : விசை obj ஐ விட குறைவான பெரிய விசை k ஐ வழங்குகிறது. அத்தகைய விசை இல்லை என்றால், பூஜ்யத்தை வழங்குகிறது
  • highKey(K obj) : விசை obj ஐ விட பெரிய சிறிய விசை k ஐ வழங்குகிறது. அத்தகைய விசை இல்லை என்றால், பூஜ்யத்தை வழங்குகிறது
  • உச்சவரம்பு நுழைவு(K obj) : சீலிங்கே(K obj) முறையைப் போலவே, விசை-மதிப்பு ஜோடியை (அல்லது பூஜ்யமாக) மட்டுமே வழங்கும்
  • floorEntry(K obj) : floorKey(K obj) முறையைப் போலவே, ஒரு முக்கிய-மதிப்பு ஜோடியை (அல்லது பூஜ்யமாக) மட்டுமே வழங்கும்
  • lowEntry(K obj) : lowerKey(K obj) முறையைப் போலவே, ஒரு விசை-மதிப்பு ஜோடியை (அல்லது பூஜ்யமாக) மட்டுமே வழங்கும்
  • highEntry(K obj) : HighKey(K obj) முறையைப் போலவே, ஒரு முக்கிய மதிப்பு ஜோடியை (அல்லது பூஜ்யமாக) மட்டுமே வழங்கும்
  • descendingKeySet() : தலைகீழ் வரிசையில் வரிசைப்படுத்தப்பட்ட அனைத்து விசைகளையும் கொண்ட NavigableSet ஐ வழங்குகிறது
  • descendingMap() : தலைகீழ் வரிசையில் வரிசைப்படுத்தப்பட்ட அனைத்து ஜோடிகளையும் கொண்ட NavigableMap ஐ வழங்குகிறது
  • navigableKeySet() : அனைத்து விசைகளும் சேமிக்கப்பட்டுள்ள வரிசையில் உள்ள NavigableSet பொருளை வழங்கும்
  • headMap(K topBound, boolean incl) : தொடக்கத்தில் இருந்து மேல்பவுண்ட் உறுப்பு வரை ஜோடிகளைக் கொண்ட ஒரு வரைபடத்தை வழங்குகிறது. திரும்பிய வரைபடத்தில் அப்பர்பவுண்ட் உறுப்பைச் சேர்க்க வேண்டுமா என்பதை incl அளவுரு குறிக்கிறது
  • tailMap(K lowerBound, boolean incl) : முந்தைய முறையைப் போன்ற செயல்பாடு, கீழ்பவுண்டிலிருந்து இறுதிவரை ஜோடிகளை மட்டுமே வழங்குகிறது
  • subMap(K lowerBound, boolean lowIncl, K topBound, boolean highIncl) : முந்தைய முறைகளைப் போலவே, கீழ்பவுண்டிலிருந்து அப்பர்பவுண்டிற்கு ஜோடிகளை வழங்குகிறது; புதிய வரைபடத்தில் எல்லை கூறுகளை சேர்க்க வேண்டுமா என்பதை lowIncl மற்றும் highIncl வாதங்கள் குறிப்பிடுகின்றன.
வழக்கமான கட்டமைப்பாளர்களுக்கு கூடுதலாக, TreeMap மற்றொரு கட்டமைப்பாளரைக் கொண்டுள்ளது, அது ஒரு ஒப்பீட்டாளரின் நிகழ்வை ஏற்றுக்கொள்கிறது. உறுப்புகள் சேமிக்கப்படும் வரிசைக்கு இந்த ஒப்பீட்டாளர் பொறுப்பு.

ட்ரீமேப்பின் எடுத்துக்காட்டுகள்

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

public class Person {
   public String firstName;
   public String lastName;
   public int age;

   public Person(String firstName, String lastName, int age) {
       this.firstName = firstName;
       this.lastName = lastName;
       this.age = age;
   }
}
நாங்கள் முதன்மை வகுப்பில் தர்க்கத்தை செயல்படுத்துகிறோம் :

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class Main {
   public static void main(String[] args) {
      TreeMap<Person, Integer> map = new TreeMap<>(Comparator.comparingInt(o -> o.age));
      map.put(new Person("John", "Smith", 17), 0);
      map.put(new Person("Ivan", "Petrenko", 65), 0);
      map.put(new Person("Pedro", "Escobar", 32), 0);
      map.put(new Person("Shirley", "Hatfield", 14), 0);
      map.put(new Person("Abby", "Parsons", 19), 0);

      Person firstAdultPerson = map.navigableKeySet().stream().filter(person -> person.age>18).findFirst().get();

       Map<Person, Integer> youngPeopleMap = map.headMap(firstAdultPerson, false);
       Map<Person, Integer> adultPeopleMap = map.tailMap(firstAdultPerson, true);
       showAdvertisementToYoung(youngPeopleMap);
       showAdvertisementToAdult(adultPeopleMap);
   }

   public static void showAdvertisementToYoung(Map map) {}
   public static void showAdvertisementToAdult(Map map) {}
}
முதன்மை வகுப்பில், TreeMap ஐ உருவாக்கவும், அதில் ஒவ்வொரு விசையும் ஒரு குறிப்பிட்ட நபரைக் குறிக்கும், மேலும் ஒவ்வொரு மதிப்பும் இந்த மாத விளம்பர பதிவுகளின் எண்ணிக்கையாகும். வயதைக் கொண்டு மக்களை வரிசைப்படுத்தும் ஒப்பீட்டாளரைக் கட்டமைப்பாளருக்கு அனுப்புகிறோம். வரைபடத்தை தன்னிச்சையான மதிப்புகளுடன் நிரப்புகிறோம். இப்போது எங்கள் சிறிய தரவுக் களஞ்சியத்தில் முதல் வயது வந்தவரைப் பற்றிய குறிப்பைப் பெற விரும்புகிறோம். ஸ்ட்ரீம் API ஐப் பயன்படுத்தி இதைச் செய்கிறோம். பின்னர் இரண்டு தனித்தனி வரைபடங்களைப் பெறுகிறோம், அதை விளம்பரங்களைக் காட்டும் முறைகளுக்கு அனுப்புகிறோம். இந்த பணியை நாம் நிறைவேற்றுவதற்கு பல, பல வழிகள் உள்ளன. ட்ரீமேப் வகுப்பின் ஆயுதக் களஞ்சியம் ஒவ்வொரு தேவைக்கும் தனிப்பயன் தீர்வுகளை உருவாக்க உதவுகிறது. உங்கள் IDE இலிருந்து ஆவணங்கள் அல்லது உதவிக்குறிப்புகளை நீங்கள் எப்பொழுதும் பயன்படுத்தலாம் என்பதால், அவை அனைத்தையும் நீங்கள் நினைவில் வைத்திருக்க வேண்டியதில்லை. நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்
இப்பொழுது இத்துடன் நிறைவடைகிறது! ட்ரீமேப் வகுப்பு உங்களுக்கு இப்போது தெளிவாகத் தெரியும் என்றும், நடைமுறைக் குறியீட்டுப் பணிகளைத் தீர்ப்பதில் நீங்கள் அதைச் சரியாகப் பயன்படுத்துவீர்கள் என்றும் நம்புகிறேன்.