कैसे parseInt()अलग है valueOf()?
वे वास्तव में मेरे लिए एक ही बात करने के लिए दिखाई देते हैं (यह भी के लिए चला जाता है parseFloat(), parseDouble(), parseLong()आदि, कि वे किस तरह से अलग हैं Long.valueOf(string)?
इसके अलावा, इनमें से कौन सा अधिक बेहतर है और अधिवेशन द्वारा अधिक बार उपयोग किया जाता है?
जवाबों:
ठीक है, एपीआई के लिए Integer.valueOf(String)वास्तव में कहते हैं कि Stringयह व्याख्या की है जैसे कि इसे दिया गया था Integer.parseInt(String)। हालाँकि, valueOf(String)एक वस्तु लौटाता है जबकि एक आदिम देता है ।new Integer()parseInt(String)int
यदि आप संभावित कैशिंग के लाभों का आनंद लेना चाहते हैं Integer.valueOf(int), तो आप इस आंखों का उपयोग भी कर सकते हैं:
Integer k = Integer.valueOf(Integer.parseInt("123"))अब, यदि आप जो चाहते हैं वह वस्तु है और आदिम नहीं है, तो valueOf(String)नई वस्तु बनाने से अधिक आकर्षक हो सकता है parseInt(String)क्योंकि पूर्व में लगातार मौजूद है Integer, Longऔर Double, आदि।
Integer.valueOf(Integer.parseInt("123"))बर्बाद Integer.valueOf("123")या Integer.valueOf(123)चक्र से और अपने कार्यक्रम के आकार से अलग कोई लाभ नहीं है ।
Integer.valueOf(String)के रूप में बिल्कुल कैशिंग करता है Integer.valueOf(int)। वास्तव में, इसे Integer.valueOf(Integer.parseInt(…))…
int। हस्ताक्षर कहता है कि यह एक रिटर्न देता है Integer, और वह वास्तव में यही करता है। यह उत्तर भी आंशिक रूप से गलत है जब वह कहता है कि यह 'नया' है Integer। इसे जावदोक में नहीं कहते हैं। यह कैश्ड वापस करने के लिए स्वतंत्र है Integer।
से इस मंच :
parseInt()आदिम पूर्णांक प्रकार ( int )valueOfदेता है , जिससे java.lang.Integer रिटर्न होता है , जो पूर्णांक का ऑब्जेक्ट प्रतिनिधि है। ऐसी परिस्थितियाँ हैं जहाँ आप आदिम प्रकार के बजाय एक पूर्णांक वस्तु चाहते हैं।बेशक, एक और स्पष्ट अंतर यह है कि intValue एक उदाहरण विधि है जिससे parseInt एक स्थिर विधि है।
Integer.valueOf(s)के समान है
new Integer(Integer.parseInt(s))अंतर एक valueOf()रिटर्न है Integer, और parseInt()रिटर्न एक int(एक आदिम प्रकार)। यह भी ध्यान दें कि valueOf()कैश्ड Integerउदाहरण वापस कर सकते हैं , जिससे भ्रामक परिणाम हो सकते हैं जहां ==परीक्षणों का परिणाम रुक-रुक कर सही लगता है। ऑटोबॉक्सिंग से पहले सुविधा में अंतर हो सकता है, जावा 1.5 के बाद वास्तव में कोई फर्क नहीं पड़ता।
इसके अलावा, Integer.parseInt(s)आदिम डेटाटाइप भी ले सकते हैं।
जावा स्रोतों को देखें: valueOfउपयोग कर रहा है parseInt:
/**
* Parses the specified string as a signed decimal integer value.
*
* @param string
* the string representation of an integer value.
* @return an {@code Integer} instance containing the integer value
* represented by {@code string}.
* @throws NumberFormatException
* if {@code string} cannot be parsed as an integer value.
* @see #parseInt(String)
*/
public static Integer valueOf(String string) throws NumberFormatException {
return valueOf(parseInt(string));
}parseInt रिटर्न int
/**
* Parses the specified string as a signed decimal integer value. The ASCII
* character \u002d ('-') is recognized as the minus sign.
*
* @param string
* the string representation of an integer value.
* @return the primitive integer value represented by {@code string}.
* @throws NumberFormatException
* if {@code string} cannot be parsed as an integer value.
*/
public static int parseInt(String string) throws NumberFormatException {
return parseInt(string, 10);
}Integer.parseInt सिर्फ देशी प्रकार के रूप में int वापस कर सकते हैं।
Integer.valueOf को वास्तव में एक पूर्णांक वस्तु को आवंटित करने की आवश्यकता हो सकती है, जब तक कि पूर्णांक उपप्रमुखों में से एक न हो। इससे लागत अधिक आती है।
यदि आपको केवल मूल प्रकार की आवश्यकता है, तो parseInt का उपयोग करें। यदि आपको कोई ऑब्जेक्ट चाहिए, तो valueOf का उपयोग करें।
इसके अलावा, इस संभावित आवंटन के कारण, ऑटोबॉक्सिंग वास्तव में हर तरह से अच्छी बात नहीं है। यह चीजों को धीमा कर सकता है।
पार्स * विविधताएं आदिम प्रकारों को लौटाती हैं और मानों के संस्करण ऑब्जेक्ट लौटाते हैं। मेरा मानना है कि valueOf संस्करण किसी दिए गए मान के लिए SAME ऑब्जेक्ट को वापस करने के लिए एक आंतरिक संदर्भ पूल का भी उपयोग करेगा, न कि एक ही आंतरिक मूल्य के साथ एक और उदाहरण।
यदि आप Integer वर्ग की जाँच करते हैं, तो आपको वह मान कॉल कॉल parseInt विधि मिलेगी। जब आप valueof API कहते हैं तो बड़ा अंतर कैशिंग है। अगर यह -128 से 127 के बीच है तो कैश करें। अधिक जानकारी के लिए कृपया नीचे दिए गए लिंक को देखें
http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html
सार्वजनिक स्थैतिक पूर्णांक मान (स्ट्रिंग s)
परिणाम एक पूर्णांक वस्तु है जो स्ट्रिंग द्वारा निर्दिष्ट पूर्णांक मान का प्रतिनिधित्व करता है।
दूसरे शब्दों में, यह विधि एक पूर्णांक वस्तु को मान के बराबर लौटा देती है: नया पूर्णांक (Integer.parseInt)
Integer.parseInt केवल स्ट्रिंग स्वीकार करते हैं और आदिम पूर्णांक प्रकार (int) वापस करते हैं।
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}Iteger.valueOf int और स्ट्रिंग को स्वीकार करते हैं। यदि मान स्ट्रिंग है, मान इसे parseInt का उपयोग करके सरल इंट में बदल देता है और इनपुट से -128 या 127 से अधिक होने पर नया इंटेगर वापस लौटाता है। यदि इनपुट रेंज में है (-128 - 127) तो यह हमेशा इंटीजर ऑब्जेक्ट को वापस लौटाता है आंतरिक IntegerCache। Integer वर्ग एक आंतरिक स्थैतिक IntegerCache वर्ग को बनाए रखता है जो कैश के रूप में कार्य करता है और -128 से 127 तक पूर्णांक ऑब्जेक्ट रखता है और इसीलिए जब हम 127 के लिए पूर्णांक ऑब्जेक्ट प्राप्त करने का प्रयास करते हैं (उदाहरण के लिए) हमें हमेशा एक ही ऑब्जेक्ट मिलता है।
Iteger.valueOf(200)200 से नया इंटेगर देगा। जैसा new Integer(200)
Iteger.valueOf(127)है वैसा ही है Integer = 127;
यदि आप String को Integer उपयोग में बदलना चाहते हैं Iteger.valueOf।
यदि आप String को साधारण int उपयोग में बदलना नहीं चाहते हैं Integer.parseInt। यह तेजी से काम करता है।
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}और Integer.valueOf (127) == Integer.valueOf (127) की तुलना सही है
Integer a = 127; // Compiler converts this line to Integer a = Integer.valueOf(127);
Integer b = 127; // Compiler converts this line to Integer b = Integer.valueOf(127);
a == b; // return true क्योंकि यह कैश से समान संदर्भों के साथ इंटेगर ऑब्जेक्ट लेता है।
लेकिन Integer.valueOf (128) == Integer.valueOf (128) गलत है, क्योंकि 128 IntegerCache रेंज से बाहर है और यह नया Integer लौटाता है, इसलिए वस्तुओं का अलग-अलग संदर्भ होगा।
हमें अपनी आवश्यकता के आधार पर किसी एक का उपयोग करना चाहिए। ValueOf के मामले में, यह किसी वस्तु को तात्कालिक कर रहा है। यह अधिक संसाधनों का उपभोग करेगा यदि हमें केवल कुछ पाठ के मूल्य की आवश्यकता है तो हमें parseInt, parseFloat आदि का उपयोग करना चाहिए।