ஜாவா ஹாஷ்கோட்()

ஹாஷ் கொள்கை

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

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

"சரியான" ஹாஷ் செயல்பாடு மோதல்களின் நிகழ்தகவைக் குறைக்கிறது.

ஜாவாவில் ஹாஷ்கோடு

ஜாவாவில் ஹாஷ் செயல்பாடு பொதுவாக ஹாஷ்கோட்() முறையுடன் இணைக்கப்படும் . துல்லியமாக, ஒரு பொருளுக்கு ஹாஷ் செயல்பாட்டைப் பயன்படுத்துவதன் விளைவு ஒரு ஹாஷ்கோட் ஆகும். ஒவ்வொரு ஜாவா பொருளுக்கும் ஒரு ஹாஷ் குறியீடு உள்ளது. பொதுவாக ஹாஷ் குறியீடு என்பது வகுப்பின் ஹாஷ்கோட்() முறையால் கணக்கிடப்படும் எண்ணாகும் Object. வழக்கமாக, புரோகிராமர்கள் இந்த முறையை தங்கள் பொருள்களுக்காகவும் , குறிப்பிட்ட தரவை மிகவும் திறமையான செயலாக்கத்திற்கான ஹாஷ்கோட்() சமம் () முறையுடன் தொடர்புடையதாகவும் மேலெழுதுவார்கள் . ஹாஷ்கோட் () முறை ஒரு முழு எண்ணாக (4 பைட்டுகள்) மதிப்பை வழங்குகிறது, இது பொருளின் எண் பிரதிநிதித்துவமாகும். இந்த ஹாஷ்கோடு பயன்படுத்தப்படுகிறது, எடுத்துக்காட்டாக, சேகரிப்புகள் மூலம் தரவை மிகவும் திறமையான சேமிப்பிற்காகவும், அதன்படி, அவற்றை விரைவாக அணுகவும். முன்னிருப்பாக, hashCode()ஒரு பொருளுக்கான செயல்பாடு, பொருள் சேமிக்கப்பட்டுள்ள நினைவக கலத்தின் எண்ணிக்கையை வழங்குகிறது. எனவே, பயன்பாட்டுக் குறியீட்டில் எந்த மாற்றமும் செய்யப்படவில்லை என்றால், செயல்பாடு அதே மதிப்பை வழங்க வேண்டும். குறியீடு சிறிது மாறினால், ஹாஷ்கோட் மதிப்பும் மாறும். ஜாவாவில் ஹாஷ்கோட் எதற்காகப் பயன்படுத்தப்படுகிறது? முதலில் ஜாவா ஹாஷ்கோடுகள் புரோகிராம்கள் வேகமாக இயங்க உதவுகின்றன. எடுத்துக்காட்டாக, இரண்டு பொருட்களையும் சில வகைகளையும் ஒப்பிட்டுப் பார்த்தால் o1, o2செயல்பாட்டிற்கு o1.equals(o2)20 மடங்கு அதிக நேரம் எடுக்கும் o1.hashCode() == o2.hashCode().

ஜாவா சமம்()

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

ஹாஷ்கோட்() முறையை செயல்படுத்துதல்

உதாரணமாக

ஒரு புலத்துடன் வர்க்க எழுத்தை உருவாக்குவோம் — பெயர் . அதன் பிறகு, எழுத்து வகுப்பின் இரண்டு பொருள்களை உருவாக்குகிறோம் , பாத்திரம்1 , மற்றும் பாத்திரம்2 மற்றும் அதே பெயரை அமைக்கிறோம். ஆப்ஜெக்ட் வகுப்பின் இயல்புநிலை hashCode() மற்றும் equals()ஐப் பயன்படுத்தினால் , நாம் நிச்சயமாக வேறுபட்ட பொருள்களைப் பெறுவோம், சமமான பொருள்கள் அல்ல. ஜாவாவில் ஹாஷ்கோட் இப்படித்தான் செயல்படுகிறது. வெவ்வேறு மெமரி செல்களில் இருப்பதால் அவை வெவ்வேறு ஹாஷ்கோடுகளைக் கொண்டிருக்கும் மற்றும் சமம்() செயல்பாட்டு முடிவு தவறானதாக இருக்கும்.

import java.util.Objects;

public class Character {
    private String Name;

    public Character(String name) {
        Name = name;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    } 

    public static void main(String[] args) {
        Character character1 = new Character("Arnold");
        System.out.println(character1.getName());
        System.out.println(character1.hashCode());
        Character character2 = new Character("Arnold");
        System.out.println(character2.getName());
        System.out.println(character2.hashCode());
        System.out.println(character2.equals(character1));
    }
}

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

Arnold
1595428806
Arnold
1072408673
false

கன்சோலில் உள்ள இரண்டு 10 இலக்க எண்கள் ஹாஷ்கோடுகள். ஒரே பெயர்கள் இருந்தால் நமக்கு சமமான பொருள்கள் இருக்க வேண்டுமா என்ன? நாம் என்ன செய்ய வேண்டும்? பதில்: நமது எழுத்து வகுப்பிற்கான ஆப்ஜெக்ட் வகுப்பின் ஹாஷ்கோட்() மற்றும் சமம்() முறைகளை நாம் மேலெழுத வேண்டும் . IDEA IDE இல் நாங்கள் அதை தானாகவே செய்யலாம், உங்கள் விசைப்பலகையில் alt + insert ஐ அழுத்தி, Generate -> equals() மற்றும் hashCode() என்பதைத் தேர்ந்தெடுக்கவும் . எங்கள் எடுத்துக்காட்டின் விஷயத்தில், அடுத்த குறியீட்டைப் பெற்றுள்ளோம்:

import java.util.Objects;

public class Character {
    private String Name;

    public Character(String name) {
        Name = name;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Character)) return false;

        Character character = (Character) o;

        return getName() != null ? getName().equals(character.getName()) : character.getName() == null;
    }

    @Override
    public int hashCode() {
        return getName() != null ? getName().hashCode() : 0;
    }

    public static void main(String[] args) {
        Character character1 = new Character("Arnold");
        System.out.println(character1.getName());
        System.out.println(character1.hashCode());
        Character character2 = new Character("Arnold");
        System.out.println(character2.getName());
        System.out.println(character2.hashCode());
        System.out.println(character2.equals(character1));
    }
}

இந்தக் குறியீட்டை இயக்குவதன் முடிவு:

Arnold
1969563338
Arnold
1969563338
true

எனவே இப்போது நிரல் நமது பொருட்களை சமமாக அடையாளப்படுத்துகிறது மற்றும் அவை ஒரே ஹாஷ்கோடுகளைக் கொண்டுள்ளன.

ஜாவா ஹாஷ்கோட் உதாரணம்:

உங்கள் சொந்த ஹாஷ்கோட்() மற்றும் சமம்()

நீங்கள் உங்கள் சொந்த சமமான() மற்றும் hashCode() உணர்தல்களை உருவாக்கலாம் , ஆனால் கவனமாக இருங்கள் மற்றும் ஹாஷ்கோடு மோதல்களைக் குறைக்க நினைவில் கொள்ளுங்கள். மாணவர் வகுப்பில் எங்களின் சொந்த ஹாஷ்கோட்() மற்றும் சமம்() முறைகளின் உதாரணம் இங்கே :

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }
//Java hashcode example
   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

மற்றும் அவர்களின் வேலையை நிரூபிக்க முக்கிய வகுப்பு:

import java.util.Date;
import java.util.HashMap;
import java.util.Hashtable;

public class Main {
   static HashMap<Student, Integer> cache = new HashMap<Student, Integer>(); // <person, targetPriority>

   public static void main(String[] args) {
       Student sarah1 = new Student("Sarah","Connor", "Jane", null);
       Student sarah2 = new Student("Sarah","Connor", "Jane", new Date(1970, 01-1, 01));
       Student sarah3 = new Student("Sarah","Connor", "Jane", new Date(1959, 02-1, 28)); // date not exists
       Student john = new Student("John","Connor", "Kyle", new Date(1985, 02-1, 28)); // date not exists
       Student johnny = new Student("John","Connor", "Kyle", new Date(1985, 02-1, 28)); // date not exists
       System.out.println(john.hashCode());
       System.out.println(johnny.hashCode());
       System.out.println(sarah1.hashCode());
       System.out.println();
       cache.put(sarah1, 1);
       cache.put(sarah2, 2);
       cache.put(sarah3, 3);
       System.out.println(new Date(sarah1.birthday));
       System.out.println();
       cache.put(john, 5);
       System.out.println(cache.get(john));
       System.out.println(cache.get(johnny));
       cache.put(johnny, 7);
       System.out.println(cache.get(john));
       System.out.println(cache.get(johnny));
   }
}

ஹாஷ்கோட் எதற்காகப் பயன்படுத்தப்படுகிறது?

முதலில் ஹாஷ்கோடுகள் புரோகிராம்கள் வேகமாக இயங்க உதவுகின்றன. எடுத்துக்காட்டாக, நாம் இரண்டு பொருட்களையும் சில வகைகளையும் ஒப்பிட்டுப் பார்த்தால் o1, o2செயல்பாடு o1.equals(o2)o1.hashCode() == o2.hashCode() ஐ விட 20 மடங்கு அதிக நேரம் எடுக்கும். ஜாவாவில் ஹாஷ்மேப் , ஹாஷ்செட் மற்றும் ஹாஷ்டேபிள் போன்ற சில பிரபலமான சேகரிப்புகளுக்குப் பின்னால் ஹாஷிங் கொள்கை உள்ளது .

முடிவுரை

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