ट्रीमॅप संग्रह सादर करत आहे

विद्यापीठात एके दिवशी, मला माझ्या वर्गमित्रांच्या आडनावांची क्रमवारी लावण्यासाठी कोड लिहायचा होता, जो त्यांच्या वैयक्तिक डेटाची की म्हणून काम करत होता, चढत्या क्रमाने. मी यावर बराच वेळ घालवला. पण जर मला त्या वेळी TreeMap क्लासबद्दल माहिती असते , तर मी हे काम खूप वेगाने पूर्ण केले असते.

ट्रीमॅप म्हणजे काय ? ही एक शब्दकोशासारखी डेटा रचना आहे जी घटकांना की-व्हॅल्यू जोड्या म्हणून संग्रहित करते, त्यांची की नुसार क्रमवारी लावते.

ते कुठे आणि कसे वापरले जाऊ शकते? बरं, माझ्या वर्गमित्रांच्या आडनावांसह समान असाइनमेंटसाठी ते आदर्श ठरले असते. मला चढत्या क्रमाने मूल्ये साठवायची असल्यास, माझे स्वतःचे वर्गीकरण अल्गोरिदम लिहिण्याऐवजी, मला फक्त एक TreeMap तयार करायचा आहे आणि त्यात मूल्ये ठेवायची आहेत.

ते चढत्या क्रमाने पूर्णांक आणि स्ट्रिंग सारख्या प्रकारांची क्रमवारी लावते . परंतु जर तुम्हाला TreeMap मध्ये तुमचा स्वतःचा सानुकूल प्रकार ठेवायचा असेल , तर तुमच्या वर्गाला तुलना करण्यायोग्य इंटरफेस लागू करणे आवश्यक आहे, जेणेकरून ते compareTo() पद्धत लागू करेल, जी तुमच्या वर्गाची उदाहरणे कशी क्रमवारी लावायची हे दर्शवते.

public class Person implements Comparable<Person> {

    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

  …

    @Override
    public int compareTo(Person person) {
        return person.getFirstName().compareTo(firstName);
    }

    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                '}';
    }
}

compareTo() पद्धत ओव्हरराइड करू या जेणेकरून ती व्हॅल्यूला पहिल्या नावाने उलट वर्णक्रमानुसार क्रमवारी लावेल:

TreeMap map = new TreeMap<Person, String>();

map.put(new Person("AA","BB"), "aa");
map.put(new Person("BB","BB"), "aa");
map.put(new Person("DD","BB"), "aa");
map.put(new Person("CC","BB"), "aa");

मूल्ये खालील क्रमाने संग्रहित केली जातील:

Person{firstName='DD', lastName='BB'}
Person{firstName='CC', lastName='BB'}
Person{firstName='BB', lastName='BB'}
Person{firstName='AA', lastName='BB'}

ट्रीमॅप क्लास नेव्हिगेबलमॅप इंटरफेस लागू करतो, जो क्रमाने सॉर्टेडमॅप इंटरफेसचा विस्तार करतो . हे TreeMap वर्गाला क्रमवारीत मूल्ये संग्रहित करण्यासाठी वृक्ष वापरू देते.

सोप्या भाषेत सांगायचे तर, लाल-काळा वृक्ष ही एक डेटा रचना आहे जी मूळपेक्षा जास्त असल्यास उजव्या सबट्रीमध्ये आणि कमी असल्यास डाव्या सबट्रीमध्ये मूल्ये संग्रहित करते. हे अंमलबजावणी संरचनेतील मूल्ये खूप लवकर शोधू शकते.

लाल-काळे झाड हे स्व-संतुलित आहे, म्हणून प्रत्येक नवीन मूल्य घातल्यावर त्याची रचना बदलते. प्रथम जोडलेले मूल्य सुरुवातीला मूळ मानले जाते, परंतु संतुलन प्रक्रियेदरम्यान दुसरे मूल्य मूळ बनू शकते.

बरं, आता तुम्हाला माहित आहे की ट्रीमॅप म्हणजे काय आणि ते कसे कार्य करते.

लक्षात ठेवा की TreeMap फक्त त्या वस्तू संग्रहित करू शकते ज्यांचा वर्ग तुलना करण्यायोग्य इंटरफेस लागू करतो आणि compareTo() पद्धत ओव्हरराइड करतो.

परंतु जर आपण विविध लायब्ररींमधून लोड केलेले तृतीय-पक्ष वर्ग वापरत आहोत आणि त्यामध्ये तुलनात्मक अंमलबजावणी करू शकत नाही तर काय? यासाठी एक उपाय आहे: तुमचा स्वतःचा Comparator लिहा .

Comparator हा एक इंटरफेस आहे ज्यामध्ये compare() पद्धत आहे. आपण त्याचा वापर वस्तूंची तुलना करण्यासाठी आणि ट्रीमॅपमध्ये संग्रहित करण्यासाठी करू शकतो .

Comparator<Person> comparator = new Comparator<Person>() {

    @Override
    public int compare(Person person1, Person person2) {
        return person1.getFirstName().compareTo(person2.getFirstName());
    }
};


TreeMap map = new TreeMap<Person, String>(comparator);

या उदाहरणात, आम्ही एक सानुकूल तुलनाकर्ता तयार केला आणि वर्गाला TreeMap पास केला.

Java 8 मध्ये सुरू करून, आम्ही हे लॅम्बडा अभिव्यक्ती वापरून लिहू शकतो:

TreeMap map = new TreeMap<Person, String>((Person person1, Person person2) -> person1.getFirstName().compareTo(person2.getFirstName()));

दुसऱ्या शब्दांत, TreeMap मध्ये मूल्ये संचयित करण्यासाठी , तुम्हाला त्यांची क्रमवारी कशी लावायची ते निर्दिष्ट करणे आवश्यक आहे. हे करण्याचे दोन मार्ग आहेत: Comparable लागू करा किंवा तुमचा स्वतःचा Comparator अंमलात आणा .

परंतु जर आपल्याला ट्रीमॅपमध्ये की म्हणून शून्य ठेवण्याची आवश्यकता असेल तर ? हॅशमॅप तुम्हाला हे करू देते. होय, परंतु TreeMap हे कसे हाताळते?

TreeMap map = new TreeMap<Person, String>();
map.put (null, "Person");

हा कोड चालवल्याने आम्हाला एक त्रुटी येते:

समस्या अशी आहे की अंतर्गतपणे TreeMap वर्ग compareTo() पद्धत वापरून मूल्यांची तुलना करतो . तुम्ही निश्चितपणे शून्य मूल्यात पास करू शकता आणि कोड संकलित होईल. परंतु रनटाइमच्या वेळी तुम्हाला एक त्रुटी मिळेल, कारण पद्धत शून्य मूल्यावर कॉल केली जाईल, ज्यामुळे NullPointerException टाकला जाईल.

हॅशमॅप आणि ट्रीमॅपची तुलना

TreeMap च्या विपरीत , HashMap तुम्हाला नल की म्हणून संग्रहित करू देते. संरचनेत सर्व शून्य की साठी एक विशिष्ट स्थान आहे. हॅशमॅप शून्य की संचयित करण्यास सक्षम आहे कारण ते त्यांच्या हॅश मूल्याच्या आधारावर ते कोठे जायचे हे निर्धारित करते आणि हॅश मूल्याची गणना करताना तुलना आवश्यक नसते. त्यामुळे सर्व नल किजना त्यांचे स्थान आहे.

तुमच्याकडे ते आहे — आता तुम्हाला माहिती आहे की जेव्हा तुम्हाला मूल्ये क्रमवारीत साठवायची असतात तेव्हा काय वापरायचे आणि क्रमवारीसाठी नियम कसे सेट करायचे.