इसलिए मुझे पता है कि इससे मिलते-जुलते अन्य प्रश्न भी हैं, जैसे कि do-not-use-new?lq=1">यह वाला और यह अन्य वाला। लेकिन उनका उत्तर ऐसा प्रतीत होता है कि क्योंकि वे शाब्दिक हैं और अपरिवर्तनीय शाब्दिक स्थिरांक के कुछ पूल का हिस्सा हैं, वे उपलब्ध रहेंगे। इस तरह का मुझे समझ में आता है, लेकिन फिर गैर-शाब्दिक भी ठीक काम क्यों करते हैं? स्ट्रिंग्स से निपटने के दौरान मुझे कभी भी "नया" कीवर्ड का उपयोग कब करना पड़ता है। नीचे दिए गए उदाहरण में, मैं कुछ चीजें करने के लिए स्ट्रिंग्स का उपयोग करता हूं, लेकिन सब कुछ ठीक काम करता है और मैं कभी भी "नया" कीवर्ड का उपयोग नहीं करता (सुधार: मैं इसे स्ट्रिंग प्रकार ऑब्जेक्ट के साथ कभी भी उपयोग नहीं करता)।

import java.util.*;

class teststrings{

   public static void main(String[] args){
      Scanner in = new Scanner(System.in);
      String nonew;
      String nonew2;
      String literally= "old";
      literally= "new"; //does the word "old" get garbage collected here?
      nonew = in.nextLine(); //this does not use the new keyword, but it works, why?
      System.out.println("nonew:"+nonew);
      System.out.println("literally:"+literally);
      nonew2 = in.nextLine();
      System.out.println("nonew:"+nonew); //the data is still preserved here
      System.out.println("nonew2:"+nonew2);
      //I didn't use the new keyword at all, but everything worked
      //So, when do I need to use it?
   }

}
1
ADJenks 13 मार्च 2016, 04:46

2 जवाब

सबसे बढ़िया उत्तर

कुछ बिंदु: "क्या "पुराना" शब्द यहां कचरा इकट्ठा करता है?" संभावना है कि आपका कंपाइलर महसूस करता है कि इसका कभी भी उपयोग नहीं किया जाता है और इसे पूरी तरह से छोड़ देता है।

Scanner::nextLine एक String देता है, और विधि द्वारा लौटाया गया मान असाइनमेंट के लिए उपयोग किया जाता है।

जहां तक ​​Strings के लिए से new का उपयोग करने का सवाल है... खैर, शायद ही कभी सबसे अच्छा होगा। केवल एक बार जब मैंने इसे देखा है तो यह आंतरिक स्थिरांक के लिए होगा। उदाहरण के लिए

public class MatchChecker {
    private static final String ANY_VALUE = new String("*");

    private final Map<Object, String> map = new HashMap<Object, String>();

    public void addMatch(Object object, String string) {
        map.put(object, string);
    }

    public void addAnyValueMatch(Object object) {
        map.put(object, ANY_VALUE);
    }

    public boolean matches(Object object, String string) {
        if (!map.contains(object)) {
            return false;
        }
        if (map.get(object) == ANY_VALUE || map.get(object).equals(string)) {
            return true;
        }
        return false;
    }
}

जिसका अर्थ होगा केवल addAnyValueMatch के माध्यम से जोड़े गए ऑब्जेक्ट किसी भी मान से मेल खाएंगे (जैसा कि == के साथ परीक्षण किया गया है), भले ही उपयोगकर्ता ने "*" स्ट्रिंग के रूप में उपयोग किया हो addMatch.

2
BeUndead 13 मार्च 2016, 05:11

जावा में स्ट्रिंग्स का विशेष रूप से इलाज किया जाता है। जावा जेवीएम एक कैश जैसे कार्यान्वयन का उपयोग करता है जिसे स्ट्रिंग पूल कहा जाता है।

अन्य वस्तुओं के विपरीत, जब आप इस तरह एक शाब्दिक स्ट्रिंग बनाते हैं: String mystring = "Hello"; जावा पहले यह देखने के लिए जांच करेगा कि स्ट्रिंग पूल में स्ट्रिंग "हैलो" पहले से मौजूद है या नहीं। यदि नहीं, तो यह इसे कैश्ड करने के लिए जोड़ देगा और फिर से संदर्भित होने पर पुन: उपयोग किया जाएगा।

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

String s1 = "Hello";
String s2 = "Hello";
String s3 = s1;
s1 = "SomethingElse"

उपरोक्त कोड में, जब s1 को "हैलो" असाइन किया जाता है, तो JVM देखेगा कि यह पूल में संग्रहीत नहीं है और इसे पूल में बनाएं/जोड़ें। S2 के लिए, आप फिर से "हैलो" का संदर्भ दे रहे हैं। JVM इसे पूल में देखेगा और पूल में संग्रहीत उसी स्ट्रिंग को s2 असाइन करेगा। s3 को केवल s1 के मेमोरी एड्रेस या उसी स्ट्रिंग "हैलो" पर संदर्भित मान को सौंपा गया है। अंत में, s1 को फिर से किसी अन्य स्ट्रिंग को सौंप दिया जाता है, जो अभी तक पूल में मौजूद नहीं है, इसलिए इसे जोड़ा जाता है। इसके अलावा, s1 अब "हैलो" की ओर इशारा नहीं करता है, फिर भी यह दो कारणों से एकत्रित कचरा नहीं होगा। 1:t स्ट्रिंग पूल में संग्रहीत किया जा रहा है और 2: s2 भी उसी संदर्भित स्ट्रिंग को इंगित करता है।

स्ट्रिंग्स के साथ, आपको शाब्दिक स्ट्रिंग्स बनाने के लिए कभी भी new कीवर्ड का उपयोग नहीं करना चाहिए। यदि आप करते हैं, तो आप स्ट्रिंग पूल के पुन: उपयोग का लाभ नहीं उठा रहे हैं और स्मृति में एक ही स्ट्रिंग के कई उदाहरण मौजूद हो सकते हैं, जो एक बेकार है।

2
pczeus 13 मार्च 2016, 05:32