दिलचस्प पोस्ट
जावा के साथ पुनरावर्ती एक निर्देशिका से सभी फ़ाइलों की सूची मेरे आंशिक दृश्य के जावास्क्रिप्ट इनलाइन में एनजी-स्कोप क्यों जोड़ा गया है और सचेत काम नहीं कर रहा है? चयन ऑब्जेक्ट के बाद पॉज़ या स्लीप करने में असमर्थ क्या जावा के बिगडीकल के समकक्ष सी ++ है? मैं एक सीएसवी फ़ाइल में शब्दकोशों की इस सूची को कैसे परिवर्तित कर सकता हूं? लकड़हारा सबसे अच्छा अभ्यास अभ्यास मैटलैब से ओपनसीवी तक इस इमेज प्रोसेसिंग का अनुवाद कैसे करें? क्या मैं डिबग जानकारी के साथ "पूर्ण" या "पीडीबी-केवल" रिलीज का संकलन करना चाहता हूं? एक आईओएस ऐप में फेसबुक प्रमाणीकरण के लिए डिजाइन जो एक सुरक्षित वेब सेवा तक पहुंचता है PHPExcel वर्ग Zend Autoloader में नहीं मिला धीमापन पाया जब बेस 64 छवि का चयन करें और डेटाबेस से सांकेतिक शब्दों में बदलना कैसे VBA के साथ निर्दिष्ट सेल स्थिति पर एक चित्र Excel में डालें Android WebView कुकी समस्या चौड़ाई और ऊंचाई तय हुई डिवीजन में एलेप्सेस के साथ बहु-रेखाएं पाठ ओवरफ्लो को क्रॉस ब्राउज़ करें? ओपनसीवी के साथ वीडियो स्थिरीकरण

जावा स्ट्रिंग्स: "स्ट्रिंग s = नया स्ट्रिंग (" मूर्ख ");"

मैं एक सी ++ आदमी जावा सीख रहा हूँ मैं प्रभावी जावा पढ़ रहा हूँ और कुछ मुझे उलझन में यह कहते हैं कि इस तरह कभी भी कोड लिखना नहीं है:

String s = new String("silly"); 

क्योंकि यह अनावश्यक String ऑब्जेक्ट बनाता है लेकिन इसके बजाय इसे इस प्रकार लिखा जाना चाहिए:

 String s = "No longer silly"; 

ठीक है अब तक … हालांकि, इस वर्ग को दिया गया है:

 public final class CaseInsensitiveString { private String s; public CaseInsensitiveString(String s) { if (s == null) { throw new NullPointerException(); } this.s = s; } : : } CaseInsensitiveString cis = new CaseInsensitiveString("Polish"); String s = "polish"; 
  1. पहला बयान ठीक क्यों है? ऐसा नहीं होना चाहिए

    CaseInsensitiveString cis = "Polish";

  2. मैं CaseInsensitiveString String तरह व्यवहार कैसे कर सकता हूं, इसलिए उपरोक्त कथन ठीक है ( String को बढ़ाए बिना और)? स्ट्रिंग के बारे में क्या है जो इसे ठीक उसी तरह पारित करने में सक्षम हो सकता है जैसे कि? मेरी समझ से जावा में कोई "प्रतिलिपि निर्माता" अवधारणा नहीं है?

Solutions Collecting From Web of "जावा स्ट्रिंग्स: "स्ट्रिंग s = नया स्ट्रिंग (" मूर्ख ");""

String का एक विशेष अंतर्निहित वर्ग है। यह केवल String क्लास के लिए है जिसमें आपको कहने से बचना चाहिए

 String s = new String("Polish"); 

क्योंकि शाब्दिक "Polish" पहले से ही String का प्रकार है, और आप एक अतिरिक्त अनावश्यक ऑब्जेक्ट बना रहे हैं। किसी भी अन्य वर्ग के लिए, कह रही है

 CaseInsensitiveString cis = new CaseInsensitiveString("Polish"); 

सही है (और केवल, इस मामले में) करने की बात करना

मेरा मानना ​​है कि शाब्दिक रूप (यानी, "फू" के बजाय नया स्ट्रिंग ("फू")) का उपयोग करने का मुख्य लाभ यह है कि सभी स्ट्रिंग लीटरल्स को वीएम द्वारा 'इंटर्न किया गया' है। दूसरे शब्दों में यह एक पूल में जोड़ा जाता है, ऐसा कोई अन्य कोड जो समान स्ट्रिंग बनाता है, एक नए उदाहरण बनाने की बजाय पूल स्ट्रिंग का उपयोग करेगा

उदाहरण के लिए, निम्न कोड पहली पंक्ति के लिए सही प्रिंट करेंगे, लेकिन दूसरे के लिए गलत होगा:

 System.out.println("foo" == "foo"); System.out.println(new String("bar") == new String("bar")); 

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

अगर आप लिखते हैं

 String s = "Polish"; String t = "Polish"; 

तो एस और टी वास्तव में एक ही वस्तु का संदर्भ लेते हैं, और एस == टी सच वापस आएगा, वस्तुओं के लिए "==" पढ़ने के लिए "एक ही वस्तु है" (या, वैसे भी, मुझे यकीन नहीं है कि यह का हिस्सा है वास्तविक भाषा कल्पना या बस कंपाइलर कार्यान्वयन का एक विवरण – तो शायद इस पर भरोसा करना सुरक्षित नहीं है)।

अगर आप लिखते हैं

 String s = new String("Polish"); String t = new String("Polish"); 

तो s! = t (क्योंकि आपने स्पष्ट रूप से एक नई स्ट्रिंग बनाई है) हालांकि s.equals (t) सच हो जाएगा (क्योंकि स्ट्रिंग इस व्यवहार को बराबर जोड़ता है)।

जिस चीज़ को आप लिखना चाहते हैं,

 CaseInsensitiveString cis = "Polish"; 

काम नहीं कर सकता क्योंकि आप सोच रहे हैं कि उद्धरण आपके ऑब्जेक्ट के लिए किसी प्रकार का शॉर्ट-सर्किट कन्स्ट्रक्टर हैं, जब वास्तव में यह केवल सादे पुराने जावा के लिए काम करता है।

 String s1="foo"; 

शाब्दिक पूल में जाएगा और एस 1 देखेंगे।

 String s2="foo"; 

इस बार यह "फू" शब्द की जाँच करेगा पहले से ही StringPool में उपलब्ध है या नहीं के रूप में अब यह मौजूद है इसलिए S2 उसी शब्द का संदर्भ लेंगे।

 String s3=new String("foo"); 

स्ट्रिंगपुल में "फू" शब्दशः बनाया जाएगा पहले स्ट्रिंग एजी कन्स्ट्रक्टर स्ट्रिंग ऑब्जेक्ट के माध्यम से या तो नए ऑपरेटर के माध्यम से ऑब्जेक्ट सृजन के कारण ढेर में "फू" बनाया जाएगा, फिर एस 3 इसका संदर्भ देगा।

 String s4=new String("foo"); 

एस 3 के समान

इसलिए System.out.println(s1==s2);// **true** due to literal comparison.

और System.out.println(s3==s4);// **false** due to object

तुलना (एस 3 और एस 4 को ढेर में विभिन्न स्थानों पर बनाया गया है)

String जावा में विशेष हैं – वे अपरिवर्तनीय हैं, और स्ट्रिंग स्थिरांक स्वचालित रूप से String ऑब्जेक्ट्स में बदल जाते हैं।

आपके SomeStringClass cis = "value" उदाहरण के लिए कोई अन्य वर्ग के लिए आवेदन करने का कोई तरीका नहीं है।

और न ही आप String विस्तार कर सकते हैं, क्योंकि इसे final रूप में घोषित किया गया है, जिसका अर्थ नहीं उप-वर्गीकरण की अनुमति है।

जावा तार दिलचस्प हैं ऐसा लगता है कि प्रतिक्रियाओं ने कुछ दिलचस्प बिंदुओं को कवर किया है। ये मेरे दो सेंट हैं

तार अपरिवर्तनीय हैं (आप उन्हें कभी नहीं बदल सकते हैं)

 String x = "x"; x = "Y"; 
  • पहली पंक्ति एक वेरिएबल एक्स बनाएगी जिसमें स्ट्रिंग मान "x" होगा। जेवीएम स्ट्रिंग मानों के अपने पूल में दिखेगा और देखेंगे कि यदि "एक्स" मौजूद है, तो यह वैरिएबल एक्स को इंगित करेगा, अगर यह अस्तित्व में नहीं है, तो इसे बना देगा और फिर असाइनमेंट करें
  • दूसरी पंक्ति "x" के संदर्भ को निकाल देगी और देखें कि "वाई" स्ट्रिंग मानों के पूल में मौजूद है या नहीं। यदि यह अस्तित्व में है, तो यह उसे निर्दिष्ट करेगा, अगर ऐसा नहीं होता है, तो यह पहले इसे असाइनमेंट बना देगा। जैसे स्ट्रिंग मान का उपयोग किया जाता है या नहीं, स्ट्रिंग मानों के पूल में स्मृति स्थान को पुनः प्राप्त किया जाएगा।

स्ट्रिंग तुलना आप क्या तुलना कर रहे हैं पर आकस्मिक हैं

 String a1 = new String("A"); String a2 = new String("A"); 
  • a1 a2 बराबर नहीं है
  • a1 और a2 वस्तु संदर्भ हैं
  • जब स्ट्रिंग स्पष्ट रूप से घोषित किया जाता है, नया उदाहरण बना दिया जाता है और उनके संदर्भ समान नहीं होंगे।

मुझे लगता है कि आप केसिनसेंसिवेटिव क्लास का उपयोग करने के लिए गलत रास्ते पर हैं। अकेले तार छोड़ें आप वास्तव में किस चीज के बारे में परवाह करते हैं यह है कि आप मूल्यों की तुलना या तुलना कैसे करते हैं। स्ट्रिंग को फ़ॉर्मेट करने या तुलना करने के लिए दूसरे वर्ग का उपयोग करें।

अर्थात

 TextUtility.compare(string 1, string 2) TextUtility.compareIgnoreCase(string 1, string 2) TextUtility.camelHump(string 1) 

चूंकि आप कक्षा बना रहे हैं, आप तुलना कर सकते हैं जो आप चाहते हैं – पाठ मूल्यों की तुलना करें

आप नहीं कर सकते जावा में दोहरे उद्धरण में चीजें विशेष रूप से संकलक के रूप में स्ट्रिंग के रूप में मान्यता प्राप्त होती हैं, और दुर्भाग्य से आप इसे ओवरराइड नहीं कर सकते (या java.lang.String विस्तार – यह घोषित final )।

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

 String s = "Hello"; 

केवल पूल में एक स्ट्रिंग ऑब्जेक्ट बनाएगा और संदर्भ एस इसका उल्लेख करेगा, लेकिन इसका उपयोग करके

 String s = new String("Hello"); 

आप दो स्ट्रिंग ऑब्जेक्ट बनाते हैं: एक पूल में और दूसरे में हीप में। संदर्भ ढेर में ऑब्जेक्ट को देखेंगे।

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

हालांकि, स्ट्रिंग वाकई एक केसइन्सेंसिस्टिव स्ट्रिंग नहीं है, इसलिए आप अपने अंतिम उदाहरण में जो कुछ चाहते हैं वह नहीं कर सकते। इसके अलावा, कास्टिंग ऑपरेटर को लोड करने का कोई तरीका नहीं है जैसे कि आप C ++ में कर सकते हैं, इसलिए वस्तुतः आपके लिए क्या करना है कोई रास्ता नहीं है। आपको इसके बजाय अपने वर्ग के निर्माता के लिए एक पैरामीटर के रूप में इसे पास करना होगा बेशक, मैं शायद सिर्फ String.toLowerCase () का उपयोग करें और इसके साथ किया जाना चाहिए।

साथ ही, आपका केसइन्सेंसिस्टिव स्ट्रिंग को चारसेंक्वेंस इंटरफेस भी लागू करना चाहिए और साथ ही संभवतः सीरियलज करने योग्य और तुलनात्मक इंटरफेस। बेशक, यदि आप तुलनात्मक लागू करते हैं, तो आपको बराबर () और हैशोड () के बराबर ओवरराइड करना चाहिए

– मैं कैसे केसइन्सेंसिस्टिव स्ट्रिंग स्ट्रिंग की तरह व्यवहार करता हूं ताकि उपरोक्त कथन ठीक है (साथ में और स्ट्रिंग को बढ़ाएगा)? स्ट्रिंग के बारे में क्या है जो इसे ठीक उसी तरह पारित करने में सक्षम हो सकता है जैसे कि? मेरी समझ से जावा में कोई "प्रतिलिपि निर्माता" अवधारणा नहीं है?

पर्याप्त पहले बिंदु से कहा गया है "पोलिश" एक स्ट्रिंग शब्दशः है और CaseInsentiviveString वर्ग को असाइन नहीं किया जा सकता।

अब दूसरे बिंदु के बारे में

यद्यपि आप नये लीटरल नहीं बना सकते हैं, तो आप "समान" दृष्टिकोण के लिए उस पुस्तक के पहले आइटम का अनुसरण कर सकते हैं ताकि निम्नलिखित कथन सही हो:

  // Lets test the insensitiveness CaseInsensitiveString cis5 = CaseInsensitiveString.valueOf("sOmEtHiNg"); CaseInsensitiveString cis6 = CaseInsensitiveString.valueOf("SoMeThInG"); assert cis5 == cis6; assert cis5.equals(cis6); 

यहाँ कोड है

 C:\oreyes\samples\java\insensitive>type CaseInsensitiveString.java import java.util.Map; import java.util.HashMap; public final class CaseInsensitiveString { private static final Map<String,CaseInsensitiveString> innerPool = new HashMap<String,CaseInsensitiveString>(); private final String s; // Effective Java Item 1: Consider providing static factory methods instead of constructors public static CaseInsensitiveString valueOf( String s ) { if ( s == null ) { return null; } String value = s.toLowerCase(); if ( !CaseInsensitiveString.innerPool.containsKey( value ) ) { CaseInsensitiveString.innerPool.put( value , new CaseInsensitiveString( value ) ); } return CaseInsensitiveString.innerPool.get( value ); } // Class constructor: This creates a new instance each time it is invoked. public CaseInsensitiveString(String s){ if (s == null) { throw new NullPointerException(); } this.s = s.toLowerCase(); } public boolean equals( Object other ) { if ( other instanceof CaseInsensitiveString ) { CaseInsensitiveString otherInstance = ( CaseInsensitiveString ) other; return this.s.equals( otherInstance.s ); } return false; } public int hashCode(){ return this.s.hashCode(); } 

// "जोर" कीवर्ड का उपयोग करके कक्षा का परीक्षण करें

  public static void main( String [] args ) { // Creating two different objects as in new String("Polish") == new String("Polish") is false CaseInsensitiveString cis1 = new CaseInsensitiveString("Polish"); CaseInsensitiveString cis2 = new CaseInsensitiveString("Polish"); // references cis1 and cis2 points to differents objects. // so the following is true assert cis1 != cis2; // Yes they're different assert cis1.equals(cis2); // Yes they're equals thanks to the equals method // Now let's try the valueOf idiom CaseInsensitiveString cis3 = CaseInsensitiveString.valueOf("Polish"); CaseInsensitiveString cis4 = CaseInsensitiveString.valueOf("Polish"); // References cis3 and cis4 points to same object. // so the following is true assert cis3 == cis4; // Yes they point to the same object assert cis3.equals(cis4); // and still equals. // Lets test the insensitiveness CaseInsensitiveString cis5 = CaseInsensitiveString.valueOf("sOmEtHiNg"); CaseInsensitiveString cis6 = CaseInsensitiveString.valueOf("SoMeThInG"); assert cis5 == cis6; assert cis5.equals(cis6); // Futhermore CaseInsensitiveString cis7 = CaseInsensitiveString.valueOf("SomethinG"); CaseInsensitiveString cis8 = CaseInsensitiveString.valueOf("someThing"); assert cis8 == cis5 && cis7 == cis6; assert cis7.equals(cis5) && cis6.equals(cis8); } } C:\oreyes\samples\java\insensitive>javac CaseInsensitiveString.java C:\oreyes\samples\java\insensitive>java -ea CaseInsensitiveString C:\oreyes\samples\java\insensitive> 

यही है, CaseInsensitiveString ऑब्जेक्ट्स का एक आंतरिक पूल बनाएं, और वहां से कोरेंसस्पोंंगिंग इनाम वापस लौटाएं।

इस तरह से "==" ऑपरेटर एक ही मान के दो ऑब्जेक्ट संदर्भों के लिए वास्तविक रिटर्न देता है

यह उपयोगी है जब समान ऑब्जेक्ट्स बहुत बार उपयोग किए जाते हैं और लागत का निर्माण महंगा है

स्ट्रिंग क्लास प्रलेखन बताता है कि क्लास एक आंतरिक पूल का उपयोग करता है

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

यह ध्यान देने योग्य है कि आंतरिकपूल ऑब्जेक्ट का उपयोग करके, संदर्भ जारी नहीं किए जाते हैं और इस तरह कचरा संग्रहण योग्य नहीं होते हैं, और यदि बहुत सारे ऑब्जेक्ट बनाए जाते हैं तो यह एक समस्या बन सकता है

यह स्ट्रिंग वर्ग के लिए काम करता है क्योंकि यह तीव्रता से उपयोग किया जाता है और पूल को "इंन्टर" ऑब्जेक्ट का ही गठन किया जाता है

यह बूलियन वर्ग के लिए भी अच्छी तरह से काम करता है, क्योंकि केवल दो संभावित मान हैं

और अंत में यह भी कारण है कि क्लास पूर्णांक में valueOf (int) -128 से 127 int मान तक सीमित है।

सिर्फ इसलिए कि आपके पास वर्ड String शब्द है, इसका मतलब यह नहीं है कि आप अंतर्निहित String क्लास की सभी विशेष सुविधाएं प्राप्त करते हैं।

CaseInsensitiveString String नहीं है हालांकि इसमें String शामिल है एक String शाब्दिक जैसे "उदाहरण" केवल String को सौंपा जा सकता है।

केसइन्सेंसिस्टिव स्ट्रिंग और स्ट्रिंग विभिन्न ऑब्जेक्ट हैं I आप ऐसा नहीं कर सकते:

 CaseInsensitiveString cis = "Polish"; 

क्योंकि "पोलिश" एक स्ट्रिंग है, नहीं CaseInsensitiveString। यदि स्ट्रिंग विस्तारित CaseInsensitiveString स्ट्रिंग, तो आप ठीक हो जाएंगे, लेकिन जाहिर है यह नहीं है।

और यहाँ निर्माण के बारे में चिंता मत करो, आप अनावश्यक वस्तुओं नहीं बना रहे होंगे। यदि आप कन्स्ट्रक्टर के कोड को देखते हैं, तो यह सब आपके द्वारा पारित स्ट्रिंग के संदर्भ को संचित कर रहा है। अतिरिक्त कुछ भी नहीं बनाया जा रहा है।

स्ट्रिंग एस = नया स्ट्रिंग ("फोबार") मामले में यह कुछ अलग कर रहा है आप पहली बार शाब्दिक स्ट्रिंग "फोबोर" का निर्माण कर रहे हैं, उसके बाद एक नई स्ट्रिंग तैयार करके इसकी एक प्रतिलिपि बनाना। उस प्रति को बनाने की कोई ज़रूरत नहीं है

जब वे लिखने के लिए कहते हैं

 String s = "Silly"; 

के बजाय

 String s = new String("Silly"); 

उनका मतलब स्ट्रिंग ऑब्जेक्ट बनाते समय होता है क्योंकि उपर्युक्त दोनों बयान स्ट्रिंग ऑब्जेक्ट बनाते हैं, लेकिन नया स्ट्रिंग () संस्करण दो स्ट्रिंग ऑब्जेक्ट बनाता है: एक में हीप और स्ट्रिंग स्ट्रिंग पूल में दूसरा इसलिए अधिक मेमोरी का उपयोग करना

लेकिन जब आप लिखते हैं

 CaseInsensitiveString cis = new CaseInsensitiveString("Polish"); 

आप एक स्ट्रिंग नहीं बना रहे हैं, बजाय आप वर्ग CaseInsensitiveString का ऑब्जेक्ट बना रहे हैं। इसलिए आपको नए ऑपरेटर का उपयोग करने की आवश्यकता है।

अगर मैं इसे सही ढंग से समझता हूं, तो आपका प्रश्न का अर्थ है कि हम इसे किसी वस्तु को सीधे निर्दिष्ट करके एक ऑब्जेक्ट नहीं बना सकते हैं, इसे जावा में स्ट्रिंग क्लास के रैपर को सीमित नहीं करने देता है।

उत्तर देने के लिए कि मैं सिर्फ इतना कहूँगा, विशुद्ध रूप से वस्तु उन्मुख प्रोग्रामिंग भाषाओं में कुछ निर्माण होते हैं और यह कहते हैं, कि सभी लिटरल्स अकेले लिखे गए शब्दों को किसी प्रकार के ऑब्जेक्ट में सीधे रूपांतरित कर सकते हैं।

इसका सही अर्थ है, यदि दुभाषिया 3 देखता है तो इसे पूर्णांक वस्तु में परिवर्तित कर दिया जाएगा क्योंकि पूर्णांक इस तरह के शाब्दिक रूपों के लिए निर्धारित प्रकार है

यदि दुभाषिया एक 'ए' जैसे एकल उद्धरण में किसी भी चीज़ को देखता है तो यह सीधे टाइप ऑब्जेक्ट का एक ऑब्जेक्ट बनाता है, आपको इसे निर्दिष्ट करने की ज़रूरत नहीं है क्योंकि भाषा इसके लिए टाइप ऑब्जेक्ट की डिफ़ॉल्ट ऑब्जेक्ट को परिभाषित करती है।

इसी तरह अगर दुभाषिया कुछ में देखता है तो इसे अपने डिफ़ॉल्ट प्रकार यानी स्ट्रिंग के ऑब्जेक्ट के रूप में माना जाएगा। यह पृष्ठभूमि में कुछ देशी कोड काम कर रहा है।

एमआईटी वीडियो व्याख्यान कोर्स के लिए धन्यवाद 6.00 जहां मुझे इस उत्तर के लिए संकेत मिला।

जावा में वाक्यविन्यास "पाठ" वर्ग java.lang.String का एक उदाहरण बनाता है। काम:

 String foo = "text"; 

एक सरल कार्य है, कोई प्रतिलिपि निर्माता आवश्यक नहीं है

 MyString bar = "text"; 

क्या अवैध है जो आप करते हैं क्योंकि मैस्टस्ट्रिंग कक्षा या तो जावा नहीं है। लंग। स्ट्रिंग या java.lang.String का एक सुपर वर्ग।

सबसे पहले, आप एक ऐसा वर्ग नहीं बना सकते जो स्ट्रिंग से फैली हुई है, क्योंकि स्ट्रिंग अंतिम श्रेणी है। और जावा स्ट्रिंग को अन्य कक्षाओं से अलग ढंग से प्रबंधित करते हैं, इसलिए स्ट्रिंग के साथ ही आप कर सकते हैं

 String s = "Polish"; 

लेकिन अपने वर्ग को कंट्रोलर को आमंत्रित करना होगा। तो, यह कोड ठीक है।

मैं सिर्फ उस जावा को प्रतिलिपि बनाने वाले कंसल्टेंट्स को जोड़ दूंगा …

ठीक है, यह तर्क के रूप में एक ही प्रकार के एक वस्तु के साथ एक साधारण निर्माता है।

जेडीके के अधिकतर संस्करणों में दो संस्करण समान होंगे:

स्ट्रिंग एस = नया स्ट्रिंग ("मूर्ख");

स्ट्रिंग s = "अब मूर्ख नहीं";

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

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

मैं भेद यहाँ नहीं देख रहा हूँ हालांकि अपने खुद के वर्ग के लिए, जो अपरिवर्तनीय नहीं है, यह व्यवहार अप्रासंगिक है और आपको अपने कन्स्ट्रक्टर को कॉल करना चाहिए।

अद्यतनः मैं गलत था! नीचे दिए गए वोट और टिप्पणी संलग्न के आधार पर, मैंने इसका परीक्षण किया और यह महसूस किया कि मेरी समझ गलत है – नया स्ट्रिंग ("सिली") वास्तव में मौजूदा एक का पुन: उपयोग करने के बजाय एक नई स्ट्रिंग बनाते हैं। मैं स्पष्ट नहीं है कि यह क्यों होगा (लाभ क्या है?) लेकिन कोड शब्दों की तुलना में जोर से बोलता है!

स्ट्रिंग विशेष वर्गों में से एक है जिसमें आप उन्हें नए सिरों वाले भाग के बिना बना सकते हैं

यह समान है

int x = y;

या

चार सी;

यह एक बुनियादी कानून है कि जावा में स्ट्रिंग अपरिवर्तनीय और मामला संवेदनशील है।

  String str1 = "foo"; String str2 = "foo"; 

दोनों स्ट्र1 और स्ट्र्बो समान स्ट्रिंग ऑब्जेक्ट था, "फू", बोंज़ जावा जावा स्ट्रिंग्स स्ट्रिंगपुल का प्रबंध करता है, इसलिए यदि एक नया वैरिएबल स्ट्रिंग को संदर्भित करता है, तो यह स्ट्रिंगपुल में एक ही एलार्डि मौजूद नहीं होता है ।

  String str1 = new String("foo"); String str2 = new String("foo"); 

यहां दोनों str1 और str2 अलग ऑब्जेक्ट्स से संबंधित हैं, b'coz new String () बलपूर्वक एक नया स्ट्रिंग ऑब्जेक्ट बनाएं

जावा आपके कोड में उपयोग किए जाने वाले प्रत्येक स्ट्रिंग के लिए स्ट्रिंग ऑब्जेक्ट बनाता है। कोई भी समय प्रयोग किया जाता है, यह new String() कहने के समान है।

तार जटिल डेटा होते हैं जो सिर्फ आदिम डेटा की तरह "कार्य" होता है स्ट्रिंग लिटरल्स वास्तव में वस्तुएं हैं, हालांकि हम बहाना करते हैं कि वे आदिम लिटरल हैं, जैसे कि 6, 6.0, 'c', आदि। स्ट्रिंग "शाब्दिक "text" मान के साथ एक नया स्ट्रिंग ऑब्जेक्ट देता है char[] value = {'t','e','x','t} । इसलिए, कॉलिंग

 new String("text"); 

वास्तव में कॉल करने के लिए समान है

 new String(new String(new char[]{'t','e','x','t'})); 

उम्मीद है कि यहां से, आप देख सकते हैं कि आपका पाठ्यपुस्तक इस बेमानी क्यों समझता है

संदर्भ के लिए, यहां स्ट्रिंग का कार्यान्वयन है: http://www.docjar.com/html/api/java/lang/String.java.html

यह एक मजेदार पढ़ा है और कुछ अंतर्दृष्टि को प्रेरित कर सकता है। शुरुआती लोगों को पढ़ना और समझने की कोशिश करना भी बहुत अच्छा है क्योंकि यह कोड बहुत ही पेशेवर और सम्मेलन-अनुपालन कोड दर्शाता है।

एक और अच्छा संदर्भ स्ट्रिंग पर जावा ट्यूटोरियल है: http://docs.oracle.com/javase/tutorial/java/data/strings.html