जावा में न्यूमेरिक ऑपरेटर्स

नमस्ते! आज हम जावा में न्यूमेरिक ऑपरेटर नामक एक बहुत ही महत्वपूर्ण विषय पर विचार करेंगे । प्रोग्रामिंग में, नंबर हर जगह होते हैं। यदि आप गहरी खुदाई करते हैं और हाई स्कूल को याद करते हैं, तो आपको याद हो सकता है कि एक कंप्यूटर एक संख्यात्मक प्रारूप में सभी सूचनाओं का प्रतिनिधित्व करता है: शून्य और एक का संयोजन, जिसे बाइनरी कोड भी कहा जाता है। प्रोग्रामिंग में बहुत सारे न्यूमेरिक ऑपरेटर हैं, इसलिए हम उनमें से सबसे महत्वपूर्ण का पता लगाने के लिए उदाहरणों का उपयोग करेंगे :) आइए सबसे सरल से शुरू करें: अंकगणितीय ऑपरेटर । ये जाने-माने जोड़ ( +), घटाव ( -), गुणा ( *), और भाग ( /) संकारक हैं।

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

कंसोल आउटपुट: 1032 966 32967 30 आप पहले ही यह सब उपयोग कर चुके हैं। इस समूह में, आप शेष या मॉडुलो ( %) ऑपरेटर को जोड़ सकते हैं।

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

कंसोल आउटपुट: 1 इस उदाहरण में, हम 33 को 2 से विभाजित करते हैं। यह एक अतिरिक्त "पूंछ" (एक) के साथ 16 उत्पन्न करता है जो 2 से विभाज्य नहीं है। यह "पूंछ" "विभाजन से शेष" ऑपरेशन का परिणाम है। जावा भी तुलना/संबंधपरक ऑपरेटरों को लागू करता है (बिल्कुल गणित की तरह)। वे शायद आपको स्कूल से भी जानते हैं:

• बराबर ( ==)
• से अधिक ( >)
• से कम ( <)
• से अधिक या बराबर ( >=)
• <=( ) से कम या बराबर
• बराबर नहीं ( !=)

यहां आपको एक महत्वपूर्ण बिंदु पर ध्यान देना चाहिए जिसके कारण कई नौसिखिए गलतियां करते हैं। "बराबर" ऑपरेटर लिखा है ==, नहीं =। जावा में, एक एकल असाइनमेंट= ऑपरेटर है , जिसका उपयोग तब किया जाता है जब एक चर को एक संख्या, स्ट्रिंग या किसी अन्य चर का मान निर्दिष्ट किया जाता है।

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

कंसोल आउटपुट: 999 उफ़! यह स्पष्ट रूप से वह परिणाम नहीं है जिसकी हमें उम्मीद थी। यह एक पूरी तरह से अलग डेटा प्रकार है: हमें एक बूलियन देखने की उम्मीद थी , लेकिन हमें एक संख्या मिली। ऐसा इसलिए है क्योंकि हमने तुलना के बजाय कोष्ठकों में असाइनमेंट ऑपरेटर का उपयोग किया है । (999) का मान वेरिएबल को असाइन किया गया था , और फिर हमने का मान प्रदर्शित किया । यहाँ इसे करने का सही तरीका है: x=yyxx

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

कंसोल आउटपुट: गलत अब हमने दो नंबरों की ठीक से तुलना की है! :) यहां असाइनमेंट ऑपरेटर ( =) की एक और विशेषता है: इसे एक साथ "जंजीर" किया जा सकता है:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

कंसोल आउटपुट: 256 याद रखें असाइनमेंट दाएं से बाएं होता है । यह अभिव्यक्ति ( x = y = z) चरणों में क्रियान्वित की जाएगी:

• y = z, वह है,y = 256
• x = y, वह है,x = 256

यूनरी ऑपरेटर्स।

उन्हें " यूनो " शब्द से " यूनरी " कहा जाता है , जिसका अर्थ है " एक "। उन्हें यह नाम इसलिए मिला क्योंकि पिछले ऑपरेटरों के विपरीत, वे एक नंबर पर कार्य करते हैं, कई नहीं। इसमे शामिल है:

• यूनरी माइनस। यह संख्या के संकेत को फ़्लिप करता है।

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

कंसोल आउटपुट: -999 999 हमने यूनरी माइनस ऑपरेटर का दो बार उपयोग किया। नतीजतन, हमारी संख्या पहले नकारात्मक थी, और फिर यह फिर से सकारात्मक हो गई!

• वृद्धि (++) और कमी (--)

ऑपरेटर ++एक संख्या को एक से बढ़ाता है, और --ऑपरेटर उसी राशि से संख्या को कम करता है।

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

कंसोल आउटपुट: 1000 999 यदि आपने C++ भाषा के बारे में सुना है तो यह नोटेशन आपके लिए परिचित हो सकता है। इसके रचनाकारों ने इस दिलचस्प नाम का उपयोग इस विचार को व्यक्त करने के लिए किया कि "सी ++ सी भाषा का विस्तार है" नोटपैड का एक लोकप्रिय उन्नत संस्करण नोटपैड ++ कहलाता है यहां एक महत्वपूर्ण बिंदु है। दो प्रकार के इंक्रीमेंट और डिक्रीमेंट ऑपरेटर हैं: पोस्टफ़िक्स और प्रीफ़िक्स । x++- पोस्टफ़िक्स ++x- उपसर्ग नंबर के पहले या बाद में प्लसस/माइनस लगाने के बीच मूलभूत अंतर क्या है? हम निम्नलिखित उदाहरण में देखेंगे:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

कंसोल आउटपुट: 999 कुछ ठीक नहीं है! हम 1 से बढ़ाना चाहते थे xऔर वेरिएबल y को नया मान देना चाहते थे। दूसरे शब्दों में, y 1000 होना चाहिए। लेकिन इसके बजाय हमें कुछ और मिलता है: 999। ऐसा लगता है कि x को बढ़ाया नहीं गया था और इंक्रीमेंट ऑपरेटर ने काम नहीं किया? लेकिन इसने काम किया। अपने आप को समझाने के लिए, xअंत में प्रदर्शित करने का प्रयास करें :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

कंसोल आउटपुट: 999 1000 वास्तव में, यही कारण है कि इस ऑपरेशन को पोस्टफिक्स कहा जाता है: यह मुख्य अभिव्यक्ति के बाद किया जाता है। इसका अर्थ है, हमारे मामले में: int y = x++; y = xपहले किया जाता है (और वेरिएबल को ) yके मान से प्रारंभ किया जाएगा x, और उसके बाद ही x++निष्पादित किया जाएगा यदि यह वह व्यवहार नहीं है जो हम चाहते हैं? फिर हमें उपसर्ग संकेतन का उपयोग करने की आवश्यकता है:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

इस मामले में, ++xपहले संसाधित किया जाता है और उसके बाद ही होता है y = x; निष्पादित। वास्तविक कार्यक्रम में गलतियों से बचने के लिए आपको इस अंतर को स्मृति में तुरंत करना चाहिए, जहां पोस्टफिक्स का उपयोग करने के बजाय उपसर्ग सब कुछ उल्टा कर सकता है :)

यौगिक संचालक

इसके अलावा, जावा में तथाकथित कंपाउंड ऑपरेटर हैं। वे दो ऑपरेटरों को जोड़ते हैं:

• कार्यभार
• अंकगणितीय आपरेटर

इसमे शामिल है:

• +=
• -=
• *=
• /=
• %=

आइए एक उदाहरण पर विचार करें:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

कंसोल आउटपुट: 1032 x += y का अर्थ है x = x + y। संक्षिप्तता के लिए दो प्रतीकों का लगातार उपयोग किया जाता है। संयोजन -=, *=, /=और %=समान तरीके से काम करते हैं।

लॉजिकल ऑपरेटर्स

न्यूमेरिक ऑपरेटर्स के अलावा, जावा में ऐसे ऑपरेशन भी हैं जिनमें बूलियन वैल्यू ( सही और गलत ) शामिल हैं। ये ऑपरेशन तार्किक ऑपरेटरों का उपयोग करके किए जाते हैं

• !- तार्किक नहीं । यह एक बूलियन के मान को फ़्लिप करता है

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

कंसोल आउटपुट: झूठा

• &&- तार्किक और । यह तभी सही होता है जब दोनों ऑपरेंड सत्य होते हैं।

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

कंसोल आउटपुट: गलत सच पहले ऑपरेशन का परिणाम गलत है, क्योंकि एक ऑपरेंड गलत है, अर्थात् 100 > 200। सही होने के लिए, &&ऑपरेटर को यह आवश्यक है कि दोनों ऑपरेंड सत्य हों (जैसा कि दूसरी पंक्ति में है)।

• ||- तार्किक या । जब कम से कम एक ऑपरेंड सत्य होता है तो यह सच हो जाता है ।

जब हम इस ऑपरेटर का उपयोग करते हैं, तो हमारा पिछला उदाहरण एक अलग परिणाम उत्पन्न करता है:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

कंसोल आउटपुट: सत्य अभिव्यक्ति 100 > 200अभी भी गलत है, लेकिन OR ऑपरेटर के लिए यह पूरी तरह से पर्याप्त है कि पहला भाग ( 100 > 10) सत्य है।