జావా హ్యాష్‌కోడ్()

హాష్ సూత్రం

అన్నింటిలో మొదటిది, మేము జావా హ్యాష్‌కోడ్‌ను నిర్వచించే ముందు, హ్యాషింగ్ అంటే ఏమిటి మరియు అది దేని కోసం అని అర్థం చేసుకోవాలి. హ్యాషింగ్ అనేది కొంత డేటాకు హాష్ ఫంక్షన్‌ని వర్తింపజేసే ప్రక్రియ. హాష్ ఫంక్షన్ కేవలం గణిత ఫంక్షన్. దీని గురించి చింతించకండి! "గణితం" అంటే ఎల్లప్పుడూ "సంక్లిష్టమైనది" అని అర్థం కాదు. ఇక్కడ మనకు కొంత డేటా మరియు డేటాను అక్షరాల సెట్‌గా (కోడ్) మ్యాప్ చేసే నిర్దిష్ట నియమం ఉందని మాత్రమే అర్థం. ఉదాహరణకు, ఇది హెక్సాడెసిమల్ సాంకేతికలిపి కావచ్చు. మేము ఇన్‌పుట్ వద్ద ఏదైనా పరిమాణంలో కొంత డేటాను కలిగి ఉన్నాము మరియు దానికి హాష్ ఫంక్షన్‌ను వర్తింపజేస్తాము. అవుట్‌పుట్ వద్ద, మేము స్థిర-పరిమాణ డేటాను పొందుతాము, చెప్పాలంటే, 32 అక్షరాలు. సాధారణంగా, ఆ రకమైన ఫంక్షన్ పెద్ద డేటాను చిన్న పూర్ణాంక విలువగా మారుస్తుంది. ఈ ఫంక్షన్ పని ఫలితాన్ని హాష్ కోడ్ అంటారు. గూఢ లిపి శాస్త్రంలో మరియు కొన్ని ఇతర ప్రాంతాలలో కూడా హాష్ విధులు విస్తృతంగా ఉపయోగించబడుతున్నాయి. హాష్ విధులు భిన్నంగా ఉండవచ్చు,

• నిర్దిష్ట వస్తువుకు నిర్దిష్ట హ్యాష్‌కోడ్ ఉంటుంది.
• రెండు వస్తువులు సమానంగా ఉంటే, వాటి హ్యాష్‌కోడ్‌లు ఒకేలా ఉంటాయి. రివర్స్ నిజం కాదు.
• హాష్ కోడ్‌లు భిన్నంగా ఉంటే, ఆ వస్తువులు ఖచ్చితంగా సమానంగా ఉండవు.
• వేర్వేరు వస్తువులు ఒకే హాష్ కోడ్‌ని కలిగి ఉండవచ్చు. అయితే, ఇది చాలా అసంభవమైన సంఘటన. ఈ సమయంలో, మేము డేటాను కోల్పోయే ప్రమాదం, పరిస్థితి.

"సరైన" హాష్ ఫంక్షన్ ఘర్షణల సంభావ్యతను తగ్గిస్తుంది.

జావాలో హ్యాష్‌కోడ్

జావాలో హాష్ ఫంక్షన్ సాధారణంగా hashCode() పద్ధతికి అనుసంధానించబడుతుంది . ఖచ్చితంగా, ఆబ్జెక్ట్‌కు హాష్ ఫంక్షన్‌ను వర్తింపజేయడం వల్ల వచ్చే ఫలితం హ్యాష్‌కోడ్. ప్రతి జావా వస్తువుకు హాష్ కోడ్ ఉంటుంది. సాధారణంగా హాష్ కోడ్ అనేది క్లాస్ యొక్క హాష్ కోడ్() పద్ధతి ద్వారా లెక్కించబడిన సంఖ్య Object. సాధారణంగా, ప్రోగ్రామర్లు తమ ఆబ్జెక్ట్‌ల కోసం ఈ పద్ధతిని ఓవర్‌రైడ్ చేస్తారు, అలాగే నిర్దిష్ట డేటా యొక్క మరింత సమర్థవంతమైన ప్రాసెసింగ్ కోసం హాష్‌కోడ్() ఈక్వల్స్ () పద్ధతికి సంబంధించినవి. HashCode () పద్ధతి ఒక int (4 బైట్లు) విలువను అందిస్తుంది, ఇది ఆబ్జెక్ట్ యొక్క సంఖ్యా ప్రాతినిధ్యం. ఈ హ్యాష్‌కోడ్ ఉపయోగించబడుతుంది, ఉదాహరణకు, డేటా యొక్క మరింత సమర్థవంతమైన నిల్వ కోసం సేకరణల ద్వారా మరియు తదనుగుణంగా, వాటికి వేగవంతమైన ప్రాప్యత. డిఫాల్ట్‌గా, హ్యాష్‌కోడ్()ఆబ్జెక్ట్ కోసం ఫంక్షన్ ఆబ్జెక్ట్ నిల్వ చేయబడిన మెమరీ సెల్ సంఖ్యను అందిస్తుంది. కాబట్టి, అప్లికేషన్ కోడ్‌లో మార్పులు చేయకుంటే, ఫంక్షన్ అదే విలువను అందించాలి. కోడ్ కొద్దిగా మారితే, హ్యాష్‌కోడ్ విలువ కూడా మారుతుంది. జావాలో హ్యాష్‌కోడ్ దేనికి ఉపయోగించబడుతుంది? అన్నింటిలో మొదటిది జావా హ్యాష్‌కోడ్‌లు ప్రోగ్రామ్‌లను వేగంగా అమలు చేయడంలో సహాయపడతాయి. ఉదాహరణకు, మేము రెండు వస్తువులను o1మరియు o2కొన్ని రకాలను పోల్చినట్లయితే, ఆపరేషన్ o1.equals(o2)కంటే 20 రెట్లు ఎక్కువ సమయం పడుతుంది o1.hashCode() == o2.hashCode().

జావా సమానం()

పేరెంట్ క్లాస్‌లో , హాష్‌కోడ్()Object పద్ధతితో పాటు , ఈక్వల్స్() కూడా ఉంది , ఇది రెండు వస్తువుల సమానత్వాన్ని తనిఖీ చేయడానికి ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ యొక్క డిఫాల్ట్ అమలు రెండు వస్తువుల లింక్‌లను వాటి సమానత్వం కోసం తనిఖీ చేస్తుంది. సమానం() మరియు హాష్‌కోడ్() వారి ఒప్పందాన్ని కలిగి ఉన్నాయి, కాబట్టి మీరు వాటిలో ఒకదానిని భర్తీ చేస్తే, ఈ ఒప్పందాన్ని విచ్ఛిన్నం చేయకుండా ఉండటానికి మీరు మరొకదానిని భర్తీ చేయాలి.

HashCode() పద్ధతిని అమలు చేస్తోంది

ఉదాహరణ

ఒక ఫీల్డ్‌తో క్లాస్ క్యారెక్టర్‌ని క్రియేట్ చేద్దాం — పేరు . ఆ తర్వాత, మేము క్యారెక్టర్ క్లాస్, క్యారెక్టర్1 మరియు క్యారెక్టర్2 అనే రెండు ఆబ్జెక్ట్‌లను సృష్టించి , వాటికి ఒకే పేరును సెట్ చేస్తాము. మేము ఆబ్జెక్ట్ క్లాస్ యొక్క డిఫాల్ట్ హ్యాష్‌కోడ్() మరియు ఈక్వల్స్()ని ఉపయోగిస్తే , మనం ఖచ్చితంగా విభిన్నమైన, సమానమైన ఆబ్జెక్ట్‌లను పొందుతాము.జావాలో హ్యాష్‌కోడ్ ఎలా పనిచేస్తుంది. అవి వేర్వేరు మెమరీ సెల్‌లలో ఉన్నందున వాటికి వేర్వేరు హ్యాష్‌కోడ్‌లు ఉంటాయి మరియు సమాన () ఆపరేషన్ ఫలితం తప్పుగా ఉంటుంది.

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 + ఇన్సర్ట్ నొక్కండి మరియు 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

కాబట్టి ఇప్పుడు ప్రోగ్రామ్ మన వస్తువులను సమానంగా గుర్తిస్తుంది మరియు వాటికి ఒకే హ్యాష్‌కోడ్‌లు ఉన్నాయి.

జావా హ్యాష్‌కోడ్ ఉదాహరణ:

మీ స్వంత హ్యాష్‌కోడ్() మరియు సమానం()

మీరు మీ స్వంత సమానాలు() మరియు హ్యాష్‌కోడ్() రియలైజేషన్‌లను కూడా సృష్టించవచ్చు , కానీ జాగ్రత్తగా ఉండండి మరియు హ్యాష్‌కోడ్ ఘర్షణలను తగ్గించాలని గుర్తుంచుకోండి. స్టూడెంట్ క్లాస్‌లో మా స్వంత హ్యాష్‌కోడ్() మరియు ఈక్వల్స్() పద్ధతులకు ఇక్కడ ఉదాహరణ :

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 రెట్లు ఎక్కువ సమయం పడుతుంది. జావాలో హ్యాషింగ్ సూత్రం HashMap , HashSet మరియు HashTable వంటి కొన్ని ప్రసిద్ధ సేకరణల వెనుక నిలుస్తుంది .

ముగింపు

ప్రతి జావా ఆబ్జెక్ట్‌కు ఆబ్జెక్ట్ క్లాస్ నుండి వారసత్వంగా వచ్చిన హ్యాష్‌కోడ్() మరియు ఈక్వల్స్() పద్ధతులు ఉంటాయి. మంచి పని సమానత్వ యంత్రాంగాన్ని పొందడానికి, మీరు మీ స్వంత తరగతుల కోసం హ్యాష్‌కోడ్() మరియు ఈక్వల్స్() పద్ధతులను భర్తీ చేయడం మంచిది. హ్యాష్‌కోడ్‌లను ఉపయోగించడం వల్ల ప్రోగ్రామ్‌లు వేగంగా పని చేస్తాయి.