स्टॅक ट्रेस

"हाय! आज मी तुम्हाला स्टॅक ट्रेस म्हणजे काय ते सांगेन. पण आधी मला तुम्हाला स्टॅक म्हणजे काय हे सांगायला हवे."

"कागदांच्या ढिगाऱ्याची कल्पना करा - एखाद्या विशिष्ट कर्मचार्‍यासाठी निर्देश. तुम्ही ढिगाऱ्याच्या शीर्षस्थानी एक नवीन कार्य ठेवू शकता किंवा तुम्ही वरून एखादे कार्य घेऊ शकता. याचा अर्थ असा की कार्ये प्राप्त झालेल्या क्रमाने कार्यान्वित केली जाणार नाहीत. . सर्वात अलीकडे ढिगाऱ्यावर ठेवलेले कार्य प्रथम कार्यान्वित केले जाईल. अशा प्रकारे संग्रहातील घटकांची रचना केल्याने एक स्टॅक तयार होतो .

" Java कडे त्यासाठी एक विशेष संग्रह आहे - स्टॅक . हा एक संग्रह आहे ज्यामध्ये 'घटक जोडणे' आणि 'एक घटक घेणे (मिळवणे)' या पद्धती आहेत. तुम्ही अंदाज केला असेल की, शेवटी जोडलेला घटक प्रथम असेल घेतले पाहिजे."

"त्यापेक्षा सरळ वाटतं."

"छान. आता मी स्टॅक ट्रेस म्हणजे काय ते समजावून सांगेन ."

"कल्पना करा की जावा प्रोग्रॅम पद्धतीमध्ये A म्हणतात पद्धत B , ज्याला पद्धत C म्हणतात, ज्याला पद्धत D म्हणतात . पद्धत B मधून बाहेर पडण्यासाठी , आपण प्रथम पद्धत C मधून बाहेर पडणे आवश्यक आहे , आणि ते करण्यासाठी - आपण प्रथम पद्धत D मधून बाहेर पडणे आवश्यक आहे . वर्तन स्टॅकसारखे दिसते."

"तुम्ही असे का म्हणता?"

"आमच्या कागदपत्रांच्या स्टॅकच्या मध्यभागी काही कार्य करण्यासाठी, उदाहरणार्थ, तुम्हाला प्रथम त्याच्या शीर्षस्थानी असलेली सर्व कार्ये कार्यान्वित करणे आवश्यक आहे."

"काही समानता आहे, परंतु मला खात्री नाही की मला सर्वकाही योग्यरित्या समजले आहे."

"पहा. स्टॅक हा घटकांचा संच आहे. ढिगाऱ्यातील कागदाच्या तुकड्यांप्रमाणे. वरून तिसरा कागद घेण्यासाठी, तुम्हाला प्रथम दुसरा घ्यावा लागेल आणि त्यासाठी तुम्हाला पहिला घ्यावा लागेल. तुम्ही नेहमी कागदाचे तुकडे ठेवू आणि घेऊ शकतो, परंतु तुम्हाला नेहमी सर्वात वरचा कागद घ्यावा लागेल."

"फंक्शन कॉलसाठीही हेच खरे आहे. पद्धत A कॉल पद्धत B , जी पद्धत C कॉल करते. A मधून बाहेर पडण्यासाठी , तुम्हाला प्रथम B मधून बाहेर पडणे आवश्यक आहे , आणि ते करण्यासाठी, तुम्हाला C मधून बाहेर पडणे आवश्यक आहे ."

"थांबा. जर तुम्ही काय म्हणत आहात ते मला समजले तर, स्टॅकची संपूर्ण संकल्पना 'शेवटचा जोडलेला कागद घ्या' आणि 'तुम्ही अलीकडे प्रविष्ट केलेल्या पद्धतीतून बाहेर पडू शकता'. ते अचूक आहे का? "

"होय. फंक्शन कॉलचा क्रम 'कॉल स्टॅक' किंवा फक्त 'स्टॅक' म्हणून ओळखला जातो. कॉल केलेले शेवटचे फंक्शन हे शेवटचे पहिले फंक्शन आहे. चला एक उदाहरण शोधूया."

public class ExceptionExample
{
  public static void main(String[] args)
  {
    method1();
  }

  public static void method1()
  {
    method2();
  }

  public static void method2()
  {
    method3();
  }

  public static void method3()
  {
     StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
    for (StackTraceElement element : stackTraceElements)
    {
       System.out.println(element.getMethodName());
    }
  }
}

getStackTrace
method3
method2
method1
main

"ठीक आहे. मला फंक्शन कॉल्सबद्दल सर्व काही मिळते. पण हे StackTraceElement काय आहे?"

"जावा मशीन सर्व फंक्शन कॉल्सचा मागोवा ठेवते. त्यासाठी, त्यात एक विशेष संग्रह आहे - स्टॅक. जेव्हा एक फंक्शन दुसर्‍याला कॉल करते, तेव्हा Java मशीन स्टॅकवर एक नवीन StackTraceElement ऑब्जेक्ट ठेवते. जेव्हा फंक्शन पूर्ण होते, तेव्हा तो घटक काढून टाकला जातो . स्टॅकमधून. याचा अर्थ स्टॅक नेहमी 'फंक्शन कॉल्सच्या स्टॅक'च्या सद्य स्थितीबद्दल अद्ययावत माहिती संग्रहित करतो. "

"प्रत्येक StackTraceElement ऑब्जेक्टमध्ये कॉल केलेल्या पद्धतीबद्दल माहिती असते. विशेषतः, तुम्ही getMethodName पद्धत वापरून पद्धतीचे नाव मिळवू शकता."

"हे कसे कार्य करते ते तुम्ही वरील उदाहरणात पाहू शकता:

1) आम्हाला कॉल स्टॅक मिळतो.

२) त्यामधून जाण्यासाठी आम्ही प्रत्येकासाठी लूप वापरतो . मला आशा आहे की तुम्ही ते काय आहे हे विसरला नाही.

३) आम्ही पद्धतीची नावे System.out वर आउटपुट करतो ."

"आकर्षक! आणि खूप क्लिष्टही नाही. धन्यवाद, ऋषी!"