म्यूटेबल न्यूमेरिक ऑब्जेक्ट्स

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

कल्पना करें कि आपको कहीं से आने वाली विभिन्न लाइनों की संख्या की गणना करने की आवश्यकता है। अक्सर इस तरह का कोड लिखा जाता है:

public Map<String, Integer> countStrings() { Map<String, Integer> counts = new HashMap<String, Integer>(); while(true) { String next = getNextString(); if(next == null) break; Integer val = counts.get(next); if(val == null) counts.put(next, 1); else counts.put(next, val+1); } return counts; } 

यदि बहुत सारी प्रकार की लाइनें नहीं हैं, लेकिन पर्याप्त पुनरावृत्तियां हैं, तो बॉक्सिंग से लाखों अस्थायी इंटेगर ऑब्जेक्ट बनेंगे, जो कचरा कलेक्टर फिर साफ करेगा। यह कल्पना करना डरावना है। नहीं, यह भयावह रूप से धीमा नहीं है, लेकिन फिर भी 2-3 बार प्रक्रिया को गति देना मुश्किल नहीं है। इसके लिए हम MutableInteger का उपयोग करते हैं।

ऐसी कक्षा कुछ पुस्तकालयों में मौजूद है (उदाहरण के लिए, org.apache.commons.lang में ), लेकिन इसे स्वयं लिखना मुश्किल नहीं है। एक साधारण कार्यान्वयन कुछ इस तरह दिख सकता है:

 public class MutableInteger { private int value; public MutableInteger(int value) { this.value = value; } public int intValue() { return value; } public void set(int value) { this.value = value; } public void increment() { value++; } public String toString() { return String.valueOf(value); } } 

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

 public Map<String, MutableInteger> countStrings() { Map<String, MutableInteger> counts = new HashMap<String, MutableInteger>(); while(true) { String next = getNextString(); if(next == null) break; MutableInteger val = counts.get(next); if(val == null) counts.put(next, new MutableInteger(1)); else val.increment(); } return counts; } 

यह निश्चित रूप से अच्छा नहीं है, नक्शा <स्ट्रींग, म्यूटेबलइंटरर> को वापस करके कार्यान्वयन विवरण का खुलासा करने के लिए, लेकिन अगर हमें java.lang.Number विरासत में मिला है, तो हम मैप <स्ट्रिंग, नंबर> वापस कर सकते हैं। ठीक है, या अंतिम उपाय के रूप में, गिनती के बाद, सब कुछ एक नए मानचित्र में कॉपी करें। इसी तरह, आप न केवल मात्रा, बल्कि वस्तुओं के एक सेट पर अन्य आंकड़े भी एकत्र कर सकते हैं।

हम यह भी ध्यान दें कि java.util.concurrent.atomic.AtomicInteger भी अनिवार्य रूप से एक MutableInteger है, हालाँकि, एटमॉसिटी का ओवरहेड पहले उदाहरण से वस्तुओं और कचरा संग्रह बनाने की लागत को भी पार कर सकता है, इसलिए एक अलग वर्ग MutableInteger की अभी भी आवश्यकता है।