PGDCA, BCA, B-Tech, MCA, M-Tech, B.Sc computer science राजस्थान सूचना सहायक व कंप्यूटर शिक्षक विशेष नोट्स: इस अध्याय में हम Strings in Java: java.lang.String Class and Immutability (जावा स्ट्रिंग्स: String क्लास की अपरिवर्तनीय (Immutable) प्रकृति) की संपूर्ण थ्योरी, मुख्य तकनीकी बिंदु, तुलनात्मक तालिका और विगत परीक्षाओं के पैटर्न पर आधारित 20 अति-महत्वपूर्ण बहुविकल्पीय प्रश्न (MCQs) विस्तृत हिंदी व अंग्रेजी व्याख्या सहित पढ़ेंगे।
Overview: java.lang.String is a public final class whose instances represent immutable character sequences that cannot be altered after creation. Immutability enables String Constant Pool sharing, hashcode caching, thread safety, and tamper-resistant security parameters.
अध्याय सार: java.lang.String एक public final क्लास है जिसके ऑब्जेक्ट निर्माण के बाद अपरिवर्तनीय (immutable) कैरेक्टर अनुक्रम दर्शाते हैं। यह अपरिवर्तनीयता स्ट्रिंग कांस्टेंट पूल शेयरिंग, हैशकोड कैशिंग, थ्रेड सेफ्टी और सुरक्षित पैरामीटर पासिंग को संभव बनाती है।
Strings in Java: java.lang.String Class and Immutability: Detailed Notes & Architecture (जावा स्ट्रिंग्स: String क्लास की अपरिवर्तनीय (Immutable) प्रकृति)
1. Class Declaration, Interfaces, and Compact Strings Internals (क्लास डिक्लेरेशन, इंटरफ़ेस और कॉम्पैक्ट स्ट्रिंग्स आंतरिक संरचना)
[EN] In java.lang, String is declared as public final class String implements Serializable, Comparable<String>, CharSequence. Making String final prevents subclasses from overriding its methods to violate immutability contracts. Up through Java 8, String backed characters internally with a private final char[] array (2 bytes per UTF-16 character). Starting in Java 9 (JEP 254 Compact Strings), String stores characters in a private final byte[] value array paired with a byte coder flag (LATIN1 = 0 or UTF16 = 1), halving heap footprint for ASCII/Latin-1 text.
[HI] java.lang पैकेज में String को public final class String implements Serializable, Comparable<String>, CharSequence के रूप में घोषित किया गया है। String के final होने से कोई सबक्लास इसके मेथड्स ओवरराइड करके अपरिवर्तनीयता को भंग नहीं कर सकती। जावा 8 तक String आंतरिक रूप से private final char[] (प्रति कैरेक्टर 2 बाइट UTF-16) का उपयोग करती थी। जावा 9 (JEP 254 कॉम्पैक्ट स्ट्रिंग्स) से String एक private final byte[] value और एक coder फ्लैग (LATIN1 = 0 या UTF16 = 1) उपयोग करती है, जिससे ASCII टेक्स्ट की मेमोरी खपत आधी हो जाती है।
2. How Immutability Works Under the Hood (अपरिवर्तनीयता (Immutability) आंतरिक रूप से कैसे काम करती है)
[EN] Once a String object is constructed in memory, its internal byte[] or char[] contents can never be overwritten or resized. Methods that appear to modify a string—such as concat(), toUpperCase(), replace(), or substring()—never edit the original instance; instead, they construct and return a brand-new String object. If a method produces an identical sequence (for example, calling "hello".toLowerCase()), Java optimizes memory by returning the same existing reference (this). Constructors taking external arrays like new String(char[] data) copy the incoming array defensively so subsequent edits to data do not mutate the String.
[HI] एक बार मेमोरी में String ऑब्जेक्ट बन जाने पर उसके आंतरिक byte[] या char[] डेटा को कभी बदला या रीसाइज़ नहीं किया जा सकता। concat(), toUpperCase(), replace() या substring() जैसे मेथड्स मूल ऑब्जेक्ट को नहीं बदलते बल्कि हमेशा एक नया String ऑब्जेक्ट बनाकर लौटाते हैं। यदि ऑपरेशन से कोई परिवर्तन न हो (जैसे "hello".toLowerCase()), तो जावा मेमोरी बचाने के लिए वही मौजूदा रेफरेंस (this) लौटा देता है। new String(char[] data) जैसा कंस्ट्रक्टर बाहर से मिले एरे की सुरक्षित कॉपी बनाता है ताकि बाद में मूल एरे बदलने पर String प्रभावित न हो।
3. Four Core Architectural Reasons String is Immutable (String के अपरिवर्तनीय होने के चार प्रमुख तकनीकी कारण)
[EN] First, Pool Sharing: multiple variables can safely point to the same literal in the String Constant Pool without one reference corrupting another's data. Second, Security: database URLs, usernames, file paths, network hosts, and reflection class names are passed as Strings; immutability blocks Time-of-Check to Time-of-Use tampering. Third, HashCode Caching: String caches its computed hashCode lazily in an int hash field, making String ideal as an O(1) key in HashMap and HashSet without recomputing hashes. Fourth, Thread Safety: immutable state allows concurrent threads to read shared Strings freely without synchronization locks.
[HI] पहला, पूल शेयरिंग: कई रेफरेंस बिना एक-दूसरे का डेटा खराब किए स्ट्रिंग कांस्टेंट पूल के एक ही लिटरल को सुरक्षित रूप से साझा कर सकते हैं। दूसरा, सुरक्षा: डेटाबेस URL, फ़ाइल पाथ, नेटवर्क होस्ट और क्लास लोडिंग के नाम String में पास होते हैं; अपरिवर्तनीयता जांच के बाद उनमें छेड़छाड़ रोकती है। तीसरा, हैशकोड कैशिंग: String अपना हैशकोड एक बार गणना करके कैश कर लेता है, जिससे HashMap और HashSet में तेज़ लुकअप मिलता है। चौथा, थ्रेड सेफ्टी: डेटा न बदलने के कारण अनेक थ्रेड्स बिना किसी सिंक्रोनाइज़ेशन लॉक के एक ही String को एक साथ पढ़ सकते हैं।
4. Reference Reassignment vs Object Mutation (रेफरेंस रीअसाइनमेंट बनाम ऑब्जेक्ट म्यूटेशन)
[EN] Beginners often confuse reassigning a String variable with mutating a String object: writing s = s + " World"; creates a new String object and points variable s to the new address. Meanwhile, the original "Hello" object remains completely intact in memory unless no references point to it and Garbage Collection reclaims it (outside the pool or unreferenced). Performing repeated string concatenation with + inside a tight loop allocates O(N^2) intermediate character bytes and triggers heavy GC pressure. For sensitive credentials like passwords, security guidelines advise char[] over String because char[] can be zeroed out immediately whereas immutable Strings linger in Heap until GC.
[HI] अक्सर शुरुआती छात्र वेरिएबल रीअसाइनमेंट को ऑब्जेक्ट बदलाव समझ लेते हैं: s = s + " World"; लिखने पर नया String ऑब्जेक्ट बनता है और वेरिएबल s नए एड्रेस की ओर इशारा करने लगता है। मूल "Hello" ऑब्जेक्ट मेमोरी में ज्यों का त्यों सुरक्षित रहता है जब तक कि गार्बेज कलेक्टर उसे हटा न दे। लूप के अंदर बार-बार + से स्ट्रिंग जोड़ने पर अनेक अस्थायी ऑब्जेक्ट बनते हैं जिससे मेमोरी और GC पर भारी दबाव पड़ता है। पासवर्ड जैसे संवेदनशील डेटा के लिए String के बजाय char[] की सलाह दी जाती है क्योंकि char[] को उपयोग के बाद तुरंत शून्य किया जा सकता है।
Syntax, Formula & Technical Example (Strings in Java: java.lang.String Class and Immutability)
String s = "Java";
s.concat(" 21");
System.out.println(s); // prints Java
String s2 = s.concat(" 21");
System.out.println(s2); // prints Java 21
char[] buf = {'A', 'B'};
String copy = new String(buf);
buf[0] = 'Z';
System.out.println(copy); // still AB
Strings in Java: java.lang.String Class and Immutability Quick Reference & Comparison Table
| String Property | Technical Detail | Exam Fact |
|---|---|---|
| Class Modifiers | public final class in java.lang | Cannot be inherited or subclassed in Java |
| Implemented Interfaces | Serializable, Comparable, CharSequence | Enables sorting, serialization, and char sequence APIs |
| Backing Storage (Java 9+) | private final byte[] + coder byte | Compact Strings save up to 50% Heap for Latin-1 |
| HashCode Caching | Lazy cached int hash field | Eliminates repeated hashing when used as HashMap key |
Strings in Java: java.lang.String Class and Immutability Top 20 Bilingual MCQs with Answers
Q1. Why is the java.lang.String class declared with the final keyword?
(java.lang.String क्लास को final कीवर्ड के साथ क्यों घोषित किया गया है?)
(A) To allow multiple inheritance from StringBuffer
(B) To prevent subclassing so no child class can override methods and break immutability
(C) To disable Garbage Collection on String instances
(D) To store String objects on the JVM Stack
Correct Answer: (B)
[EN] Declaring String final guarantees that no subclass can expose mutable state or alter equals/hashCode semantics.
[HI] String को final रखने से कोई भी सबक्लास इसे एक्सटेंड करके इसके मेथड्स या अपरिवर्तनीयता नियम को बदल नहीं सकती।
Q2. What does this code print? String s = "Core"; s.toUpperCase(); System.out.print(s);
(यह कोड क्या प्रिंट करेगा? String s = "Core"; s.toUpperCase(); System.out.print(s);)
(A) CORE
(B) Core
(C) core
(D) Compile-time error
Correct Answer: (B)
[EN] toUpperCase() returns a new String "CORE", which is discarded because it is not reassigned to s; s still refers to "Core".
[HI] toUpperCase() एक नया String "CORE" लौटाता है जिसे s में असाइन नहीं किया गया, इसलिए s अब भी "Core" को दर्शाता है।
Q3. How did Java 9 (JEP 254 Compact Strings) change the internal storage field of java.lang.String?
(जावा 9 (JEP 254 कॉम्पैक्ट स्ट्रिंग्स) ने java.lang.String के आंतरिक स्टोरेज फ़ील्ड में क्या बदलाव किया?)
(A) Replaced char[] with StringBuilder
(B) Stored characters inside native OS disk swap
(C) Changed UTF-16 to fixed 32-bit int[]
(D) Replaced char[] with byte[] plus a 1-byte encoding coder flag
Correct Answer: (D)
[EN] Java 9 uses byte[] with coder (LATIN1 or UTF16) so single-byte Latin-1 characters consume 1 byte instead of 2.
[HI] जावा 9 ने char[] की जगह byte[] और एक coder फ़ील्ड पेश किया जिससे Latin-1 कैरेक्टर 2 के बजाय 1 बाइट लेते हैं।
Q4. Which set of interfaces is directly implemented by java.lang.String?
(java.lang.String सीधे निम्न में से किन इंटरफ़ेस को इम्प्लीमेंट करता है?)
(A) Appendable, Closeable, and List
(B) Cloneable, Iterable, and Runnable
(C) Comparator, AutoCloseable, and RandomAccess
(D) Serializable, Comparable<String>, and CharSequence
Correct Answer: (D)
[EN] String implements Serializable, Comparable<String>, and CharSequence (plus Constable/ConstantDesc in modern Java).
[HI] String मुख्य रूप से Serializable, Comparable<String> और CharSequence इंटरफ़ेस को इम्प्लीमेंट करता है।
Q5. Why are Strings preferred over mutable objects as keys in a HashMap?
(HashMap में कुंजी (key) के रूप में म्यूटेबल ऑब्जेक्ट्स की तुलना में String को प्राथमिकता क्यों दी जाती है?)
(A) Strings never experience hash collisions
(B) Immutability ensures the hashCode never changes after insertion and allows caching it once
(C) HashMap rejects all non-String keys
(D) Strings bypass equals() checks inside HashMap
Correct Answer: (B)
[EN] If a key's state mutated after insertion, its hash bucket would change; String caches its immutable hash safely.
[HI] इन्सर्ट होने के बाद यदि कुंजी बदल जाए तो हैश बकेट गलत हो जाएगा; String अपरिवर्तनीय रहकर अपना हैशकोड कैश कर लेता है।
Q6. What happens if you pass a char[] array to new String(arr) and later modify arr[0]?
(यदि आप new String(arr) बनाकर बाद में arr[0] को बदल दें तो String ऑब्जेक्ट पर क्या प्रभाव पड़ेगा?)
(A) The String mutates to match arr[0]
(B) Compilation fails unless arr is final
(C) Throws ConcurrentModificationException
(D) The String remains unchanged because the constructor makes a defensive copy
Correct Answer: (D)
[EN] String(char[]) copies the array contents into its own private internal storage to preserve strict immutability.
[HI] String(char[]) कंस्ट्रक्टर अपनी निजी आंतरिक मेमोरी में एरे की सुरक्षित कॉपी बनाता है, इसलिए बाद में arr बदलने से String नहीं बदलता।
Q7. Why do security best practices recommend char[] instead of String for storing passwords in memory?
(मेमोरी में पासवर्ड संग्रहीत करने के लिए सुरक्षा मानक String के बजाय char[] की सलाह क्यों देते हैं?)
(A) char[] automatically encrypts values with AES-256
(B) char[] cannot be viewed by debuggers
(C) String objects are always stored unencrypted on the hard disk
(D) A char[] can be explicitly overwritten with zeros immediately after use, whereas immutable Strings persist until GC
Correct Answer: (D)
[EN] Because Strings are immutable and may enter pools, secrets stay readable in memory dumps until garbage-collected.
[HI] String के अपरिवर्तनीय होने से पासवर्ड गार्बेज कलेक्शन तक मेमोरी डंप में बना रहता है, जबकि char[] को तुरंत शून्य से मिटाया जा सकता है।
Q8. What does "abc".concat("") return in Java?
(जावा में "abc".concat("") क्या लौटाता है?)
(A) The exact same "abc" String reference (this) without allocating a new object
(B) Throws IllegalArgumentException
(C) null
(D) A guaranteed new String object in Heap
Correct Answer: (A)
[EN] When concatenating an empty string, String.concat checks str.isEmpty() and returns the existing instance directly.
[HI] खाली स्ट्रिंग जोड़ने पर String.concat लंबाई 0 जांचकर नया ऑब्जेक्ट बनाए बिना मौजूदा रेफरेंस (this) ही लौटा देता है।
Q9. Does java.lang.String need an explicit import statement in a Java source file?
(क्या किसी जावा प्रोग्राम में java.lang.String का उपयोग करने के लिए explicit import स्टेटमेंट लिखना आवश्यक है?)
(A) Yes, import java.lang.String; is mandatory
(B) Only when using new String()
(C) Yes, since Java 9 modularization
(D) No, the java.lang package is automatically imported into every Java source file
Correct Answer: (D)
[EN] The compiler automatically imports all classes from java.lang into every compilation unit.
[HI] कंपाइलर प्रत्येक जावा सोर्स फ़ाइल में पूरे java.lang पैकेज को स्वचालित रूप से इम्पोर्ट कर देता है।
Q10. How is thread-safety achieved by String without using any synchronized methods?
(बिना किसी synchronized मेथड का उपयोग किए String थ्रेड-सेफ्टी कैसे सुनिश्चित करता है?)
(A) Strings reside inside ThreadLocal memory
(B) Because immutable objects have read-only state that cannot produce race conditions across threads
(C) The compiler inserts volatile locks on every String variable
(D) JVM freezes all other threads whenever a String is read
Correct Answer: (B)
[EN] Objects whose state cannot be modified after construction are inherently thread-safe for concurrent reads.
[HI] निर्माण के बाद जिस ऑब्जेक्ट की आंतरिक अवस्था बदल ही नहीं सकती, वह एकाधिक थ्रेड्स द्वारा पढ़ने पर स्वतः थ्रेड-सेफ होता है।
Q11. In Java, what happens to the original "Hello" object when you execute String s = "Hello"; s = "World";?
(String s = "Hello"; s = "World"; चलाने पर मूल "Hello" ऑब्जेक्ट के साथ क्या होता है?)
(A) "Hello" remains unchanged in the String pool while variable s is reassigned to "World"
(B) "Hello" is overwritten in place by "World"
(C) Compile-time error because String is final
(D) "Hello" is immediately deleted using free()
Correct Answer: (A)
[EN] Reassigning s changes only the local reference variable to point to "World"; the "Hello" literal object is untouched.
[HI] s को नया मान देने से केवल रेफरेंस वेरिएबल "World" की ओर मुड़ता है; "Hello" ऑब्जेक्ट मेमोरी में ज्यों का त्यों रहता है।
Q12. Which of the following operations causes poor O(N^2) performance when executed repeatedly inside a large loop?
(किसी बड़े लूप के अंदर बार-बार निष्पादित करने पर निम्न में से कौन-सा ऑपरेशन खराब O(N^2) प्रदर्शन देता है?)
(A) Reading string.length()
(B) Concatenating Strings using result += item; on every iteration
(C) Calling StringBuilder.append(item)
(D) Comparing strings using equals()
Correct Answer: (B)
[EN] Because String is immutable, result += item copies all previous characters into a newly allocated String on every loop cycle.
[HI] String के अपरिवर्तनीय होने के कारण लूप में result += item हर बार पिछले सभी कैरेक्टर्स की नई कॉपी बनाता है।
Q13. Can you store null inside a String variable like String name = null;?
(क्या String name = null; लिखकर किसी String वेरिएबल में null संग्रहीत किया जा सकता है?)
(A) Compile-time error
(B) Yes, because String is a reference type, though calling methods on it throws NullPointerException
(C) Yes, and name.length() returns 0
(D) No, String cannot hold null
Correct Answer: (B)
[EN] Any Java reference variable may hold null, but dereferencing null via name.length() throws NullPointerException.
[HI] String एक रेफरेंस टाइप है इसलिए यह null रख सकता है, परंतु उस पर मेथड कॉल करने पर NullPointerException आता है।
Q14. Which of the following is NOT true about java.lang.String?
(java.lang.String के बारे में निम्न में से कौन-सा कथन सत्य नहीं है?)
(A) String is immutable and final
(B) Calling replace('a', 'b') mutates the original String object's internal array
(C) String implements the CharSequence interface
(D) String caches its hash code for performance
Correct Answer: (B)
[EN] replace() never modifies the original String; it returns a new String (or this if no character matched).
[HI] replace() कभी भी मूल String ऑब्जेक्ट को नहीं बदलता; यह हमेशा नया String लौटाता है (यदि कोई बदलाव हो)।
Q15. What value does "Java".toLowerCase().equals("java") return, and did "Java" change?
("Java".toLowerCase().equals("java") क्या लौटाता है, और क्या मूल "Java" बदलता है?)
(A) Returns true, and the original "Java" literal remains unaltered
(B) Returns false
(C) Returns true and mutates "Java" to "java"
(D) Compile-time error chaining methods
Correct Answer: (A)
[EN] toLowerCase() creates a new String "java" for comparison while the original "Java" remains intact.
[HI] toLowerCase() तुलना के लिए नया String "java" बनाता है जबकि मूल "Java" लिटरल पूरी तरह अपरिवर्तित रहता है।
Q16. Which statement best distinguishes final reference (final String s) from String immutability?
(final रेफरेंस (final String s) और String की अपरिवर्तनीयता (immutability) में क्या मुख्य अंतर है?)
(A) Both mean the exact same thing
(B) final makes a StringBuffer immutable too
(C) final prevents s from being reassigned to another String, whereas immutability prevents the String object's value from changing
(D) Without final, a String object becomes mutable
Correct Answer: (C)
[EN] final constrains the variable reference, whereas immutability is an intrinsic property of the String class itself.
[HI] final केवल वेरिएबल के रेफरेंस को बदलने से रोकता है, जबकि अपरिवर्तनीयता String ऑब्जेक्ट के भीतर के डेटा को बदलने से रोकती है।
Q17. Within Strings in Java: java.lang.String Class and Immutability, which string property directly maps to: "public final class in java.lang"?
(Strings in Java: java.lang.String Class and Immutability में कौन सा String Property सीधे "public final class in java.lang" से संबंधित है?)
(A) HashCode Caching
(B) Backing Storage (Java 9+)
(C) Implemented Interfaces
(D) Class Modifiers
Correct Answer: (D)
[EN] In Strings in Java: java.lang.String Class and Immutability, 'Class Modifiers' handles 'public final class in java.lang' (Cannot be inherited or subclassed in Java).
[HI] Strings in Java: java.lang.String Class and Immutability में 'Class Modifiers' का कार्य/विवरण 'public final class in java.lang' (Cannot be inherited or subclassed in Java) है।
Q18. Which option accurately describes 'Implemented Interfaces' in Strings in Java: java.lang.String Class and Immutability?
(Strings in Java: java.lang.String Class and Immutability के संदर्भ में 'Implemented Interfaces' की सही विशेषता कौन सी है?)
(A) public final class in java.lang
(B) Serializable, Comparable, CharSequence
(C) Lazy cached int hash field
(D) private final byte[] + coder byte
Correct Answer: (B)
[EN] 'Implemented Interfaces' provides 'Serializable, Comparable, CharSequence' — key point: Enables sorting, serialization, and char sequence APIs.
[HI] 'Implemented Interfaces' का मुख्य विवरण 'Serializable, Comparable, CharSequence' है (Enables sorting, serialization, and char sequence APIs)।
Q19. In Strings in Java: java.lang.String Class and Immutability, identify the correct parameter for the specification: "private final byte[] + coder byte".
(Strings in Java: java.lang.String Class and Immutability में "private final byte[] + coder byte" विवरण किस विकल्प के लिए सही है?)
(A) Implemented Interfaces
(B) Class Modifiers
(C) HashCode Caching
(D) Backing Storage (Java 9+)
Correct Answer: (D)
[EN] 'Backing Storage (Java 9+)' corresponds to 'private final byte[] + coder byte' (Compact Strings save up to 50% Heap for Latin-1).
[HI] 'Backing Storage (Java 9+)' का संबंध 'private final byte[] + coder byte' (Compact Strings save up to 50% Heap for Latin-1) से है।
Q20. Considering Strings in Java: java.lang.String Class and Immutability, what key behavior defines 'HashCode Caching'?
(Strings in Java: java.lang.String Class and Immutability में 'HashCode Caching' की मुख्य भूमिका या मान क्या है?)
(A) Lazy cached int hash field
(B) public final class in java.lang
(C) private final byte[] + coder byte
(D) Serializable, Comparable, CharSequence
Correct Answer: (A)
[EN] 'HashCode Caching' represents 'Lazy cached int hash field' (Eliminates repeated hashing when used as HashMap key).
[HI] 'HashCode Caching' का अर्थ/मान 'Lazy cached int hash field' है (Eliminates repeated hashing when used as HashMap key)।
Strings in Java: java.lang.String Class and Immutability — Exam FAQs
Q1: Can reflection break String immutability in Java?
क्या जावा में रिफ्लेक्शन (Reflection) का उपयोग करके String की अपरिवर्तनीयता को तोड़ा जा सकता है?
[EN] Older JDKs allowed setAccessible(true) on the internal char[]/byte[], though doing so caused severe pool corruption; Java 16+ strong encapsulation blocks deep reflection into java.base internals by default.
[HI] पुराने JDK में setAccessible(true) से आंतरिक एरे बदला जा सकता था जिससे पूल डेटा खराब हो जाता था; जावा 16+ में मजबूत एनकैप्सुलेशन इसे डिफ़ॉल्ट रूप से ब्लॉक करता है।
Q2: Why wasn't String made mutable like StringBuffer from the start?
String को शुरुआत से ही StringBuffer की तरह परिवर्तनीय क्यों नहीं बनाया गया?
[EN] Immutable Strings guarantee safe sharing in the String Constant Pool, prevent security attacks on classloaders/URLs, and eliminate defensive copying whenever Strings are passed across APIs.
[HI] अपरिवर्तनीय String पूल शेयरिंग, क्लासलोडर/URL की सुरक्षा और बिना डिफेंसिव कॉपी के सुरक्षित API पासिंग सुनिश्चित करती है।
Q3: How does Java 9 Compact Strings detect whether to store Latin-1 or UTF-16?
जावा 9 कॉम्पैक्ट स्ट्रिंग्स यह कैसे पहचानता है कि डेटा को Latin-1 में रखना है या UTF-16 में?
[EN] At String construction, if every character fits within 0..255 (ISO-8859-1), the JVM compresses it to 1 byte per char (coder = 0); otherwise, it stores 2 bytes per char in UTF-16 (coder = 1).
[HI] निर्माण के समय यदि सभी कैरेक्टर 0..255 (ISO-8859-1) रेंज में हों तो JVM प्रति कैरेक्टर 1 बाइट (coder = 0) उपयोग करता है, अन्यथा 2 बाइट UTF-16 (coder = 1) चुनता है।
Post a Comment
Post a Comment