क्या Java में Integer, Float, Double, Long के लिए परस्पर प्रकार हैं?

Question

मैं ऐसी स्थिति में हूं जहां मैं इंटीजर जैसी चीजों के परस्पर संस्करणों का उपयोग करना चाहता हूं। क्या मुझे इन वर्गों (नीचे) का उपयोग करना होगा या जावा में कुछ बनाया है?

http://www.java2s.com/Code/Java/Data-Type/Amutableintwrapper.htm

Comments

सवाल यह है कि आप ऐसा क्यों करना चाहते हैं?

— हेल्परमथोड

कुछ मामलों के लिए (उदाहरण के लिए! एक खेल, nकैलोरी ले जाने वाले भोजन के एक टुकड़े को संग्रहीत करना , जिसे कम किया जा सकता है / जोड़ा जा सकता है), उपयोग के नाम पर एक वर्ग का उपयोग करना बेहतर हो सकता है, (उदाहरण के लिए class FoodItem { int calories; }, क्योंकि यह स्पष्ट है और विधियाँ हैं। अगर बाद में जरूरत हो तो जोड़ा जाए।

— GKFX

जावा 8 लैम्ब्डा केवल प्रभावी रूप से अंतिम चर के साथ काम करते हैं। इस सीमा के आसपास काम करने के लिए एक परस्पर अंतर की आवश्यकता होती है।

— एलेक्स

आप एक काउंटर चाहते हैं जिसे विधियों के बीच पारित करने की आवश्यकता हो। पासिंग एक intकाम नहीं करता है जैसे कि अगर यह एक विधि में बढ़ा हुआ है तो मूल्य दूसरी विधि में परिलक्षित नहीं होगा।

— एडम बुर्ले

Answer 1

नहीं, जावा में ये बिल्ट इन नहीं हैं। और यह एक कारण के लिए है। उत्परिवर्तनीय प्रकारों का उपयोग करना खतरनाक है, क्योंकि वे आसानी से दुरुपयोग कर सकते हैं। इसके अतिरिक्त, इसे लागू करना वास्तव में आसान है। उदाहरण के लिए, कॉमन्स-लैंग में ए MutableInt।

Comments

मेरा अनुमान है कि java dev का वांटेड इंटेगर एक इंट की तरह 'व्यवहार' करता है, जो कि..इसके लिए आपके पास एक संदर्भ है, यह कभी नहीं बदलता (भ्रम से बचें)। लेकिन..यह अभी भी किसी भी तरह से एक परस्पर विकल्प नहीं है, मुझे अजीब लगता है ...

— rogerdpack

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

— जीकेएफएक्स

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

— व्लासेक

निश्चित रूप से एक पुराना सवाल है, लेकिन उम्मीद है कि कोई व्यक्ति कैसे उत्तर दे सकता है कि उनका दुरुपयोग किया जा सकता है। उनका उपयोग करने के बारे में इतना खतरनाक क्या है?

— शराबी रोबोट

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

— ग्रेग

Answer 2

आप हमेशा एक सरणी में मान को लपेट सकते हैं जैसे int[] mutable = {1};कि एक उत्परिवर्ती आवरण वर्ग के लिए कोड बहुत बोझिल है।

Comments

स्मार्ट, पाप के रूप में बग बदसूरत।

— ग्वलासोव

यह सुपर चालाक है और लगभग कोई जगह नहीं लेता है। प्लस एटॉमिकआईंट के साथ किए गए सिचिंग से बचा जाता है।

— CompEng88

Answer 3

JDK के बाद से 1.5 जावा अब है java.util.concurrent.atomic.AtomicInteger

यह एक थ्रेड सेफ म्यूटेबल पूर्णांक है, उपयोग का उदाहरण:

final AtomicInteger value = new AtomicInteger(0);

फिर बाद में:

value.incrementAndGet();

Comments

यह थीड सेफ्टी एक प्रदर्शन लागत पर आती है, जिसकी कई मामलों में आवश्यकता नहीं होती है। उदाहरण के लिए, मेरे लिए एक सामान्य उपयोग मामला एक लंबो द्वारा पकड़े गए काउंटर को बढ़ाना है। एक परमाणु का उपयोग ओवरकिल है।

— मिनस मीना

Answer 4

यहाँ एक छोटा वर्ग है जिसे मैंने एक पूर्णांक पूर्णांक के लिए बनाया है:

public class MutableInteger {
    private int value;
    public MutableInteger(int value) {
        this.value = value;
    }
    public void set(int value) {
        this.value = value;
    }
    public int intValue() {
        return value;
    }
}

आप इसे आसानी से किसी अन्य आदिम तक बढ़ा सकते हैं। बेशक, जैसे हर कोई कह रहा है, आपको इसका उपयोग सावधानी से करना चाहिए।

Comments

IMHO सबसे अच्छा विकल्प है कि यह एक परमाणु अंतराल का उपयोग करने के रूप में संगामिति के बारे में गलत सुराग नहीं देता है। और एक सरणी, वास्तव में मैं अपने कोड में ऐसा बुरा काम कभी नहीं करूंगा ..;)

— स्निकोलस

बजाय एक ही सामान्य आवरण वर्ग प्रदान करने के लिए एक अच्छा विचार हो सकता है तो आप एक साथ न करना पड़े MutableInteger, MutableDouble, MutableStringआदि लेकिन इसके बजाय एक Mutable<Integer>, Mutable<Double>... (का उपयोग करने का स्मृति भूमि के ऊपर Integerसे अधिक intआम तौर पर खाते में गिर जाएगी। लेकिन आपको एक सिंगल मिलता है, क्लास का उपयोग करने के लिए तैयार, जो अधिकांश मामलों को संभाल सकता है (यदि आप चाहते हैं कि आपका पूर्णांक तुलनीय या इसी तरह की चीजें हैं जो आपको अभी भी उप-वर्ग की आवश्यकता हैं, हालांकि)।

— Qw3ry

यह संख्या बढ़ाने के लिए एक अच्छा विचार हो सकता है ।

— स्टिजेन डे विट

Answer 5

आप किसी भी आदिम प्रकार के लिए एक उत्परिवर्ती वस्तु के रूप में एक nnnn [] का उपयोग कर सकते हैं जैसा कि @Alexandre से पता चलता है, जावा में AtomicInteger और AtomicLong भी है।

आईएमएचओ इंट आम तौर पर इंटेगर की तुलना में बेहतर विकल्प है और यह परिवर्तनशील है।

क्या आप इस बात का अधिक विवरण दे सकते हैं कि आपको एक उत्परिवर्ती वस्तु की आवश्यकता क्यों है, शायद उसी चीज को प्राप्त करने का एक और तरीका है।

Comments

intहमेशा final

— म्यूटेबल है

यह कहना वास्तव में मान्य नहीं है कि एक आदिम प्रकार परस्पर है । इसे बदला जा सकता है लेकिन अगर आप किसी नई वस्तु की ओर इशारा करते हैं तो यह हर गैर-अंतिम वस्तु हो सकती है। उदाहरण के लिए Integer a = 4;तब a = 5;मान्य कोड है, लेकिन Integerपरस्पर नहीं है।

— mjaggard

मैं मानता हूं कि Integerउदाहरण परस्पर भिन्न नहीं हैं भले ही उनके संदर्भ हों, लेकिन यह एक अलग प्रकार है।

— पीटर लॉरी

यह एक संदर्भ int पैरामीटर के लिए एक अच्छा तरीका नहीं है? उदाहरण के लिए एक फ़ंक्शन जो आइटमों की एक सूची (डेटाबेस से) लौटाता है, लेकिन रिकॉर्ड की कुल संख्या भी। ऐसे मामले में, AtomicInteger या MutableInteger उपयोगी लगते हैं। निश्चित रूप से दूसरा तरीका यह होगा कि एक ही विधि में इसे वापस करने के बजाय एक getTotalRecords की संपत्ति हो।

— msanjay

intपरस्पर भिन्न नहीं है क्योंकि यदि आप इसे किसी विधि में पास करते हैं, तो विधि के लिए इसके मूल्य को बदलने का कोई तरीका नहीं है और कॉलिंग विधि में परिलक्षित नया मान है

— एडम बर्ले

Answer 6

AtomicIntegerपहले ही उल्लेख किया जा चुका है। Mutable Doubles का अनुकरण किया जा सकता है AtomicReference<Double>। पहले से उल्लिखित चेतावनी लागू होती है और यह खराब शैली है, लेकिन कभी-कभी आपके पास इस तरह का कोड होता है

double sum=0
for (Data data:someListGenerator())
  sum+=data.getValue()

और कार्यात्मक जावा 8 शैली में इसे फिर से बनाना चाहते हैं। यदि कोड इस पैटर्न का अनुसरण करता है, लेकिन इसमें काफी जटिलता जोड़ता है, तो सबसे समझदार रूपांतरण हो सकता है

AtomicReference<Double> sumref=new AtomicReference<>(0d);
someStreamGenerator().forEach(data->
  sumref.set(sumref.get().doubleValue()+data.getValue()));
double sum=sumref.get().doubleValue();

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

Comments

आपको वास्तव में अपने शब्दों के बारे में सोचना चाहिए: भले ही आप लंबोदा का उपयोग करते हैं, आपका उदाहरण कार्यात्मक नहीं है , क्योंकि यह दुष्प्रभाव पर प्रतिबंध लगाता है। क्या तुम सच में यह कार्यात्मक बारे में हैं, तो आप mutables की जरूरत नहीं है: someStreamGenerator().mapToDouble(Data::getValue).sum()। यहां तक ​​कि तीन अलग-अलग informations के संचयन के लिए, उपयोग करके एक कार्यात्मक तरीका हैStream.reduce याStream.collect । मुझे हर लूप को कार्यात्मक कोड के टुकड़े में रिफलेक्टर करने का कोई कारण नहीं दिखता है, लेकिन यदि आप इस तरह से जाना चाहते हैं, तो आपको इसे अंत तक जाना चाहिए।

— टोबियास लिफके

जैसा कि मैंने लिखा है: यह उचित शैली नहीं है और प्रत्येक और किसी भी नए कोड के लिए इसका उपयोग नहीं किया जाना चाहिए । लेकिन जब कोड का पुन: निर्माण 400.000+ लाइनों का होता है, जो 15+ वर्षों के भीतर विकसित होता है, तो आपको ऐसे निर्माण मिलते हैं, जहाँ वास्तव में कार्यात्मक निर्माणों में उचित पुनर्लेखन करना बेहद कठिन हो सकता है। फिर, इस तरह की हाइब्रिड-शैली में फिर से लिखना एक समझदार व्यापार-बंद हो सकता है क्योंकि आपको कम से कम बुनियादी संरचना मिलती है। forऔर foreachजटिल रूपरेखाओं के हिस्से हो सकते हैं जो कार्यात्मक रूप से फिर से लिखे जाते हैं, इसलिए आपको बाकी कोड को किसी तरह उनके चारों ओर संरेखित करना होगा।

— डिर्क हिलब्रैच

आप मेमने और कार्यात्मक प्रोग्रामिंग को भ्रमित कर रहे हैं। अपने उदाहरण में आपने इसे "कार्यात्मक" नहीं लिखा। और जब आप पठनीयता खो देते हैं, तो लंबोदर के साथ सब कुछ फिर से लिखने का क्या मतलब है, लेकिन कार्यात्मक प्रोग्रामिंग के फायदे नहीं मिलते हैं? किसी को भी इस तरह के संकर का उपयोग करके एक जटिल ढांचे में हर लूप से छुटकारा पाने की कोशिश क्यों करनी चाहिए?

— टोबियास लिफके

आपके पास अपने कोड में एक निश्चित मुहावरे के साथ 1000 स्थान हैं। मुहावरा एक पुस्तकालय या जो भी वैश्विक संरचना है, उससे प्रेरित है। आप कार्यात्मक दृष्टिकोण और लंबोदर के आधार पर उस वैश्विक संरचना को एक नए के साथ बदलते हैं। आपके 1000 स्थानों में से 998 को स्वच्छ रूप से कार्यात्मक शैली में परिवर्तित किया जा सकता है। शेष 2 को ठीक से परिवर्तित करना बेहद मुश्किल है। ऐसे मामलों में, मैं हमेशा इस तरह के संकर निर्माणों के साथ नई शैली में परिवर्तित करने के लिए जनादेश देता हूं। इसके बाद ही आप इस बात से छुटकारा पा सकते हैं कि कोड में जो भी पुरानी वैश्विक संरचनाएँ हैं। जबकि सही नहीं है, समग्र कोड गुणवत्ता बढ़ जाती है।

— डिर्क हिलब्रैच

Answer 7

आप org.omg.CORBA पैकेज (या बस आपको जिस वर्ग की आवश्यकता है) आयात कर सकते हैं और इसमें आप होल्डर कक्षाओं का उपयोग कर सकते हैं।

उदाहरण के लिए, इसमें "IntHolder" है जहां यह पूर्णांक को संग्रहीत करने वाला क्षेत्र सार्वजनिक है, इसे संशोधित करने के लिए पहुंच प्रदान करता है।

public static void triple(IntHolder x){
    x.value = 3 * x.value;
}

IntHolder mutableInt = new IntHolder(10);
triple(mutableInt);     
System.out.println(mutableInt.value);

इसमें "लॉन्गहॉल्डर" और "डबलहॉल्ड" और अन्य के टन भी हैं जिनका आप उपयोग कर सकते हैं। सावधानी से प्रयोग करें।

यहाँ इसके लिए एपीआई है: https://docs.oracle.com/javase/7/docs/api/org/omg/CORBA/package-summary.html

Comments

इस समस्या को ठीक करने के लिए बहुत ही स्मार्ट तरीका, Java9 के आने के साथ, आप शायद इसका उपयोग नहीं करना चाहते हैं - जो कि एक संपूर्ण धारक के लिए पूरे CORBA मॉड्यूल को आयात करेगा।

— अगोस्तान होर्वाथ