Wie konvertiere ich ein Zeichen in einen String?

Ich habe eine charund ich brauche eine String. Wie konvertiere ich von einem zum anderen?

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

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

String s = "" + 's';

Dies führt jedoch zu:

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

Dies ist weniger effizient, da das StringBuildervon einem char[](überbelegt von StringBuilder()bis 16) unterstützt wird, nur damit dieses Array vom Ergebnis defensiv kopiert wird String.

String.valueOf(char)"Kommt in die Hintertür", indem Sie das charArray in ein Array mit einem Element einschließen und an den privaten Konstruktor des Pakets übergeben String(char[], boolean), wodurch die Array-Kopie vermieden wird.

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

// #5
   // Although this method seems very simple, 
   // this is less efficient because the concatenation
   // expands to new StringBuilder().append(x).append("").toString();
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 auf new String(char[] value), wodurch wiederum das valuechar-Array festgelegt wird.

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

String.valueOf(char value)Ruft andererseits den folgenden privaten Paketkonstruktor auf.

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

Der Quellcode von String.javain Java 8 Quellcode

Daher String.valueOf(char)scheint es sowohl hinsichtlich des Speichers als auch der Geschwindigkeit die effizienteste Methode für die Konvertierung in charzu sein String.

1. So konvertieren Sie primitive Zeichen in Java in String
2. So konvertieren Sie Char in Java mit Beispiel in String

Im Folgenden finden Sie verschiedene Möglichkeiten zur Konvertierung in Zeichenfolge in Zeichenfolge (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

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

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

Verwenden Sie eine der folgenden Methoden:

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

Wie @WarFox sagte, gibt es 6 Methoden, um char in string zu konvertieren. Die schnellste wäre jedoch die Verkettung, obwohl die obigen Antworten besagen, dass dies der Fall ist String.valueOf. 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 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 können, wäre der schnellste c + ""oder "" + c;

VM version: JDK 1.8.0_131, VM 25.131-b11

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

Versuchen Sie dies: Character.toString(aChar)oder nur das:aChar + ""

Wir haben verschiedene Möglichkeiten , zu konvertieren ein charzu String. Eine Möglichkeit besteht darin, die statische Methode toString()in der CharacterKlasse zu verwenden:

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

Tatsächlich verwendet diese toStringMethode intern eine valueOfMethode aus einer StringKlasse, die ein char-Array verwendet:

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

Der zweite Weg ist also, dies direkt zu verwenden:

String str2 = String.valueOf(ch);

Diese valueOfMethode in der StringKlasse verwendet das char-Array:

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

Die dritte Möglichkeit besteht darin, ein anonymes Array zu verwenden, um ein einzelnes Zeichen zu verpacken und es dann an den StringKonstruktor 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 eine appendMethode aus der StringBuilderKlasse verwenden, die tatsächlich bevorzugt wird, wenn wir eine Verkettung in einer Schleife durchführen.

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

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 umgesetzt

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