java एक char को स्ट्रिंग में कैसे परिवर्तित करें?




string type-conversion (9)

मेरे पास एक char और मुझे String ज़रूरत है। मैं एक से दूसरे में कैसे परिवर्तित करूं?


अच्छा प्रश्न। मुझे इसे करने के लिए निम्नलिखित पांच विधियों में से एक है।

1. String stringValueOf = String.valueOf('c'); // most efficient

2. String stringValueOfCharArray = String.valueOf(new char[]{x});

3. String characterToString = Character.toString('c');

4. String characterObjectToString = new Character('c').toString();

   // Although this method seems very simple, 
   // this is less efficient because the concatenation
   // expands to new StringBuilder().append(x).append("").toString();
5. String concatBlankString = 'c' + "";

6. String fromCharArray = new String(new char[]{x});

नोट: Character.toString(char) String.valueOf(char) । तो प्रभावी रूप से दोनों एक ही हैं।

String.valueOf(char[] value) new String(char[] value) String.valueOf(char[] value) आमंत्रित करता है, जो बदले में value चार सरणी सेट करता है।

public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

दूसरी तरफ String.valueOf(char value) निम्न पैकेज निजी कन्स्ट्रक्टर को आमंत्रित करता है

String(char[] value, boolean share) {
    // assert share : "unshared not supported";
    this.value = value;
}

जावा 8 स्रोत कोड में String.java से स्रोत कोड

इसलिए String.valueOf(char) char से String को परिवर्तित करने के लिए स्मृति और गति दोनों के संदर्भ में, सबसे प्रभावी विधि प्रतीत होता है।

  1. जावा में आदिम चार से स्ट्रिंग को कैसे परिवर्तित करें
  2. उदाहरण के साथ जावा में चार से स्ट्रिंग को कैसे परिवर्तित करें

चार सी से स्ट्रिंग एस में परिवर्तित करने के विभिन्न तरीके नीचे दिए गए हैं (गति और दक्षता के घटते क्रम में)

char c = 'a';
String s = String.valueOf(c);             // fastest + memory efficient
String s = Character.toString(c);
String s = new String(new char[]{c});
String s = String.valueOf(new char[]{c});
String s = new Character(c).toString();
String s = "" + c;                        // slowest + memory inefficient

जैसा कि @ वार्फफ़ॉक्स ने कहा - चार को स्ट्रिंग में कनवर्ट करने के लिए 6 तरीके हैं। हालांकि, सबसे तेज़ एक उपरोक्त उत्तरों के बावजूद होगा, यह बताते हुए कि यह String.valueOf है String.valueOf । यहां बेंचमार्क है जो साबित करता है कि:

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, batchSize = 1000, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1, batchSize = 1000, timeUnit = TimeUnit.SECONDS)
public class CharToStringConversion {

    private char c = 'c';

    @Benchmark
    public String stringValueOf() {
        return String.valueOf(c);
    }

    @Benchmark
    public String stringValueOfCharArray() {
        return String.valueOf(new char[]{c});
    }

    @Benchmark
    public String characterToString() {
        return Character.toString(c);
    }

    @Benchmark
    public String characterObjectToString() {
        return new Character(c).toString();
    }

    @Benchmark
    public String concatBlankStringPre() {
        return c + "";
    }

    @Benchmark
    public String concatBlankStringPost() {
        return "" + c;
    }

    @Benchmark
    public String fromCharArray() {
        return new String(new char[]{c});
    }
}

और परिणाम:

Benchmark                                        Mode  Cnt       Score      Error  Units
CharToStringConversion.characterObjectToString  thrpt   10   82132.021 ± 6841.497  ops/s
CharToStringConversion.characterToString        thrpt   10  118232.069 ± 8242.847  ops/s
CharToStringConversion.concatBlankStringPost    thrpt   10  136960.733 ± 9779.938  ops/s
CharToStringConversion.concatBlankStringPre     thrpt   10  137244.446 ± 9113.373  ops/s
CharToStringConversion.fromCharArray            thrpt   10   85464.842 ± 3127.211  ops/s
CharToStringConversion.stringValueOf            thrpt   10  119281.976 ± 7053.832  ops/s
CharToStringConversion.stringValueOfCharArray   thrpt   10   86563.837 ± 6436.527  ops/s

जैसा कि आप देख सकते हैं, सबसे तेज़ एक c + "" या "" + c ;

VM version: JDK 1.8.0_131, VM 25.131-b11

यह प्रदर्शन अंतर -XX:+OptimizeStringConcat अनुकूलन के कारण है। आप इसके बारे में here पढ़ सकते हैं।


मैं स्ट्र ऐरे को स्ट्रिंग में परिवर्तित कर रहा हूं

Char[] CharArray={ 'A', 'B', 'C'};
String text = String.copyValueOf(CharArray);

हमारे पास char से String को कन्वर्ट करने के कई तरीके हैं। एक तरीका है Character वर्ग में स्थिर विधि toString() का उपयोग करना:

char ch = 'I'; 
String str1 = Character.toString(ch);

असल में यह toString विधि आंतरिक रूप से String क्लास से valueOf विधि का उपयोग करता है जो चार सरणी का उपयोग करता है:

public static String toString(char c) {
    return String.valueOf(c);
}

तो इसका दूसरा तरीका सीधे इसका उपयोग करना है:

String str2 = String.valueOf(ch);

String क्लास में यह valueOf विधि चार सरणी का उपयोग करती है:

public static String valueOf(char c) {
        char data[] = {c};
        return new String(data, true);
}

तो तीसरा तरीका एक अज्ञात सरणी का उपयोग एक वर्ण को लपेटने और फिर String कन्स्ट्रक्टर को पास करने के लिए करना है:

String str4 = new String(new char[]{ch});

चौथा तरीका संगतता का उपयोग करना है:

String str3 = "" + ch;

यह वास्तव में StringBuilder वर्ग से append विधि का उपयोग करेगा जो वास्तव में पसंद किया जाता है जब हम एक लूप में concatenation कर रहे हैं।


इसे आज़माएं: Character.toString(aChar) या बस यह: aChar + ""


आप Character.toString(char) उपयोग कर सकते हैं। ध्यान दें कि यह विधि बस String.valueOf(char) एक कॉल लौटाती है, जो भी काम करती है।

जैसा कि अन्य ने ध्यान दिया है, स्ट्रिंग कॉन्सटेनेशन शॉर्टकट के रूप में भी काम करता है:

String s = "" + 's';

लेकिन यह नीचे संकलित करता है:

String s = new StringBuilder().append("").append('s').toString();

जो कम कुशल है क्योंकि String को एक char[] ( String StringBuilder() से 16 तक आवंटित किया जाता है), केवल उस सरणी के परिणामस्वरूप String द्वारा प्रतिलिपि बनाई जा सकती है।

String.valueOf(char) एक सिंगल-एलिमेंट सरणी में char को लपेटकर और इसे निजी कन्स्ट्रक्टर String(char[], boolean) पैकेज में पास करके बैक दरवाजे में आता है, जो सरणी प्रतिलिपि से बचाता है।


निम्न में से किसी एक का प्रयोग करें:

String str = String.valueOf('c');
String str = Character.toString('c');
String str = 'c' + "";

यहां कुछ विधियां हैं, किसी विशेष क्रम में:

char c = 'c';

String s = Character.toString(c); // Most efficient way

s = new Character(c).toString(); // Same as above except new Character objects needs to be garbage-collected

s = c + ""; // Least efficient and most memory-inefficient, but common amongst beginners because of its simplicity

s = String.valueOf(c); // Also quite common

s = String.format("%c", c); // Not common

Formatter formatter = new Formatter();
s = formatter.format("%c", c).toString(); // Same as above
formatter.close();




type-conversion