it-swarm.com.de

Wie konvertiere ich ein Zeichen in einen String?

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

788
Landon Kuhn

Sie können Character.toString(char) verwenden. Beachten Sie, dass diese Methode einfach einen Aufruf von String.valueOf(char) zurückgibt, was auch funktioniert.

Wie andere angemerkt haben, funktioniert die Verkettung von Zeichenfolgen auch als Verknüpfung:

String s = "" + 's';

Dies führt jedoch zu folgenden Ergebnissen:

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

dies ist weniger effizient, da StringBuilder von einem char[] (überbelegt von StringBuilder() zu 16) unterstützt wird, nur damit dieses Array defensiv von kopiert wird das resultierende String.

String.valueOf(char) "geht in die Hintertür", indem char in ein Einzelelement-Array eingeschlossen und an den privaten Paketkonstruktor String(char[], boolean) übergeben wird, wodurch die Kopie des Arrays vermieden wird.

621
Paul Bellora

Gute Frage. Ich habe Folgendes 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) zurück. So effektiv sind beide gleich.

String.valueOf(char[] value) ruft new String(char[] value) auf, wodurch wiederum das Zeichen-Array value festgelegt wird.

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

Andererseits ruft String.valueOf(char value) den folgenden privaten Paketkonstruktor auf.

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

Quellcode von String.Java in Java 8-Quellcode

Daher scheint String.valueOf(char) sowohl hinsichtlich des Speichers als auch der Geschwindigkeit die effizienteste Methode zur Umwandlung von char in String zu sein.

  1. So konvertieren Sie primitive Zeichen in Zeichenfolge in Java
  2. Konvertieren von Char in String in Java mit Example
225
WarFox

Im Folgenden finden Sie verschiedene Möglichkeiten zum Konvertieren von char c in String s (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
45
sactiw

Verwenden Sie eine der folgenden Möglichkeiten:

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

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

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

Versuchen Sie Folgendes: Character.toString(aChar) oder einfach Folgendes: aChar + ""

15
Óscar López

Wie in @WarFox angegeben, gibt es 6 Methoden, um char in string zu konvertieren. Am schnellsten geht es jedoch über die Verkettung, obwohl oben angegeben wurde, dass es sich um String.valueOf handelt. Hier ist ein Benchmark, der beweist, dass:

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

Und das Ergebnis:

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

Wie Sie sehen, wäre der schnellste c + "" oder "" + c;

VM version: JDK 1.8.0_131, VM 25.131-b11

Dieser Leistungsunterschied ist auf die Optimierung von -XX:+OptimizeStringConcat zurückzuführen. Sie können darüber lesen hier .

15

Wir haben verschiedene Möglichkeiten, ein char in String umzuwandeln. Eine Möglichkeit ist die Verwendung der statischen 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 das char-Array verwendet:

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

Also zweite Möglichkeit ist, dies direkt zu verwenden:

String str2 = String.valueOf(ch);

Diese valueOf -Methode in der String -Klasse verwendet das Zeichen-Array:

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

Die dritte Methode besteht 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, die Verkettung zu nutzen:

String str3 = "" + ch;

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

4
i_am_zero

Hier sind einige 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();
4
HyperNeutrino

Ich konvertiere Char Array in String

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

Ich habe die Vorschläge ausprobiert, sie jedoch wie folgt implementiert

editView.setFilters(new InputFilter[]{new InputFilter()
        {
            @Override
            public CharSequence filter(CharSequence source, int start, int end,
                                       Spanned dest, int dstart, int dend)
            {
                String prefix = "http://";

                //make sure our prefix is visible
                String destination = dest.toString();

                //Check If we already have our prefix - make sure it doesn't
                //get deleted
                if (destination.startsWith(prefix) && (dstart <= prefix.length() - 1))
                {
                    //Yep - our prefix gets modified - try preventing it.
                    int newEnd = (dend >= prefix.length()) ? dend : prefix.length();

                    SpannableStringBuilder builder = new SpannableStringBuilder(
                            destination.substring(dstart, newEnd));
                    builder.append(source);
                    if (source instanceof Spanned)
                    {
                        TextUtils.copySpansFrom(
                                (Spanned) source, 0, source.length(), null, builder, newEnd);
                    }

                    return builder;
                }
                else
                {
                    //Accept original replacement (by returning null)
                    return null;
                }
            }
        }});
0
zmicer