Java Language
ऑपरेटर्स

परिचय

टिप्पणियों

स्ट्रिंग कॉनटैनेशन ऑपरेटर (+)

+ प्रतीक का अर्थ जावा में तीन अलग-अलग ऑपरेटरों से हो सकता है:

• अगर + से पहले कोई ऑपरेंड नहीं है, तो यह यूनीरी प्लस ऑपरेटर है।
• यदि दो ऑपरेंड हैं, और वे दोनों संख्यात्मक हैं। तो यह बाइनरी एडिशन ऑपरेटर है।
• यदि दो ऑपरेंड हैं, और उनमें से कम से कम एक String , तो यह बाइनरी कॉन्टेनेशन ऑपरेटर है।

साधारण मामले में, कॉनकैटैनेशन ऑपरेटर तीसरी स्ट्रिंग देने के लिए दो तार से जुड़ता है। उदाहरण के लिए:

String s1 = "a String";
String s2 = "This is " + s1;    // s2 contains "This is a String"

जब दो ऑपरेंड में से एक एक स्ट्रिंग नहीं है, यह एक में बदल जाती है String इस प्रकार है:

• एक ऑपरेंड जिसका प्रकार एक आदिम प्रकार है, जैसे कि बॉक्सिंग मूल्य पर toString() कॉल करके परिवर्तित किया जाता है ।

• एक ऑपरेंड जिसका प्रकार एक संदर्भ प्रकार है, को ऑपरेंड के toString() पद्धति से कॉल करके परिवर्तित किया जाता है। यदि ऑपरेंड null , या यदि toString() विधि null , तो इसके बजाय स्ट्रिंग शाब्दिक "null" का उपयोग किया जाता है।

उदाहरण के लिए:

int one = 1;
String s3 = "One is "  + one;         // s3 contains "One is 1"
String s4 = null + " is null";        // s4 contains "null is null"
String s5 = "{1} is " + new int[]{1}; // s5 contains something like
                                      // "{} is [I@xxxxxxxx"

s5 उदाहरण के लिए स्पष्टीकरण यह है कि सरणी प्रकारों पर toString() विधि java.lang.Object से विरासत में मिली है, और व्यवहार एक स्ट्रिंग का उत्पादन करने के लिए है जिसमें प्रकार नाम और ऑब्जेक्ट की पहचान हैशकोड है।

कॉनसेन्टेशन ऑपरेटर एक नई String ऑब्जेक्ट बनाने के लिए निर्दिष्ट किया जाता है, इस मामले को छोड़कर जहां अभिव्यक्ति एक निरंतर अभिव्यक्ति है। बाद के मामले में, अभिव्यक्ति का संकलन प्रकार पर मूल्यांकन किया जाता है, और इसका रनटाइम मान एक स्ट्रिंग शाब्दिक के बराबर है। इसका मतलब यह है कि इस तरह एक लंबी स्ट्रिंग शाब्दिक विभाजन में कोई रनटाइम ओवरहेड नहीं है:

String typing = "The quick brown fox " +
                "jumped over the " +
                "lazy dog";           // constant expression

अनुकूलन और दक्षता

जैसा कि ऊपर उल्लेख किया गया है, निरंतर अभिव्यक्तियों के अपवाद के साथ, प्रत्येक स्ट्रिंग संयोजन अभिव्यक्ति एक नया String ऑब्जेक्ट बनाता है। इस कोड पर विचार करें:

public String stars(int count) {
    String res = "";
    for (int i = 0; i < count; i++) {
        res = res + "*";
    }
    return res;
}

उपरोक्त विधि में, लूप का प्रत्येक पुनरावृत्ति एक नया String बनाएगा जो पिछले पुनरावृत्ति की तुलना में एक वर्ण लंबा है। प्रत्येक कॉन्फिडेंशियल स्ट्रिंग्स के सभी पात्रों को नए String रूप में कॉपी करता है। इस प्रकार, stars(N) होगा:

• N नई String ऑब्जेक्ट्स बनाएं, और सभी को फेंक दें, लेकिन अंतिम एक,
• कॉपी N * (N + 1) / 2 अक्षर, और
• O(N^2) कचरे का बाइट जनरेट करें।

यह बड़े N लिए बहुत महंगा है। वास्तव में, कोई भी कोड जो एक लूप में तार को समाप्‍त करता है, इस समस्‍या के लिए उत्तरदायी है। इसे लिखने का एक बेहतर तरीका इस प्रकार होगा:

public String stars(int count) {
    // Create a string builder with capacity 'count' 
    StringBuilder sb = new StringBuilder(count);
    for (int i = 0; i < count; i++) {
        sb.append("*");
    }
    return sb.toString();
}

आदर्श रूप में, आप की क्षमता स्थापित करना चाहिए StringBuilder , लेकिन अगर यह व्यावहारिक नहीं है, वर्ग स्वचालित रूप से समर्थन देता है कि बिल्डर का उपयोग करता है वर्ण धारण करने के लिए बड़ा हो जाएगा। (ध्यान दें: कार्यान्वयन बैकिंग सरणी को तेजी से विस्तारित करता है। यह रणनीति O(N^2) बजाय O(N) नकल करने वाले वर्ण की मात्रा को बनाए रखती है।)

कुछ लोग इस पैटर्न को सभी स्ट्रिंग कॉन्फैक्शन में लागू करते हैं। हालाँकि, यह अनावश्यक है क्योंकि JLS जावा संकलक को एकल अभिव्यक्ति के भीतर स्ट्रिंग संघनन का अनुकूलन करने की अनुमति देता है। उदाहरण के लिए:

String s1 = ...;
String s2 = ...;    
String test = "Hello " + s1 + ". Welcome to " + s2 + "\n";

आम तौर पर कुछ इस तरह से bytecode संकलक द्वारा अनुकूलित किया जाएगा;

StringBuilder tmp = new StringBuilder();
tmp.append("Hello ")
tmp.append(s1 == null ? "null" + s1);
tmp.append("Welcome to ");
tmp.append(s2 == null ? "null" + s2);
tmp.append("\n");
String test = tmp.toString();

(JIT कंपाइलर इसे और ऑप्टिमाइज़ कर सकता है अगर यह डिसाइड कर सकता है कि s1 या s2 null नहीं हो सकता है।) लेकिन ध्यान दें कि यह ऑप्टिमाइज़ेशन केवल एक ही एक्सप्रेशन के भीतर अनुमत है।

संक्षेप में, यदि आप स्ट्रिंग संघनन की दक्षता के बारे में चिंतित हैं:

• यदि आप एक लूप (या समान) में बार-बार कंक्रीटिंग कर रहे हैं, तो हाथ से अनुकूलन करें।
• एक एकल अभिव्यक्ति अभिव्यक्ति को हाथ से अनुकूलित न करें।

अंकगणितीय संचालक (+, -, *, /,%)

जावा भाषा 7 ऑपरेटर प्रदान करती है जो पूर्णांक और फ्लोटिंग पॉइंट वैल्यू पर अंकगणित करते हैं।

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

^{1. यह अक्सर गलत तरीके से "मापांक" ऑपरेटर के रूप में जाना जाता है। "रेमेडर" वह शब्द है जिसका उपयोग जेएलएस द्वारा किया जाता है। "मापुलस" और "शेष" एक ही बात नहीं हैं।}

ऑपरेंड और परिणाम प्रकार, और संख्यात्मक पदोन्नति

ऑपरेटरों को संख्यात्मक ऑपरेंड की आवश्यकता होती है और संख्यात्मक परिणाम उत्पन्न करते हैं। ऑपरेंड प्रकार किसी भी आदिम संख्यात्मक प्रकार (जैसे byte , short , char , int , long , float या double ) या किसी भी न्यूमेरिक आवरण प्रकार java.lang में परिभाषित हो सकते java.lang ; यानी ( Byte , Character , Short , Integer , Long , Float या Double ।

परिणाम प्रकार ऑपरेटर या ऑपरेंड के प्रकारों के आधार पर निर्धारित किया जाता है, इस प्रकार है:

• यदि दोनों में से कोई भी ऑपरेंड double या Double , तो परिणाम प्रकार double ।
• अन्यथा, यदि या तो ऑपरेंड float या Float , तो परिणाम प्रकार float ।
• अन्यथा, यदि या तो ऑपरेंड long या Long , तो परिणाम प्रकार long ।
• अन्यथा, परिणाम प्रकार int । यह byte , short और char ऑपरेंड के साथ-साथ `इंट को भी कवर करता है।

ऑपरेशन का परिणाम प्रकार निर्धारित करता है कि अंकगणितीय ऑपरेशन कैसे किया जाता है, और ऑपरेंड कैसे संभाला जाता है

• यदि परिणाम प्रकार double , तो ऑपरेंड को double पदोन्नत किया जाता है, और 64-बिट (डबल परिशुद्धता बाइनरी) IEE 754 फ्लोटिंग पॉइंट अंकगणितीय का उपयोग करके ऑपरेशन किया जाता है।
• यदि परिणाम प्रकार float , तो ऑपरेंड को float करने के लिए बढ़ावा दिया जाता है, और 32-बिट (एकल परिशुद्धता बाइनरी) IEE 754 फ्लोटिंग पॉइंट अंकगणितीय का उपयोग करके ऑपरेशन किया जाता है।
• यदि परिणाम प्रकार long , तो ऑपरेंड्स को long बढ़ावा दिया जाता है, और 64-बिट हस्ताक्षरित द्वि-पूरक बाइनरी पूर्णांक अंकगणित का उपयोग करके ऑपरेशन किया जाता है।
• यदि परिणाम प्रकार int , तो ऑपरेंड को int पदोन्नत किया जाता है, और ऑपरेशन 32-बिट हस्ताक्षरित द्वि-पूरक बाइनरी पूर्णांक अंकगणित का उपयोग करके किया जाता है।

पदोन्नति दो चरणों में की जाती है:

• यदि ऑपरेंड प्रकार एक आवरण प्रकार है, तो ऑपरेंड वैल्यू संबंधित आदिम प्रकार के मान से अनबॉक्स किया जाता है।
• यदि आवश्यक हो, तो आवश्यक प्रकार के लिए आदिम प्रकार को बढ़ावा दिया जाता है:
  • को पूर्णांकों का संवर्धन int या long हानि-कम है।
  • float को double करने का प्रचार नुकसान-कम है।
  • एक पूर्णांक के लिए एक अस्थायी बिंदु मान को बढ़ावा देने से परिशुद्धता का नुकसान हो सकता है। रूपांतरण IEE 768 "गोल-से-निकटतम" शब्दार्थ का उपयोग करके किया जाता है।

विभाजन का अर्थ

/ ऑपरेटर बाएं हाथ के ऑपरेंड n ( डिविडेंड ) और राइट-हैंड ऑपरेंड d ( विभाजक ) को विभाजित करता है और परिणाम q ( भागफल ) का उत्पादन करता है।

जावा पूर्णांक विभाजन शून्य की ओर गोल होता है। JLS धारा 15.17.2 जावा पूर्णांक विभाजन के व्यवहार को निम्नानुसार निर्दिष्ट करता है:

ऑपरेंड n और d लिए निर्मित भागफल एक पूर्णांक मान q जिसकी मात्रा संतोषजनक रहते हुए यथासंभव बड़ी है |d ⋅ q| ≤ |n| । इसके अलावा, q सकारात्मक है जब |n| ≥ |d| और n और d का चिन्ह एक ही है, लेकिन q ऋणात्मक है जब |n| ≥ |d| और n और d में विपरीत संकेत हैं।

कुछ विशेष मामले हैं:

• यदि n MIN_VALUE , और विभाजक -1 है, तो पूर्णांक अतिप्रवाह होता है और परिणाम MIN_VALUE । इस मामले में कोई अपवाद नहीं फेंका गया है।
• यदि d 0 है, तो `ArithmeticException को फेंक दिया जाता है।

जावा फ्लोटिंग पॉइंट डिवीजन में विचार करने के लिए अधिक किनारे मामले हैं। हालाँकि मूल विचार यह है कि परिणाम q वह मान है जो संतोषजनक d . q = n निकटतम है d . q = n ।

फ्लोटिंग पॉइंट डिवीजन कभी भी अपवाद नहीं होगा। इसके बजाय, एक इन्फो और NaN मूल्यों में शून्य से विभाजित होने वाले ऑपरेशन; निचे देखो।

शेष का अर्थ

C और C ++ के विपरीत, जावा में शेष ऑपरेटर पूर्णांक और फ्लोटिंग पॉइंट ऑपरेशन दोनों के साथ काम करता है।

पूर्णांक मामलों के लिए, a % b का परिणाम संख्या r इस प्रकार निर्धारित किया जाता है कि (a / b) * b + r एक बराबर a , जहाँ / , * और + उपयुक्त Java पूर्णांक ऑपरेटर हैं। यह सभी मामलों में लागू होता है सिवाय जब b शून्य हो। उस स्थिति में, शेष ArithmeticException में परिणाम होता है।

इससे उपरोक्त परिभाषा से इस प्रकार a % b नकारात्मक हो सकता ही अगर a नकारात्मक है, और यह सकारात्मक केवल तभी हो सकता है a सकारात्मक है। इसके अलावा, की भयावहता a % b हमेशा की भयावहता से कम है b ।

फ्लोटिंग पॉइंट शेष ऑपरेशन पूर्णांक मामले का एक सामान्यीकरण है। a % b का परिणाम शेष r है जिसे गणितीय संबंध r = a - (b ⋅ q) द्वारा परिभाषित किया गया है:

• q एक पूर्णांक है,
• यह नकारात्मक है केवल तभी a / b ऋणात्मक है यदि केवल a / b धनात्मक है, और
• a और b के वास्तविक गणितीय भागफल के परिमाण को पार किए बिना इसका परिमाण जितना संभव हो उतना बड़ा है।

फ़्लोटिंग पॉइंट शेष, किनारे वाले मामलों में INF और NaN मान उत्पन्न कर सकता है, जैसे कि b शून्य है; निचे देखो। यह एक अपवाद नहीं फेंकेंगे।

महत्वपूर्ण लेख:

% द्वारा गणना की गई फ्लोटिंग-पॉइंट शेष ऑपरेशन का परिणाम IEEE 754 द्वारा परिभाषित शेष ऑपरेशन द्वारा उत्पादित के समान नहीं है । IEEE 754 शेष की गणना Math.IEEEremainder लाइब्रेरी पद्धति का उपयोग करके की जा सकती है।

पूर्णांक अतिप्रवाह

जावा 32 और 64 बिट पूर्णांक मानों पर हस्ताक्षर किए गए हैं और द्वि-पूरक बाइनरी प्रतिनिधित्व का उपयोग करते हैं। उदाहरण के लिए, +2 ³¹ - 1 के माध्यम से (32 बिट) int -2 ^{31 के} रूप में प्रतिनिधित्व करने योग्य संख्या की सीमा।

जब आप जोड़ते हैं, घटाते हैं या कई दो N बिट पूर्णांक (N == 32 या 64) करते हैं, तो ऑपरेशन का परिणाम N बिट पूर्णांक के रूप में प्रतिनिधित्व करने के लिए बहुत बड़ा हो सकता है। इस स्थिति में, ऑपरेशन पूर्णांक अतिप्रवाह की ओर जाता है, और परिणाम निम्नानुसार गणना की जा सकती है:

• गणितीय ऑपरेशन पूरे नंबर की एक मध्यवर्ती दो-पूरक प्रतिनिधित्व देने के लिए किया जाता है। यह प्रतिनिधित्व N बिट्स से बड़ा होगा।
• मध्यवर्ती 32 या 64 बिट्स के निचले भाग को परिणाम के रूप में उपयोग किया जाता है।

यह ध्यान दिया जाना चाहिए कि पूर्णांक ओवरफ़्लो किसी भी परिस्थिति में अपवाद नहीं होता है।

फ़्लोटिंग पॉइंट INF और NAN मान

जावा के लिए IEE 754 फ्लोटिंग बिंदु निरूपण का उपयोग करता float और double । इन अभ्यावेदन में मूल्यों का प्रतिनिधित्व करने के लिए कुछ विशेष मूल्य होते हैं जो वास्तविक संख्या के डोमेन के बाहर आते हैं:

• "अनंत" या INF मान संख्याओं को दर्शाता है जो बहुत बड़ी हैं। +INF मान उन संख्याओं को दर्शाता है जो बहुत बड़ी और सकारात्मक हैं। -INF मान उन संख्याओं को दर्शाता है जो बहुत बड़ी और नकारात्मक होती हैं।
• "अनिश्चित" / "एक नंबर नहीं" या NaN अर्थहीन कार्यों के परिणामस्वरूप मूल्यों को दर्शाता है।

INF मान फ़्लोटिंग ऑपरेशन के कारण उत्पन्न होते हैं, जो अतिप्रवाह या शून्य द्वारा विभाजन के कारण होते हैं।

NaN मान शून्य से शून्य को विभाजित करके या शून्य शेष शून्य की गणना करके उत्पादित किए जाते हैं।

हैरानी की बात है, यह अपवाद को ट्रिगर किए बिना INF और NaN ऑपरेंड का उपयोग करके अंकगणित करना संभव है। उदाहरण के लिए:

• + INF और एक परिमित मूल्य जोड़ना + INF देता है।
• + INF और + INF जोड़ना + INF देता है।
• + INF और -INF जोड़ने से NaN मिलता है।
• INF द्वारा विभाजन या तो +0.0 या -0.0 देता है।
• एक या एक से अधिक NaN ऑपरेंड वाले सभी ऑपरेशन NaN देते हैं।

पूर्ण विवरण के लिए, कृपया JLS 15 के संबंधित उपखंडों का संदर्भ लें। ध्यान दें कि यह काफी हद तक "अकादमिक" है। विशिष्ट गणना के लिए, एक INF या NaN मतलब है कि कुछ गलत हो गया है; जैसे आपके पास अधूरा या गलत इनपुट डेटा है, या गणना को गलत तरीके से प्रोग्राम किया गया है।

समानता ऑपरेटरों (==; =!)

== और != ऑपरेटर बाइनरी ऑपरेटर हैं जो true या false मूल्यांकन करते हैं, यह इस बात पर निर्भर करता है कि ऑपरेटर समान हैं या नहीं। == ऑपरेटर true देता true यदि ऑपरेंड बराबर और false हैं। != ऑपरेटर false देता false यदि ऑपरेंड समान और true हैं।

इन ऑपरेटरों को आदिम और संदर्भ प्रकारों के साथ ऑपरेंड का उपयोग किया जा सकता है, लेकिन व्यवहार काफी अलग है। जेएलएस के अनुसार, वास्तव में इन ऑपरेटरों के तीन अलग-अलग सेट हैं:

• बुलियन == और != ऑपरेटरों।
• न्यूमेरिक == और != ऑपरेटर।
• संदर्भ == और != ऑपरेटर।

हालाँकि, सभी मामलों में, == और != ऑपरेटरों का परिणाम प्रकार boolean ।

न्यूमेरिक == और != ऑपरेटर

जब == या != परिचालकों में से एक (या दोनों) एक आदिम संख्यात्मक प्रकार ( byte , short , char , int, long , float या double ) है, तो ऑपरेटर एक संख्यात्मक तुलना है। दूसरा ऑपरेंड या तो एक आदिम संख्यात्मक प्रकार, या एक बॉक्सेड संख्यात्मक प्रकार होना चाहिए।

व्यवहार अन्य सांख्यिक ऑपरेटर इस प्रकार है:

1. यदि ऑपरेंड में से एक बॉक्सिंग प्रकार है, तो यह अनबॉक्स है।
2. यदि दोनों में से कोई भी एक byte , short या char , अब प्रमोट किया जाता है, तो उसे int में प्रमोट कर दिया जाता है।
3. यदि ऑपरेंड के प्रकार समान नहीं हैं, तो "छोटे" प्रकार वाले ऑपरेंड को "बड़े" प्रकार में बढ़ावा दिया जाता है।
4. तुलना तब निम्न प्रकार से की जाती है:
   • यदि पदोन्नत ऑपरेंड int या long तो मूल्यों को देखने के लिए परीक्षण किया जाता है कि क्या वे समान हैं।
   • यदि पदोन्नत ऑपरेंड float या double तो:
     • शून्य (के दो संस्करण +0.0 और -0.0 ) बराबर के रूप में इलाज कर रहे हैं
     • एक NaN मान को किसी भी चीज़ के बराबर नहीं माना जाता है, और
     • अन्य मान समान हैं यदि उनका IEEE 754 प्रतिनिधित्व समान है।

नोट: फ्लोटिंग पॉइंट वैल्यू की तुलना करने के लिए आपको == और != का उपयोग करते समय सावधानी बरतने की आवश्यकता है।

बुलियन == और != ऑपरेटरों

यदि दोनों ऑपरेंड boolean , या एक boolean और दूसरा Boolean , तो ये ऑपरेटर बूलियन == और != ऑपरेटर हैं। व्यवहार इस प्रकार है:

1. यदि ऑपरेंड में से एक Boolean , तो यह अनबॉक्स है।
2. अनबॉक्स किए गए ऑपरेंड का परीक्षण किया जाता है और बूलियन परिणाम की गणना निम्न सत्य तालिका के अनुसार की जाती है

दो "नुकसान" हैं जो इसे उपयोग करने की सलाह देते हैं == और != सत्य मूल्यों के साथ संयम से:

• यदि आप दो Boolean वस्तुओं की तुलना करने के लिए == या != का उपयोग करते हैं, तो संदर्भ ऑपरेटरों का उपयोग किया जाता है। यह एक अप्रत्याशित परिणाम दे सकता है; देखें औसतन जैसे आदिम आवरण की वस्तुओं की तुलना करने के लिए == का उपयोग करना

• == ऑपरेटर को आसानी से = रूप में गलत किया जा सकता है। अधिकांश ऑपरेंड प्रकारों के लिए, यह गलती संकलन त्रुटि की ओर ले जाती है। हालांकि, boolean और Boolean ऑपरेंड के लिए गलती गलत रनटाइम व्यवहार की ओर ले जाती है; बूलियन का परीक्षण करने के लिए '==' का उपयोग करना

संदर्भ == और != ऑपरेटर

यदि दोनों ऑपरेंड ऑब्जेक्ट रेफरेंस हैं, तो == और != ऑपरेटर्स टेस्ट करते हैं यदि दोनों ऑपरेंड एक ही ऑब्जेक्ट को संदर्भित करते हैं । यह अक्सर वह नहीं होता जो आप चाहते हैं। यह जांचने के लिए कि क्या दो वस्तुएं मूल्य के बराबर हैं, इसके बजाय। .equals() विधि का उपयोग किया जाना चाहिए।

String s1 = "We are equal";
String s2 = new String("We are equal");

s1.equals(s2); // true

// WARNING - don't use == or != with String values
s1 == s2;      // false

चेतावनी: String मूल्यों की तुलना करने के लिए == और != का उपयोग करना ज्यादातर मामलों में गलत है; http://www.riptutorial.com/java/example/16290/pitfall--using----to-compare-strings देखें। एक समान समस्या आदिम आवरण के प्रकारों पर लागू होती है; देखें http://www.riptutorial.com/java/example/8996/pitfall--using----to-compare-primitive-wrappers-objects-such-as-integer ।

NaN बढ़त-मामलों के बारे में

JLS 15.21.1 निम्नलिखित बताता है:

यदि या तो ऑपरेंड NaN , तो == का परिणाम false लेकिन परिणाम का != true । वास्तव में, परीक्षण x != x true यदि और केवल यदि x का मान NaN ।

यह व्यवहार (अधिकांश प्रोग्रामर के लिए) अप्रत्याशित है। यदि आप परीक्षण करते हैं कि क्या NaN मान स्वयं के बराबर है, तो उत्तर है "नहीं, यह नहीं है!"। दूसरे शब्दों में, == के लिए बाध्य नहीं है NaN मूल्यों।

हालांकि, यह एक जावा "विषमता" नहीं है, यह व्यवहार IEEE 754 फ़्लोटिंग-पॉइंट मानकों में निर्दिष्ट है, और आप पाएंगे कि यह अधिकांश आधुनिक प्रोग्रामिंग भाषाओं द्वारा कार्यान्वित किया गया है। (अधिक जानकारी के लिए, http://stackoverflow.com/a/1573715/139985 देखें ... यह देखते हुए कि यह किसी ऐसे व्यक्ति द्वारा लिखा गया है जो "कमरे में थे जब निर्णय किए गए थे!"

वेतन वृद्धि / कमी ऑपरेटर (++ / -)

क्रमशः ++ और -- ऑपरेटर्स का उपयोग करके चर को 1 से बढ़ा या घटाया जा सकता है।

जब ++ और -- ऑपरेटर वैरिएबल का अनुसरण करते हैं, तो उन्हें क्रमशः पोस्ट-इंक्रीमेंट और पोस्ट-डिक्रीमेंट कहा जाता है।

int a = 10;
a++; // a now equals 11
a--; // a now equals 10 again

जब ++ और -- ऑपरेटर्स वैरिएबल से पहले होते हैं तो ऑपरेशंस को क्रमशः प्री-इंक्रीमेंट और प्री-डिक्रीमेंट कहा जाता है।

int x = 10;
--x; // x now equals 9
++x; // x now equals 10

यदि ऑपरेटर वैरिएबल से पहले है, तो एक्सप्रेशन का मूल्य बढ़ने या घटने के बाद वेरिएबल का मूल्य है। यदि ऑपरेटर वेरिएबल का अनुसरण करता है, तो एक्सप्रेशन का मूल्य वर्धित या डीग्रेड होने से पहले वेरिएबल का मान है।

int x=10;

System.out.println("x=" + x + " x=" + x++ + " x=" + x); // outputs x=10 x=10 x=11
System.out.println("x=" + x + " x=" + ++x + " x=" + x); // outputs x=11 x=12 x=12
System.out.println("x=" + x + " x=" + x-- + " x=" + x); // outputs x=12 x=12 x=11
System.out.println("x=" + x + " x=" + --x + " x=" + x); // outputs x=11 x=10 x=10

ध्यान रखें कि पोस्ट-इन्क्रीमेंट्स या डीरेक्शंस को ओवरराइट न करें। ऐसा तब होता है जब आप एक अभिव्यक्ति के अंत में एक पोस्ट-इन / डिक्रिप्शन ऑपरेटर का उपयोग करते हैं जो कि / डीरेक्टेड वेरिएबल में ही फिर से असाइन किया जाता है। में / गिरावट का असर नहीं होगा। भले ही बाएं हाथ की तरफ चर सही ढंग से बढ़े हुए हैं, अभिव्यक्ति के दाहिने हाथ की ओर से पहले से मूल्यांकन किए गए परिणाम के साथ इसका मूल्य तुरंत अधिलेखित हो जाएगा:

int x = 0; 
x = x++ + 1 + x++;      // x = 0 + 1 + 1 
                        // do not do this - the last increment has no effect (bug!) 
System.out.println(x);  // prints 2 (not 3!) 

सही बात:

int x = 0;
x = x++ + 1 + x;        // evaluates to x = 0 + 1 + 1
x++;                    // adds 1
System.out.println(x);  // prints 3 

सशर्त संचालक (?)

वाक्य - विन्यास

{हालत-से-मूल्यांकन} ? {कथन-निष्पादित-पर-सच} : {कथन-निष्पादित-पर-गलत}

सिंटैक्स में दिखाया गया है, सशर्त संचालक (जिसे टर्नरी संचालक ¹ भी कहा जाता है) का उपयोग करता है ? (प्रश्न चिह्न) और : (कोलन) अक्षर दो संभावित परिणामों की एक सशर्त अभिव्यक्ति को सक्षम करने के लिए। इसका उपयोग लंबे समय तक प्रतिस्थापित करने के लिए किया जा सकता है if-else स्थिति के आधार पर दो मूल्यों में से एक को वापस करने के लिए ब्लॉक करता है।

result = testCondition ? value1 : value2

के बराबर है

if (testCondition) { 
    result = value1; 
} else { 
    result = value2; 
}

इसे पढ़ा जा सकता है, “यदि परीक्षण सही है, तो परिणाम को मान 1 पर सेट करें; अन्यथा, value2 पर परिणाम सेट करें ”।

उदाहरण के लिए:

// get absolute value using conditional operator 
a = -10;
int absValue = a < 0 ? -a : a;
System.out.println("abs = " + absValue); // prints "abs = 10"

के बराबर है

// get absolute value using if/else loop
a = -10;
int absValue;
if (a < 0) {
    absValue = -a;
} else {
    absValue = a;
}
System.out.println("abs = " + absValue); // prints "abs = 10"

सामान्य उपयोग

आप सशर्त असाइनमेंट (जैसे नल जाँच) के लिए सशर्त ऑपरेटर का उपयोग कर सकते हैं।

String x = y != null ? y.toString() : ""; //where y is an object

यह उदाहरण इसके बराबर है:

String x = "";

if (y != null) {
    x = y.toString();
}

चूंकि सशर्त संचालक की दूसरी सबसे कम वरीयता है, असाइनमेंट ऑपरेटर्स के ऊपर, शायद ही कभी हालत के आसपास कोष्ठक का उपयोग करने की आवश्यकता होती है, लेकिन अन्य संचालकों के साथ संयुक्त होने पर पूरे सशर्त संचालक निर्माण के आसपास कोष्ठक की आवश्यकता होती है:

// no parenthesis needed for expressions in the 3 parts
10 <= a && a < 19 ? b * 5 : b * 7

// parenthesis required
7 * (a > 0 ? 2 : 5)

सशर्त संचालक घोंसले का शिकार तीसरे भाग में भी किया जा सकता है, जहां यह अधिक काम करता है जैसे कि पीछा करना या स्विच स्टेटमेंट की तरह।

a ? "a is true" :
b ? "a is false, b is true" :
c ? "a and b are false, c is true" :
    "a, b, and c are false"

//Operator precedence can be illustrated with parenthesis:

a ? x : (b ? y : (c ? z : w))

पाद लेख:

^{- 1 दोनों जावा भाषा विशिष्टता और जावा ट्यूटोरियल (फोन ? : ) ऑपरेटर सशर्त ऑपरेटर। ट्यूटोरियल कहता है कि यह "टर्नरी ऑपरेटर के रूप में भी जाना जाता है" जैसा कि यह (वर्तमान में) जावा द्वारा परिभाषित एकमात्र टर्नेरी ऑपरेटर है। "सशर्त संचालक" शब्दावली सी और सी ++ और अन्य भाषाओं में एक समतुल्य ऑपरेटर के साथ संगत है।}

बिटवाइज़ एंड लॉजिकल ऑपरेटर्स (~, &, |, ^)

जावा भाषा 4 ऑपरेटर प्रदान करती है जो पूर्णांक या बूलियन ऑपरेंड पर बिटवाइज़ या लॉजिकल ऑपरेशन करते हैं।

• पूरक ( ~ ) ऑपरेटर एक संयुक्त ऑपरेटर है जो एक ऑपरेंड के बिट्स का एक बिटवाइज़ या लॉजिकल इनवर्जन करता है; JLS 15.15.5 देखें । ।
• AND ( & ) ऑपरेटर एक द्विआधारी ऑपरेटर है जो एक बिटवाइज़ या लॉजिकल और "दो ऑपरेंड" करता है; JLS 15.22.2 देखें । ।
• या ( | ) ऑपरेटर एक द्विआधारी ऑपरेटर है कि प्रदर्शन एक बिटवाइज़ या तार्किक "समावेशी या" दो ऑपरेंड की; JLS 15.22.2 देखें । ।
• XOR ( ^ ) ऑपरेटर एक द्विआधारी ऑपरेटर है जो दो ऑपरेंड्स का एक बिटवाइज़ या लॉजिकल "एक्सक्लूसिव या" करता है; JLS 15.22.2 देखें । ।

इन ऑपरेटरों द्वारा किए गए तार्किक संचालन, जब ऑपरेंड बूलियन होते हैं, को निम्नानुसार संक्षेप में प्रस्तुत किया जा सकता है:

ध्यान दें कि पूर्णांक ऑपरेंड के लिए, उपरोक्त तालिका में वर्णित है कि व्यक्तिगत बिट्स के लिए क्या होता है। ऑपरेटर्स वास्तव में समांतर या ऑपरेंड के सभी 32 या 64 बिट्स पर काम करते हैं।

ऑपरेंड प्रकार और परिणाम प्रकार।

सामान्य अंकगणितीय रूपांतरण तब लागू होते हैं जब ऑपरेंड पूर्णांक होते हैं। बिटवाइज ऑपरेटरों के लिए सामान्य उपयोग के मामले

~ ऑपरेटर का उपयोग बूलियन मान को उलटने के लिए किया जाता है, या पूर्णांक ऑपरेटर में सभी बिट्स को बदलने के लिए।

& पूर्णांक ऑपरेटर में बिट्स में से कुछ को "मास्किंग आउट" करने के लिए ऑपरेटर का उपयोग किया जाता है। उदाहरण के लिए:

int word = 0b00101010;
int mask = 0b00000011;   // Mask for masking out all but the bottom 
                         // two bits of a word
int lowBits = word & mask;            // -> 0b00000010
int highBits = word & ~mask;          // -> 0b00101000

| ऑपरेटर का उपयोग दो ऑपरेंड के सत्य मूल्यों को संयोजित करने के लिए किया जाता है। उदाहरण के लिए:

int word2 = 0b01011111; 
// Combine the bottom 2 bits of word1 with the top 30 bits of word2
int combined = (word & mask) | (word2 & ~mask);   // -> 0b01011110

^ ऑपरेटर को टॉगल या "फ्लिपिंग" बिट्स के लिए उपयोग किया जाता है:

int word3 = 0b00101010;
int word4 = word3 ^ mask;             // -> 0b00101001

बिटवाइज़ ऑपरेटरों के उपयोग के अधिक उदाहरणों के लिए, बिट मैनिपुलेशन देखें

इंस्टैंटॉफ़ ऑपरेटर

यह ऑपरेटर जाँचता है कि क्या वस्तु एक विशेष वर्ग / इंटरफ़ेस प्रकार की है। Instof ऑपरेटर के रूप में लिखा है:

( Object reference variable ) instanceof  (class/interface type)

उदाहरण:

public class Test {

   public static void main(String args[]){
      String name = "Buyya";
      // following will return true since name is type of String
      boolean result = name instanceof String;  
      System.out.println( result );
   }
}

यह निम्नलिखित परिणाम उत्पन्न करेगा:

true

यह ऑपरेटर अभी भी सही लौटेगा यदि वस्तु की तुलना की जा रही है, दाईं ओर के प्रकार के साथ संगत असाइनमेंट है।

उदाहरण:

class Vehicle {}

public class Car extends Vehicle {
   public static void main(String args[]){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

यह निम्नलिखित परिणाम उत्पन्न करेगा:

true

असाइनमेंट ऑपरेटर्स (=, + =, - =, * =, / =,% =, << =, >> = >>>> =, & =;; = = और ^ =)

इन ऑपरेटरों के लिए बाएं हाथ का संचालन या तो एक गैर-अंतिम चर या सरणी का एक तत्व होना चाहिए। दाहिने हाथ का संचालन बाएं हाथ के संचालन के अनुरूप होना चाहिए। इसका मतलब यह है कि या तो प्रकार समान होने चाहिए, या सही ऑपरेंड प्रकार को बॉक्सिंग, अनबॉक्सिंग या चौड़ीकरण के संयोजन से बाएं ऑपरेंड प्रकार में परिवर्तनीय होना चाहिए। (पूर्ण विवरण के लिए जेएलएस 5.2 देखें।)

"ऑपरेशन और असाइन" ऑपरेटरों का सटीक अर्थ जेएलएस 15.26.2 द्वारा निर्दिष्ट किया गया है:

E1 op= E2 फॉर्म का एक मिश्रित असाइनमेंट अभिव्यक्ति E1 = (T) ((E1) op (E2)) बराबर है, जहां T E1 का प्रकार है, सिवाय इसके कि E1 का मूल्यांकन केवल एक बार किया जाता है।

ध्यान दें कि अंतिम असाइनमेंट से पहले एक अंतर्निहित प्रकार कास्ट है।

1. 1. =

सरल असाइनमेंट ऑपरेटर: बाएं हाथ के संचालन के लिए दाहिने हाथ के संचालन का मूल्य प्रदान करता है।

उदाहरण: c = a + b के मूल्य जोड़ देगा a + b के मूल्य के c और के लिए असाइन करें c

2. +=

"जोड़ें और असाइन करें" ऑपरेटर: दाएं हाथ के संचालन के मूल्य को बाएं हाथ के संचालन के मूल्य में जोड़ता है और परिणाम को बाएं हाथ के संचालन के लिए असाइन करता है। यदि बाएं हाथ के ऑपरेंड में String , तो यह एक "कॉन्कैटनेट और असाइन" ऑपरेटर है।

उदाहरण: c += a , लगभग c = c + a जैसा ही c = c + a

3. -=

"घटाना और असाइन करना" ऑपरेटर: बाएं हाथ के संचालन के मूल्य से दाएं ऑपरेंड के मूल्य को घटाता है और बाएं हाथ के ऑपरेंड को परिणाम असाइन करता है।

उदाहरण: c -= a , लगभग c = c - a जैसा ही c = c - a

4. 4. *=

"गुणा और असाइन करें" ऑपरेटर: बाएं हाथ के संचालन के मूल्य से दाहिने हाथ के संचालन के मूल्य को गुणा करता है और परिणाम को बाएं हाथ के संचालन के लिए असाइन करता है। ।

उदाहरण: c *= a , लगभग c = c * a

5. /=

"डिवाइड एंड असाइन" ऑपरेटर: बाएं हाथ के संचालन के मूल्य से दाहिने हाथ के संचालन के मूल्य को विभाजित करता है और परिणाम को बाएं हाथ के संचालन को सौंपता है।

उदाहरण: c /*= a , लगभग c = c / a जैसा ही c = c / a

6. %=

"मापांक और असाइन करें" ऑपरेटर: बाएं हाथ के संचालन के मूल्य से दाहिने हाथ के संचालन के मूल्य के मापांक की गणना करता है और बाएं हाथ के ऑपरेंड के परिणाम को असाइन करता है।

उदाहरण: c %*= a लगभग c = c % a

7. <<=

"लेफ्ट शिफ्ट और असाइन" ऑपरेटर।

उदाहरण: c <<= 2 लगभग c = c << 2

8. >>=

"अंकगणित सही पारी और असाइन करें" ऑपरेटर।

उदाहरण: c >>= 2 लगभग c = c >> 2

9. >>>=

"लॉजिकल राइट शिफ्ट और असाइन" ऑपरेटर।

उदाहरण: c >>>= 2 लगभग c = c >>> 2

10. &=

"बिटवाइज़ और असाइन" ऑपरेटर।

उदाहरण: c &= 2 लगभग c = c & 2

11. |=

"बिटवाइज़ या असाइन" ऑपरेटर।

उदाहरण: c |= 2 लगभग c = c | 2 के समान है c = c | 2

12. ^=

"बिटवाइज़ एक्सक्लूसिव या असाइन" ऑपरेटर।

उदाहरण: c ^= 2 लगभग c = c ^ 2

सशर्त-और और सशर्त-या ऑपरेटर्स (&& और ||)

जावा एक सशर्त-और एक सशर्त-या ऑपरेटर प्रदान करता है, जो दोनों प्रकार के boolean एक या दो ऑपरेंड लेते हैं और boolean परिणाम उत्पन्न करते हैं। य़े हैं:

• && - सशर्त-और ऑपरेटर,

• || - सशर्त- OR ऑपरेटर। <left-expr> && <right-expr> का मूल्यांकन निम्नलिखित छद्म कोड के बराबर है:

  {
     boolean L = evaluate(<left-expr>);
     if (L) {
         return evaluate(<right-expr>);
     } else {
         // short-circuit the evaluation of the 2nd operand expression
         return false;
     }
  }
  

का मूल्यांकन <left-expr> || <right-expr> निम्न छद्म कोड के बराबर है:

    {
       boolean L = evaluate(<left-expr>);
       if (!L) {
           return evaluate(<right-expr>);
       } else {
           // short-circuit the evaluation of the 2nd operand expression
           return true;
       }
    }

जैसा कि ऊपर छद्म कोड दिखाता है, शॉर्ट-सर्किट ऑपरेटरों के व्यवहार का उपयोग करने के लिए बराबर है if / else बयान।

उदाहरण - एक अभिव्यक्ति में गार्ड के रूप में && का उपयोग करना

निम्न उदाहरण && ऑपरेटर के लिए सबसे सामान्य उपयोग पैटर्न दिखाता है। एक आपूर्ति किए गए Integer शून्य होने पर परीक्षण करने के लिए विधि के इन दो संस्करणों की तुलना करें।

public boolean isZero(Integer value) {
    return value == 0;
}

public boolean isZero(Integer value) {
    return value != null && value == 0;
}

पहला संस्करण ज्यादातर मामलों में काम करता है, लेकिन यदि value तर्क null , तो एक NullPointerException को फेंक दिया जाएगा।

दूसरे संस्करण में हमने "गार्ड" टेस्ट जोड़ा है। value != null && value == 0 एक्सप्रेशन का मूल्यांकन पहले value != null करते हुए किया value != null test। यदि null परीक्षण सफल होता है (अर्थात यह true मूल्यांकन करता true ) तो value == 0 अभिव्यक्ति का मूल्यांकन किया जाता है। यदि null परीक्षण विफल हो जाता है, तो value == 0 का मूल्यांकन छोड़ दिया जाता है (लघु-परिचालित), और हमें NullPointerException नहीं मिलती है।

उदाहरण - महंगी गणना से बचने के लिए && का उपयोग करना

निम्न उदाहरण से पता चलता है कि अपेक्षाकृत महंगी गणना से बचने के लिए && का उपयोग कैसे किया जा सकता है:

public boolean verify(int value, boolean needPrime) {
    return !needPrime | isPrime(value);
}

public boolean verify(int value, boolean needPrime) {
    return !needPrime || isPrime(value);
}

पहले संस्करण में, दोनों ऑपरेंड | हमेशा मूल्यांकन किया जाएगा, इसलिए (महंगी) isPrime विधि को अनावश्यक रूप से कहा जाएगा। दूसरे संस्करण का उपयोग करके अनावश्यक कॉल से बचा जाता है || के बजाय | ।

शिफ्ट ऑपरेटर्स (<<, >> और >>>)

जावा भाषा 32 और 64 बिट पूर्णांक मानों पर बिटवाइज़ शिफ्टिंग करने के लिए तीन ऑपरेटर प्रदान करती है। ये सभी बाइनरी ऑपरेटर हैं, जिसमें पहला ऑपरेंड शिफ्ट होने का मूल्य है, और दूसरा ऑपरेंड कह रहा है कि कितनी दूर शिफ्ट होना है।

• << या लेफ्ट शिफ्ट ऑपरेटर दूसरे ऑपरेंड द्वारा दिए गए बिट पदों की संख्या द्वारा पहले ऑपरेंड द्वारा दिए गए मान को छोड़ देता है। दाहिने छोर पर खाली स्थान शून्य से भरे हुए हैं।

• '>>' या अंकगणितीय पारी ऑपरेटर दूसरे संकार्य द्वारा दिए गए बिट पदों की संख्या से पहले संकार्य दाये द्वारा दिए गए मूल्य बदलाव। बाएं छोर पर रिक्त स्थान बाएं-सबसे बिट की प्रतिलिपि बनाकर भरे गए हैं। इस प्रक्रिया को साइन एक्सटेंशन के रूप में जाना जाता है।

• '>>>' या तार्किक सही पारी ऑपरेटर बदलाव मूल्य दूसरे संकार्य द्वारा दिए गए बिट पदों की संख्या से पहले संकार्य दाये द्वारा दिए गए। बाएं छोर पर खाली स्थान शून्य से भरे हुए हैं।

टिप्पणियाँ:

1. इन ऑपरेटरों को पहले ऑपरेंड के रूप में एक int या long मूल्य की आवश्यकता होती है, और पहले ऑपरेंड के समान प्रकार के साथ एक मूल्य का उत्पादन करते हैं। (जब आप byte , short या char चर को शिफ्ट के परिणाम को निर्दिष्ट करते हैं तो आपको एक स्पष्ट प्रकार का उपयोग करना होगा।)

2. यदि आप पहले ऑपरेटर के साथ एक शिफ्ट ऑपरेटर का उपयोग करते हैं जो एक byte , char या short , तो इसे एक int को बढ़ावा दिया जाता है और ऑपरेशन एक int उत्पादन करता है।)

3. दूसरे ऑपरेंड को शिफ्ट की मात्रा देने के लिए ऑपरेशन के बिट्स की संख्या को कम किया जाता है । मॉड गणितीय अवधारणा के बारे में अधिक जानने के लिए, मापांक उदाहरण देखें।

4. ऑपरेशन द्वारा बाएं या दाएं छोर से स्थानांतरित किए गए बिट्स को छोड़ दिया जाता है। (जावा एक आदिम "रोटेट" ऑपरेटर प्रदान नहीं करता है।)

5. अंकगणितीय पारी ऑपरेटर 2 की शक्ति द्वारा (दो के पूरक) संख्या को विभाजित करने के बराबर है।

6. बाईं शिफ्ट ऑपरेटर 2 की शक्ति से एक (दो के पूरक) संख्या को गुणा करने के बराबर है।

निम्न तालिका आपको तीन शिफ्ट ऑपरेटरों के प्रभावों को देखने में मदद करेगी। (संख्याओं को द्विआधारी अंकन में सहायता के लिए व्यक्त किया गया है।)

बिट हेरफेर में शिफ्ट ऑपरेटरों के उपयोगकर्ता के उदाहरण हैं

लैंबडा ऑपरेटर (->)

जावा 8 के बाद से, लैम्ब्डा ऑपरेटर ( -> ) लैम्बडा एक्सप्रेशन को पेश करने के लिए उपयोग किया जाने वाला ऑपरेटर है। इन उदाहरणों के अनुसार दो सामान्य वाक्यविन्यास हैं:

  a -> a + 1              // a lambda that adds one to its argument
  a -> { return a + 1; }  // an equivalent lambda using a block.

एक लंबोदर अभिव्यक्ति एक अनाम फ़ंक्शन को परिभाषित करती है, या एक सही ढंग से एक अनाम वर्ग का एक उदाहरण है जो एक कार्यात्मक इंटरफ़ेस को लागू करता है ।

(यह उदाहरण पूर्णता के लिए यहां शामिल है। पूर्ण उपचार के लिए लैम्ब्डा एक्सप्रेशंस विषय का संदर्भ लें।)

संबंधित ऑपरेटर (<, <=>,> =)

संख्यात्मक प्रकार की तुलना के लिए ऑपरेटर < , <= , > और >= द्विआधारी ऑपरेटर हैं। आपरेटरों का अर्थ वैसा ही है जैसा आप अपेक्षा करेंगे। उदाहरण के लिए, यदि a और b को byte , short , char , int , long , float , double या संबंधित बॉक्स प्रकारों में से किसी एक के रूप में घोषित किया जाता है:

- `a < b` tests if the value of `a` is less than the value of `b`. 
- `a <= b` tests if the value of `a` is less than or equal to the value of `b`. 
- `a > b` tests if the value of `a` is greater than the value of `b`. 
- `a >= b` tests if the value of `a` is greater than or equal to the value of `b`. 

इन ऑपरेटरों के लिए परिणाम प्रकार सभी मामलों में boolean है।

विभिन्न प्रकार के साथ संख्याओं की तुलना करने के लिए रिलेशनल ऑपरेटर्स का उपयोग किया जा सकता है। उदाहरण के लिए:

int i = 1;
long l = 2;
if (i < l) {
    System.out.println("i is smaller");
}

संबंधपरक ऑपरेटरों का उपयोग तब किया जा सकता है जब या तो दोनों संख्याएं बॉक्सिंग संख्यात्मक प्रकार के उदाहरण हैं। उदाहरण के लिए:

Integer i = 1;   // 1 is autoboxed to an Integer
Integer j = 2;   // 2 is autoboxed to an Integer
if (i < j) {
    System.out.println("i is smaller");
}

सटीक व्यवहार संक्षेप में इस प्रकार है:

1. यदि ऑपरेंड में से एक बॉक्सिंग प्रकार है, तो यह अनबॉक्स है।
2. यदि दोनों में से कोई भी एक byte , short या char , अब प्रमोट किया जाता है, तो उसे int में प्रमोट कर दिया जाता है।
3. यदि ऑपरेंड के प्रकार समान नहीं हैं, तो "छोटे" प्रकार वाले ऑपरेंड को "बड़े" प्रकार में बढ़ावा दिया जाता है।
4. तुलना परिणामी int , long , float या double values पर की जाती है।

आपको रिलेशनल तुलनाओं से सावधान रहने की जरूरत है जिसमें फ्लोटिंग पॉइंट नंबर शामिल हैं:

• फ़्लोटिंग पॉइंट नंबरों की गणना करने वाली अभिव्यक्तियाँ अक्सर इस तथ्य के कारण राउंडिंग त्रुटियों को जन्म देती हैं कि कंप्यूटर फ़्लोटिंग पॉइंट अभ्यावेदन सीमित परिशुद्धता है।
• जब एक पूर्णांक प्रकार और एक फ्लोटिंग पॉइंट प्रकार की तुलना करते हैं, तो पूर्णांक के फ़्लोटिंग पॉइंट में रूपांतरण भी गोलाई त्रुटियों को जन्म दे सकता है।

अंत में, जावा ऊपर सूचीबद्ध लोगों के अलावा किसी भी प्रकार के साथ संबंधपरक ऑपरेटरों के उपयोग का समर्थन नहीं करता है। उदाहरण के लिए, आप इन ऑपरेटरों का उपयोग स्ट्रिंग्स, संख्याओं के सरणियों और इसी तरह की तुलना करने के लिए नहीं कर सकते हैं ।