क्या (a == 1 && a == 2 && a == 3) जावा में सही का मूल्यांकन कर सकता है?

Question

हम जानते हैं कि यह जावास्क्रिप्ट में हो सकता है ।

लेकिन क्या जावा में नीचे दी गई स्थिति पर "सफलता" संदेश मुद्रित करना संभव है?

if (a==1 && a==2 && a==3) {
    System.out.println("Success");
}

किसी ने सुझाव दिया:

int _a = 1;
int a  = 2;
int a_ = 3;
if (_a == 1 && a == 2 && a_ == 3) {
    System.out.println("Success");
}

लेकिन ऐसा करने से हम वास्तविक परिवर्तनशील परिवर्तन कर रहे हैं। क्या कोई और तरीका है?

Comments

&&तार्किक andऑपरेटर है, जिसका अर्थ है कि aएक ही समय में 1, 2 और 3 का मान होना चाहिए जो तार्किक रूप से असंभव है। जवाब नहीं है, संभव नहीं है। क्या आप एक ifबयान लिखना चाहते हैं जो यह जांचता है कि क्या aमान 1, 2 या 3 में से एक है?

— बोरिस पावलोवीक

सभी के लिए ध्यान दें: यह प्रश्न जावास्क्रिप्ट के लिए एक ही प्रश्न से आ सकता है: stackoverflow.com/questions/48270127/… , जिस स्थिति में उत्तर हैyes

— nos

@ArthurAttout डुप्लिकेट नहीं, यह प्रश्न जावास्क्रिप्ट के लिए है, जावा के लिए नहीं।

— ओपन स्कूल

चर नामों में व्हाट्सएप का उपयोग करने वाला भी जावा में काम करता है। लेकिन निश्चित रूप से यह मूल रूप से उपयोग करने के समान है _, सिवाय इसके कि आप इसे नहीं देख सकते।

— तोबियस_क

@Seelenvirtuose सच है, लेकिन if(a==1 && a==2 && a==3)एक ही समय में आवश्यक रूप से मूल्यांकन नहीं किया जाता है। और इसका उपयोग यूनिकोड ट्रिक्स का सहारा लिए बिना इस काम को करने के लिए किया जा सकता है।

— इरविन बोलविएट

Answer 1

हां, इसे कई थ्रेड्स के साथ हासिल करना काफी आसान है, अगर आप वैरिएबल aको अस्थिर घोषित करते हैं ।

एक धागा लगातार परिवर्तनशील को 1 से 3 तक बदलता है, और दूसरा धागा लगातार परीक्षण करता है a == 1 && a == 2 && a == 3। कंसोल पर मुद्रित "सफलता" की एक सतत धारा होने के लिए अक्सर यह पर्याप्त होता है।

(ध्यान दें कि यदि आप एक else {System.out.println("Failure");}खंड जोड़ते हैं , तो आप देखेंगे कि परीक्षण सफल होने की तुलना में कहीं अधिक बार विफल होता है।

व्यवहार में, यह भी aअस्थिर घोषित किए बिना काम करता है , लेकिन मेरे मैकबुक पर केवल 21 बार। बिना volatile, कंपाइलर या हॉटस्पॉट को स्टेटमेंट को कैश aया बदलने की अनुमति है । सबसे अधिक संभावना है, हॉटस्पॉट थोड़ी देर के बाद किक करता है और इसे विधानसभा के निर्देशों के अनुसार संकलित करता है जो कि मूल्य को कैश करते हैं । इसके साथ , यह "सफलता" को हमेशा के लिए छापता रहता है।ifif (false)a volatile

public class VolatileRace {
    private volatile int a;

    public void start() {
        new Thread(this::test).start();
        new Thread(this::change).start();
    }

    public void test() {
        while (true) {
            if (a == 1 && a == 2 && a == 3) {
                System.out.println("Success");
            }
        }
    }

    public void change() {
        while (true) {
            for (int i = 1; i < 4; i++) {
                a = i;
            }
        }
    }

    public static void main(String[] args) {
        new VolatileRace().start();
    }
}

Comments

यह एक शानदार उदाहरण है! मुझे लगता है कि मैं इसे अगली बार चुरा लूंगा जब मैं एक जूनियर देव के साथ संभावित खतरनाक समसामयिक मुद्दों पर चर्चा कर रहा हूं :)

— एलेक्स प्रू

इसके बिना बहुत संभावना नहीं है volatile, लेकिन सिद्धांत रूप में, यह volatileकीवर्ड के बिना भी हो सकता है और यह कई बार मनमाने ढंग से हो सकता है, जबकि, हाथ पर, इस बात की कोई गारंटी नहीं है कि यह कभी भी होगा, यहां तक ​​कि इसके साथ भी volatile। लेकिन निश्चित रूप से, यह व्यवहार में हो रहा है, चुप प्रभावशाली है ...

— होल्गर

@AlexPruss मैंने सभी देवों पर किया, मेरी कंपनी में सिर्फ जूनियर्स नहीं (मुझे पता था कि यह संभव हो सकता है), उत्तर में विफलताओं की 87% सफलता

— यूजीन

@ होल्गर सच, दोनों की कोई गारंटी नहीं। एक विशिष्ट कई-पूर्ण-कोर या बहु-सीपीयू वास्तुकला पर, जहां दोनों धागे एक अलग कोर को सौंपा जाता है, यह काफी संभावना है कि यह साथ होगा volatile। volatileथ्रेड को धीमा करने और इसे कम समय के लिए इन-सिंक संचालित करने की संभावना को कम करने के लिए बनाए गए मेमोरी बैरियर । यह मेरी अपेक्षा से कहीं अधिक बार होता है। यह बहुत ही समय के प्रति संवेदनशील है, लेकिन मैं मोटे तौर पर 0.2% और 0.8% (a == 1 && a == 2 && a == 3)रिटर्न के मूल्यांकन के बीच देखता हूं true।

— इरविन बोलाविद्ट

यह एकमात्र उत्तर है जो वास्तव में केवल एक के छोटे बदलाव करने के बजाय असली कोड को वापस करने के लिए बनाता है। +1

— एलेजांद्रो

Answer 2

एक से अवधारणाओं (और कोड) का उपयोग करते हुए शानदार कोड गोल्फ जवाब , Integerमूल्यों के साथ गड़बड़ जा सकता है।

इस मामले में, यह intएस को Integerएस के बराबर होने के लिए डाला जा सकता है जब वे सामान्य रूप से नहीं होंगे:

import java.lang.reflect.Field;

public class Test
{
    public static void main(String[] args) throws Exception
    {
        Class cache = Integer.class.getDeclaredClasses()[0];
        Field c = cache.getDeclaredField("cache");
        c.setAccessible(true);
        Integer[] array = (Integer[]) c.get(cache);
        // array[129] is 1
        array[130] = array[129]; // Set 2 to be 1
        array[131] = array[129]; // Set 3 to be 1

        Integer a = 1;
        if(a == (Integer)1 && a == (Integer)2 && a == (Integer)3)
            System.out.println("Success");
    }
}

दुर्भाग्य से यह इरविन बोल्विदट के बहु-उत्तर वाले उत्तर के रूप में सुरुचिपूर्ण नहीं है (क्योंकि इसमें Integerकास्टिंग की आवश्यकता होती है ) , लेकिन फिर भी कुछ मजेदार शेंनिगन्स लगते हैं ।

Comments

बहुत ही रोचक। मैं गाली देते हुए मर रहा था Integer। यह कास्टिंग के बारे में शर्म की बात है लेकिन यह अभी भी शांत है।

— माइकल

@ मिचेल मैं काफी समझ नहीं पाया कि कास्टिंग से कैसे छुटकारा पाया जाए। a१/२/३ पर सेट होने से संतोष होगा a == 1, लेकिन यह दूसरे तरीके से नहीं

— चलता

इस सवाल का जवाब मैंने कुछ दिन पहले JS / Ruby / Python और में दिया था Java। सबसे कम बदसूरत संस्करण मैं पा सकता था a.equals(1) && a.equals(2) && a.equals(3), जिसका उपयोग करना था , जो बलों 1, 2और 3एस के रूप में ऑटोबॉक्स किया जाना था Integer।

— एरिक डुमिनील

@ EricDuminil कुछ मज़ेदार हो सकता है, क्योंकि अगर आपने aक्लास बनाई हो तो क्या होगा boolean equals(int i){return true;}?

— फाफैक

जैसा कि मैंने कहा, यह सबसे कम बदसूरत है, लेकिन यह अभी भी इष्टतम नहीं है। Integer a = 1;पहले की लाइन के साथ , यह अभी भी स्पष्ट है कि aवास्तव में एक इंटेगर है।

— एरिक डुमिनील

Answer 3

में इस सवाल का @aioobe पता चलता है (और के खिलाफ सलाह) जावा वर्गों के लिए सी पूर्वप्रक्रमक का उपयोग।

हालांकि यह बहुत ही धोखा है, यह मेरा समाधान है:

#define a evil++

public class Main {
    public static void main(String[] args) {
        int evil = 1;
        if (a==1 && a==2 && a==3)
            System.out.println("Success");
    }
}

यदि निम्न आदेशों का उपयोग करके निष्पादित किया जाता है तो यह बिल्कुल एक आउटपुट होगा Success:

cpp -P src/Main.java Main.java && javac Main.java && java Main

Comments

इस तरह के महसूस एक कोड के माध्यम से चलाने की तरह लगता है और वास्तव में इसे संकलित करने से पहले प्रतिस्थापित करता है, लेकिन मैं निश्चित रूप से किसी को अपने वर्कफ़्लो के हिस्से के रूप में कुछ ऐसा करते हुए देख सकता हूं

— phflack

@ एफफ्लैक मुझे पसंद है, यकीनन यह सवाल कोड पढ़ते समय धारणा बनाने के खतरों को दिखाने के बारे में है। यह मान aलेना आसान है कि यह एक परिवर्तनशील है, लेकिन यह एक प्रीप्रोसेसर वाली भाषाओं में कोड का कोई भी मनमाना टुकड़ा हो सकता है।

— केविन

यह जावा नहीं है। यह भाषा है "C प्रीप्रोसेसर के बाद जावा"। इसी प्रकार के द्वारा प्रयोग किया जाता बचाव इस सवाल का जवाब। : (ध्यान दें चालाकीपूर्ण है विषय से हटकर कोड गोल्फ के लिए अब)

— user202729

Answer 4

हम पहले से ही जानते हैं कि यह संभव है इस कोड को बनाने के लिए के महान उत्तर देने के लिए सच धन्यवाद करने के लिए मूल्यांकन इरविन Bolwidt और phflack , मुझे लगता है कि एक जैसी लगती है प्रस्तुत पता चलता है कि आप ध्यान का एक उच्च स्तरीय रखने के लिए जब एक शर्त के साथ काम की जरूरत है चाहता था प्रश्न में, जैसा कि कभी-कभी आप देखते हैं कि जैसा आप सोचते हैं वैसा वह नहीं हो सकता है।

यह दिखाने की मेरी कोशिश है कि यह कोड Success!कंसोल को प्रिंट करता है। मुझे पता है कि मैंने थोड़ा धोखा दिया , लेकिन मुझे अभी भी लगता है कि इसे यहां प्रस्तुत करने के लिए यह एक अच्छी जगह है।

कोई फर्क नहीं पड़ता कि इस तरह कोड लिखने के उद्देश्य क्या हैं - यह जानने के लिए बेहतर है कि निम्नलिखित स्थिति से कैसे निपटें और कैसे जांचें कि क्या आप गलत नहीं हैं जो आप सोचते हैं कि आप देखते हैं।

मैंने सिरिलिक 'ए' का इस्तेमाल किया, जो लैटिन 'ए' का एक अलग चरित्र है। आप यहाँ दिए गए कथन में उपयोग किए गए वर्णों का निरीक्षण कर सकते हैं ।

यह काम करता है क्योंकि चर के नाम अलग-अलग वर्णमाला से लिए गए हैं। वे अलग-अलग पहचानकर्ता हैं, प्रत्येक में एक अलग मूल्य के साथ दो अलग-अलग चर बनाए जाते हैं।

ध्यान दें कि यदि आप चाहते हैं कि यह कोड ठीक से काम करे, तो वर्ण एन्कोडिंग को दोनों वर्णों का समर्थन करने वाले एक में बदलना होगा, जैसे सभी यूनिकोड एनकोडिंग (UTF-8, UTF-16 (BE या LE में), UTF-32, यहां तक ​​कि UTF-7 ), या Windows-1251, ISO 8859-5, KOI8-R (धन्यवाद - थॉमस वेलर और पाओलो एबरमन - इसे इंगित करने के लिए):

public class A {
    public static void main(String[] args) {
        int а = 0;
        int a = 1;
        if(а == 0 && a == 1) {
            System.out.println("Success!");
        }
    }
}

(मुझे आशा है कि आपको भविष्य में कभी भी इस तरह की समस्या से नहीं जूझना पड़ेगा।)

Comments

@ मिचेल आपको क्या मतलब है यह अच्छी तरह से नहीं दिखाता है? मैंने इसे मोबाइल फोन पर लिखा है और यहां यह मेरे लिए ठीक है, यहां तक ​​कि डेस्कटॉप दृश्य पर स्विच करते समय भी। अगर यह मेरे जवाब को बेहतर बना देता है तो कृपया इसे संपादित करने के लिए स्वतंत्र महसूस करें क्योंकि मैं इसे थोड़ा कठिन समझता हूं।

— प्रेज़ेमिसलाव मोस्कल

@ मिचेल आपका बहुत बहुत धन्यवाद। मैंने सोचा कि मैंने अपने उत्तर के अंत में जो कुछ भी स्वीकार किया है वह पर्याप्त है :)

— Przemysław Moskal

@mohsenmadi हाँ, मैं इसे यहाँ मोबाइल फ़ोन पर नहीं देख सकता, लेकिन मुझे पूरा यकीन है कि संपादित करने से पहले, अंतिम वाक्य मेरे उदाहरण में विभिन्न भाषाओं का उपयोग करने के बारे में था: P

— Przemysław Moskal

? == 0 किसी == 1 के समान क्यों होना चाहिए?

— थॉमस वेलर

अधिक नाइटपैकिंग: आपको आवश्यक रूप से UTF-8 की आवश्यकता नहीं है (हालांकि यह वैसे भी अनुशंसित है), कोई भी वर्ण एन्कोडिंग जिसमें दोनों हैं аऔर aकाम करते हैं, जब तक आप अपने संपादक को बताते हैं कि यह (और संभवतः संकलक, भी) में क्या एन्कोडिंग है। सभी यूनिकोड एनकोडिंग कार्य (UTF-8, UTF-16 (BE या LE में), UTF-32, यहां तक ​​कि UTF-7), साथ ही उदाहरण के लिए Windows-1251, ISO 8859-5, KOI8-R।

— पाओलो एबरमन

Answer 5

पॉवरमॉक की शक्ति का उपयोग करते हुए इसे एप्रोच करने का एक और तरीका है (अतिरिक्त अस्थिर डेटा-रेसिंग दृष्टिकोण जो मैंने पहले पोस्ट किया था)। पावरमॉक अन्य कार्यान्वयन के साथ तरीकों को बदलने की अनुमति देता है। जब इसे ऑटो-अनबॉक्सिंग के साथ जोड़ा जाता है, तो मूल अभिव्यक्ति(a == 1 && a == 2 && a == 3) , बिना संशोधन के सच हो सकती है।

@ phflack का उत्तर जावा में ऑटो-बॉक्सिंग प्रक्रिया को संशोधित करने पर निर्भर करता है जो Integer.valueOf(...)कॉल का उपयोग करता है । नीचे का दृष्टिकोण Integer.intValue()कॉल को बदलकर ऑटो-अनबॉक्सिंग को संशोधित करने पर निर्भर करता है ।

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

import static org.powermock.api.support.membermodification.MemberMatcher.method;
import static org.powermock.api.support.membermodification.MemberModifier.replace;

import java.util.concurrent.atomic.AtomicInteger;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@PrepareForTest(Integer.class)
@RunWith(PowerMockRunner.class)
public class Ais123 {
    @Before
    public void before() {
        // "value" is just a place to store an incrementing integer
        AtomicInteger value = new AtomicInteger(1);
        replace(method(Integer.class, "intValue"))
            .with((proxy, method, args) -> value.getAndIncrement());
    }

    @Test
    public void test() {
        Integer a = 1;

        if (a == 1 && a == 2 && a == 3) {
            System.out.println("Success");
        } else {
            Assert.fail("(a == 1 && a == 2 && a == 3) != true, a = " + a.intValue());
        }
    }

}

Comments

क्या पावरमॉक आंतरिक / बाहरी कक्षाओं के क्षेत्रों access$nnnको पढ़ने के लिए उपयोग किए जाने वाले तरीकों की तरह सिंथेटिक तरीकों को बदल सकता है private? यह कुछ अन्य दिलचस्प वेरिएंट की अनुमति देगा (जो कि एक intचर के साथ भी काम करता है) ...

— होल्गर

@ होलगर दिलचस्प विचार, मैं देख रहा हूं कि आपका क्या मतलब है। यह अभी तक काम नहीं कर रहा है - स्पष्ट नहीं है कि यह काम करने से क्या रोक रहा है।

— एरविन बोलाविद्ट

वास्तव में अच्छा है, यह वही है जो मैं करने की कोशिश कर रहा था, लेकिन मैंने पाया कि अपरिवर्तनीय वर्ग से स्थैतिक पद्धति को बदलना बायोटकोड में हेरफेर के बिना काफी मुश्किल होगा। लगता है कि मैं गलत था, पावरमॉक के बारे में कभी नहीं सुना था, मुझे आश्चर्य है कि यह कैसे करता है। एक साइड नोट के रूप में, फ़्लेफ़ैक का उत्तर ऑटोबॉक्सिंग पर निर्भर नहीं करता है: वह कैश्ड इंटेगर के एड्रेसेस को बदल देता है (इसलिए == वास्तव में इंटगर ऑब्जेक्ट एड्रैस की तुलना मूल्यों के बजाय कर रहे हैं)।

— असब

@As कास्टिंग ( (Integer)2) int बॉक्स। प्रतिबिंब में अधिक देखने पर ऐसा लगता है कि प्रतिबिंब का उपयोग करते हुए इसे अनबॉक्सिंग के साथ करना संभव नहीं है, लेकिन इसके बजाय इंस्ट्रूमेंटेशन के साथ संभव हो सकता है (या पावरमॉक के साथ, इस उत्तर में)

— फाफलैक

@ होलजर यह संभवतः सिंथेटिक विधि को बाधित नहीं करता है, हालांकि यह मुझे प्रतिस्थापन को पंजीकृत करने की अनुमति देता है और पंजीकरण में access$0एक विधि के अस्तित्व की जांच की जाती है। लेकिन प्रतिस्थापन कभी नहीं किया जाता है।

— एरविन बोलाविद्ट

Answer 6

चूंकि यह इस जावास्क्रिप्ट प्रश्न का अनुवर्ती प्रतीत होता है , इसलिए यह ध्यान देने योग्य है कि यह चाल और जावा में भी इसी तरह काम करता है:

public class Q48383521 {
    public static void main(String[] args) {
        int aﾠ = 1;
        int ﾠ2 = 3;
        int a = 3;
        if(aﾠ==1 && a==ﾠ2 && a==3) {
            System.out.println("success");
        }
    }
}

Ideone पर

---

लेकिन ध्यान दें कि यह सबसे बुरी चीज नहीं है जिसे आप यूनिकोड के साथ कर सकते हैं। श्वेत-स्थान या नियंत्रण वर्णों का उपयोग करना जो वैध पहचानकर्ता भाग हैं या समान दिखने वाले विभिन्न अक्षरों का उपयोग करते हैं भी पहचानकर्ता बनाते हैं जो अलग-अलग होते हैं और उन्हें देखा जा सकता है, जैसे पाठ खोज करते समय।

लेकिन यह कार्यक्रम

public class Q48383521 {
    public static void main(String[] args) {
        int ä = 1;
        int ä = 2;
        if(ä == 1 && ä == 2) {
            System.out.println("success");
        }
    }
}

दो पहचानकर्ताओं का उपयोग करता है जो समान हैं, कम से कम यूनिकोड बिंदु से। वे सिर्फ एक ही चरित्र äका उपयोग करने के लिए अलग-अलग तरीकों का उपयोग करते हैं, U+00E4औरU+0061 U+0308 ।

Ideone पर

इसलिए आपके द्वारा उपयोग किए जा रहे उपकरण के आधार पर, वे न केवल समान दिख सकते हैं, यूनिकोड सक्षम पाठ उपकरण भी किसी भी अंतर की सूचना नहीं दे सकते हैं, हमेशा खोजते समय दोनों को खोजते हैं। आपके पास यह समस्या भी हो सकती है कि स्रोत कोड को किसी और को कॉपी करते समय विभिन्न अभ्यावेदन खो जाते हैं, शायद "अजीब व्यवहार" के लिए सहायता प्राप्त करने की कोशिश कर रहा है, जिससे यह सहायक के लिए गैर-प्रतिलिपि बनाने योग्य हो जाता है।

Comments

एह, यह उत्तर यूनिकोड दुरुपयोग को अच्छी तरह से कवर नहीं करता है?

— माइकल

int ﾠ2 = 3;क्या यह जानबूझकर है? क्योंकि, मैं बहुत अजीब कोड चारों ओर देख रहा हूँ

— रवि

@Michael बिल्कुल नहीं, क्योंकि यह उत्तर दो अलग-अलग अक्षरों का उपयोग करने के बारे में है (जिसकी खोज करते समय IDEs अलग-अलग विचार करेंगे a), जबकि यह सफेद-स्थान के बारे में है, और अच्छी तरह से, यह संबंधित जावास्क्रिप्ट प्रश्न पर भी पुराने उत्तर का श्रेय दे रहा है। ध्यान दें कि मेरी टिप्पणी जावा सवाल (कई दिनों तक) से भी पुरानी है ...

— होल्गर

मैं भेद नहीं देखता। दोनों उत्तर एक समाधान प्रदान कर रहे हैं, जहां तीन कथन पहचानकर्ता समान रूप से समान हैं, लेकिन असामान्य यूनिकोड वर्णों का उपयोग करके तकनीकी रूप से अलग हैं। चाहे वह व्हाट्सएप हो या सिरिलिक अप्रासंगिक।

— माइकल

@ माइकल आप इसे इस तरह देख सकते हैं, यह आपके ऊपर है। जैसा कि कहा गया है, मैं यह बताना चाहता था कि जावास्क्रिप्ट के लिए पाँच दिन पहले दिया गया उत्तर भी जावा पर लागू होता है, बस प्रश्न के इतिहास पर विचार करता है। हां, यह कुछ हद तक एक और उत्तर के लिए बेमानी है जो लिंक किए गए जावास्क्रिप्ट प्रश्न का संदर्भ नहीं देता है। वैसे भी, इस बीच मैंने अपने जवाब को एक ऐसे मामले को जोड़ने के लिए अद्यतन किया, जो नेत्रहीन समान वर्णों के बारे में नहीं है, लेकिन एक ही चरित्र को सांकेतिक शब्दों में बदलना और यह एक "असामान्य यूनिकोड चरित्र" भी नहीं है; यह एक ऐसा चरित्र है जिसका मैं हर दिन उपयोग कर रहा हूं ...

— होल्जर

Answer 7

@ इरविन के उत्कृष्ट उत्तर से प्रेरित होकर , मैंने एक ऐसा ही उदाहरण लिखा, लेकिन जावा स्ट्रीम एपीआई का उपयोग करके ।

और एक दिलचस्प बात यह है कि मेरा समाधान काम करता है, लेकिन बहुत दुर्लभ मामलों में (क्योंकि   just-in-timeकंपाइलर इस तरह के कोड का अनुकूलन करता है)।

JITनिम्नलिखित VMविकल्प का उपयोग करके चाल को किसी भी अनुकूलन को निष्क्रिय करना है :

-Djava.compiler=NONE

इस स्थिति में, सफलता के मामलों की संख्या में काफी वृद्धि होती है। यहाँ कोड है:

class Race {
    private static int a;

    public static void main(String[] args) {
        IntStream.range(0, 100_000).parallel().forEach(i -> {
            a = 1;
            a = 2;
            a = 3;
            testValue();
        });
    }

    private static void testValue() {
        if (a == 1 && a == 2 && a == 3) {
            System.out.println("Success");
        }
    }
}

पुनश्च समानांतर धाराओं का उपयोग ForkJoinPoolहुड के नीचे, और चर एक से अधिक थ्रेड के बीच किसी भी तुल्यकालन के बिना साझा किया जाता है, तो इस कारण परिणाम गैर नियतात्मक है।

Answer 8

समान लाइनों के साथ , एक बड़ी संख्या द्वारा विभाजन (या गुणन) के माध्यम से फ्लोट (या डबल) को अंडरफ्लो (या अतिप्रवाह) के लिए मजबूर करके:

int a = 1;
if (a / Float.POSITIVE_INFINITY == 1 / Float.POSITIVE_INFINITY
        && a / Float.POSITIVE_INFINITY == 2 / Float.POSITIVE_INFINITY
        && a / Float.POSITIVE_INFINITY == 3 / Float.POSITIVE_INFINITY) {
    System.out.println("Success");
}

Comments

@PatrickRoberts - यह विशिष्ट व्यवहार जावा डॉक्स के अनुसार फ्लोटिंग पॉइंट अंडरफ्लो है । यह भी देखें इस , यह , यह और यह ।

— अलोके