జావాలో నిఘంటువును ఎలా సృష్టించాలి

మీరు జావా ప్రోగ్రామ్‌లో నిఘంటువుని సృష్టించాల్సిన అవసరం ఉన్నట్లయితే, ఈ సమస్యను పరిష్కరించడానికి అత్యంత తార్కిక మార్గం నిఘంటువు డేటా నిర్మాణాన్ని ఉపయోగించడం. ఈ డేటా నిర్మాణం "కీ - విలువ" రూపంలో సమాచారాన్ని నిల్వ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. జావాకు ప్రత్యేక డిక్షనరీ క్లాస్ అలాగే దాని సంతతి, హ్యాష్‌టేబుల్ ఉంది . మ్యాప్ ఇంటర్‌ఫేస్ మరియు హాష్‌మ్యాప్ క్లాస్ కూడా ఉన్నాయి , ఇది “కీ - విలువ” జతలను కూడా నిల్వ చేస్తుంది. కాబట్టి జావా నిఘంటువును రూపొందించడానికి అనేక మార్గాలు ఉన్నాయి.

నిఘంటువు డేటా నిర్మాణం

కాబట్టి, నిఘంటువు డేటా నిర్మాణం సమాచారాన్ని కీ-విలువ కలయికగా నిల్వ చేస్తుంది. అంటే, ఏదైనా విలువతో మేము కీని అనుబంధిస్తాము (ఇది ఉదాహరణకు, ఐడి కావచ్చు) మరియు ఈ జతని నిఘంటువులోకి నమోదు చేయండి. డిక్షనరీలోని మూలకాన్ని పరిష్కరించడం, తొలగించడం, డిక్షనరీలో శోధించడం కీ ద్వారా నిర్వహించబడుతుంది. అటువంటి డేటా నిర్మాణాన్ని ఉపయోగించి నిర్వహించడం సౌకర్యంగా అనిపిస్తుంది, ఉదాహరణకు, టెలిఫోన్ పుస్తకం, పేరు (కీ) ఫోన్ నంబర్ (విలువ)కి అనుగుణంగా ఉంటుంది.

నిఘంటువు తరగతి మరియు దాని పొడిగింపు

ప్రారంభించడానికి, java.util.Dictionary <K, V> util.Dictionary అనేది ఒక వియుక్త తరగతి. ఇది కీ-విలువ సంబంధాన్ని సూచిస్తుంది మరియు మ్యాప్ మాదిరిగానే పనిచేస్తుంది. కీ ఇచ్చినప్పుడు మీరు విలువలను నిల్వ చేయవచ్చు మరియు అవసరమైనప్పుడు దాని కీని ఉపయోగించి విలువను తిరిగి పొందవచ్చు. అందువలన, ఇది కీ-విలువ జత యొక్క జాబితా.

public abstract class Dictionary<K,V> extends Object

ఈ తరగతి వియుక్తమైనది కాబట్టి, మేము దీనితో నేరుగా పని చేయము. డిక్షనరీలో డైరెక్ట్ చైల్డ్ క్లాస్ హ్యాష్ టేబుల్ ఉంది . కాబట్టి Java లో నిఘంటువు సృష్టించడంలో మీరు Hashtableని ఉపయోగించవచ్చు . ఈ తరగతి హాష్ పట్టికను అమలు చేస్తుంది, ఇది విలువలకు కీలను మ్యాప్ చేస్తుంది మరియు ఏదైనా శూన్యత లేని వస్తువును కీగా లేదా విలువగా ఉపయోగించవచ్చు. జావా సోపానక్రమంలో Hashtable నిఘంటువును విస్తరించి మ్యాప్‌ని అమలు చేస్తుంది . ఒక ఉదాహరణ ఇద్దాం. మేము Hashtable ఆధారంగా ఒక క్లాసిక్ నిఘంటువు, టెలిఫోన్ పుస్తకాన్ని సృష్టించబోతున్నాము .

Dictionary phoneBook = new Hashtable();

మనం ఈ విధంగా వ్రాస్తే, మనం కొన్ని ఆపరేషన్‌లకు టైప్ కాస్టింగ్‌ని వర్తింపజేయాలి. ఉదాహరణకు, ఒక కీ వెలికితీత కోసం.

System.out.println(((Hashtable) phoneBook).keySet());

దీన్ని నివారించడానికి, మనం మార్చవచ్చు

Dictionary phoneBook = new Hashtable ();

న

Hashtable phoneBook = new Hashtable ();

మా ఉదాహరణలో, స్పష్టత కోసం, మేము మొదటి ఎంపికను వదిలివేస్తాము.

import java.util.Dictionary;
import java.util.Hashtable;

public class DictionaryDemo {

       public static void main(String[] args) {

           Dictionary phoneBook = new Hashtable();

           // put() method
           phoneBook.put("Johnny Walker", "2178");
           phoneBook.put("Andrew Arnold", "1298");
           phoneBook.put("Ivy Briggs", "1877");
           phoneBook.put("Ricky McBright", "2001");

           //print out Hashtable out
           System.out.println(phoneBook);

           //let's get the value using the key
           System.out.println(phoneBook.get("Ivy Briggs"));
           //there's no such key in out Hashtable
           System.out.println(phoneBook.get("Sol Frank"));

           //Is there a record with the "Johnny Walker" key?
           System.out.println(((Hashtable) phoneBook).containsKey("Johnny Walker"));
           //all keys of the Hashtable
           System.out.println(((Hashtable) phoneBook).keySet());
           //values from Hashtable
           System.out.println(((Hashtable) phoneBook).values());

           //the quantity of records
           System.out.println(phoneBook.size());
           //removing one record
           phoneBook.remove("Andrew Arnold");
           System.out.println(phoneBook);
       }
   }

అవుట్‌పుట్:

నిఘంటువు వలె HashMap

HashMap , Hashtable వలె కాకుండా, నిఘంటువు యొక్క ప్రత్యక్ష సంతతి కాదు . అయినప్పటికీ, అనేక లక్షణాల కారణంగా, చాలా సందర్భాలలో HashMap ఉపయోగించి నిఘంటువును రూపొందించడం ఉత్తమం . HashMap క్లాస్ , Hashtable కి ఫంక్షనాలిటీలో చాలా పోలి ఉంటుంది . ప్రధాన వ్యత్యాసం ఏమిటంటే, Hashtable యొక్క పద్ధతులు సమకాలీకరించబడ్డాయి, కానీ HashMap కాదు. హ్యాష్‌టేబుల్‌లో సమకాలీకరణ కోడ్ పనితీరును తగ్గిస్తుంది. అదనంగా, HashMap తరగతి, Hashtable వలె కాకుండా, శూన్యాన్ని కీ (ఒకటి)గా మరియు శూన్య సమితిని విలువలుగా ఉపయోగించడానికి అనుమతిస్తుంది. మా విషయంలో, ప్రోగ్రామ్ పై ఉదాహరణకి సరిగ్గా అదే విధంగా కనిపిస్తుంది. సేకరణ రకంలో మాత్రమే తేడా ఉంటుంది. అయినప్పటికీ, చాలా సందర్భాలలో జావాలో నిఘంటువులతో పని చేయడానికి ఇది ఇష్టపడే మార్గం.

import java.util.HashMap;
import java.util.Map;

public class DictionaryDemo2 {

   public static void main(String[] args) {

       Map<String, String> phoneBook = new HashMap<String,String>();
      
       phoneBook.put("Johnny Walker", "2178");
       phoneBook.put("Andrew Arnold", "1298");
       phoneBook.put("Ivy Briggs", "1877");
       phoneBook.put("Ricky McBright", "2001");
      
       System.out.println(phoneBook);
      
       System.out.println(phoneBook.get("Johnny Walker"));
       System.out.println(phoneBook.get("Ivy Briggs"));
       System.out.println(phoneBook.get("Unknown Friend"));
      
       System.out.println(phoneBook.containsKey("Johnny Walker"));
       System.out.println(phoneBook.containsKey("Unknown Friend"));

       System.out.println(phoneBook.keySet());
       System.out.println(phoneBook.values());

       System.out.println(phoneBook.size());

       phoneBook.remove("Andrew Arnold");

       System.out.println(phoneBook);
   }

}

ఇక్కడ అవుట్‌పుట్ ఉంది: