java - array - Wie konvertiert man ein Zeichen in einen String?




string to char matlab (8)

Ich habe einen char und ich brauche einen String . Wie konvertiere ich von einem zum anderen?


Gute Frage. Ich habe die folgenden fünf 6 Methoden, um es zu tun.

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});

Hinweis: Character.toString(char) gibt String.valueOf(char) . So effektiv sind beide gleich.

String.valueOf(char[] value) ruft einen new String(char[] value) String.valueOf(char[] value) new String(char[] value) , der wiederum den value char-Array festlegt.

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

Auf der anderen Seite String.valueOf(char value) den folgenden privaten String.valueOf(char value) auf .

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

Quelltext von String.java in Java 8 Quellcode

Daher scheint String.valueOf(char) die effizienteste Methode zu sein, um char und String Speicher und Geschwindigkeit umzuwandeln.

  1. Wie man ein primitives Zeichen in Java in String konvertiert
  2. So konvertieren Sie Char in Java mit Beispiel

Hier sind ein paar Methoden, in keiner bestimmten Reihenfolge:

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();

Im Folgenden finden Sie verschiedene Möglichkeiten zum Konvertieren in Zeichenfolgen in Zeichenfolgen (in absteigender Reihenfolge von Geschwindigkeit und Effizienz).

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

Sie können Character.toString(char) . Beachten Sie, dass diese Methode einfach einen Aufruf an String.valueOf(char) , was ebenfalls funktioniert.

Wie bereits erwähnt, funktioniert die Verkettung von Strings auch als Abkürzung:

String s = "" + 's';

Aber das kompiliert zu:

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

StringBuilder ist weniger effizient, da der StringBuilder mit einem char[] (von StringBuilder() bis 16 ) StringBuilder() , nur damit das Array defensiv vom resultierenden String kopiert wird.

String.valueOf(char) " String.valueOf(char) in die Hintertür", indem das char in ein Array mit einem einzelnen Element eingeschlossen und an den privaten Konstruktor String(char[], boolean) , wodurch die Array-Kopie vermieden wird.


Verwenden Sie die Character.toString() -Methode wie folgt:

char mChar = 'l';
String s = Character.toString(mChar);

Verwenden Sie eine der folgenden Möglichkeiten:

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

Wir haben verschiedene Möglichkeiten, um ein char in String zu konvertieren. Eine Möglichkeit besteht darin, die statische Methode toString() in der Klasse Character :

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

Tatsächlich verwendet diese toString Methode intern die valueOf Methode aus der String Klasse, die char-Array verwendet:

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

Der zweite Weg ist das direkt zu benutzen:

String str2 = String.valueOf(ch);

Diese valueOf Methode in der String Klasse verwendet char-Array:

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

Der dritte Weg besteht also darin, ein anonymes Array zu verwenden, um ein einzelnes Zeichen zu umbrechen und es dann an den String Konstruktor zu übergeben:

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

Der vierte Weg besteht darin, eine Verkettung zu verwenden:

String str3 = "" + ch;

Dies wird tatsächlich die append Methode aus der StringBuilder Klasse verwenden, die eigentlich bevorzugt wird, wenn wir eine Verkettung in einer Schleife durchführen.


Ich konvertiere Char Array in String

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




type-conversion