Comment convertir un char en une chaîne?

J'en ai un charet j'en ai besoin String. Comment convertir de l'un à l'autre?

Vous pouvez utiliser Character.toString(char). Notez que cette méthode renvoie simplement un appel à String.valueOf(char), qui fonctionne également.

Comme d'autres l'ont noté, la concaténation de chaînes fonctionne également comme un raccourci:

String s = "" + 's';

Mais cela se résume à:

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

ce qui est moins efficace car le StringBuilderest soutenu par un char[](sur-alloué par StringBuilder()à 16), uniquement pour que ce tableau soit copié de manière défensive par le résultat String.

String.valueOf(char)"obtient dans la porte arrière" en enveloppant le chardans un tableau à un seul élément et en le passant au constructeur privé du package String(char[], boolean), ce qui évite la copie du tableau.

Bonne question. J'ai des cinq 6 méthodes suivantes pour le faire.

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

Remarque: Character.toString (char) renvoie String.valueOf (char) . Donc, les deux sont effectivement les mêmes.

String.valueOf(char[] value)invoque new String(char[] value), qui à son tour définit le valuetableau char.

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

D'un autre côté, String.valueOf(char value)invoque le constructeur privé du package suivant .

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

Le code source de String.javadans le code source Java 8

Par conséquent, String.valueOf(char)semble être la méthode la plus efficace, en termes de mémoire et de vitesse, pour convertir charen String.

1. Comment convertir un caractère primitif en chaîne en Java
2. Comment convertir Char en String en Java avec un exemple

Vous trouverez ci-dessous différentes façons de convertir en char c en String s (par ordre décroissant de vitesse et d'efficacité)

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

Utilisez la Character.toString()méthode comme ceci:

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

Utilisez l'un des éléments suivants:

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

Comme l'a indiqué @WarFox - il existe 6 méthodes pour convertir char en chaîne. Cependant, le plus rapide serait via la concaténation, malgré les réponses ci-dessus affirmant que c'est le cas String.valueOf. Voici un benchmark qui prouve que:

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

Et résultat:

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

Comme vous pouvez le voir, le plus rapide serait c + ""ou "" + c;

VM version: JDK 1.8.0_131, VM 25.131-b11

Cette différence de performances est due à l' -XX:+OptimizeStringConcatoptimisation. Vous pouvez en lire plus ici .

Essayez ceci: Character.toString(aChar)ou simplement ceci:aChar + ""

Nous avons différentes manières de convertir un fichier charen String. Une façon consiste à utiliser la méthode statique toString()en Characterclasse:

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

En fait, cette toStringméthode utilise en interne la valueOfméthode de la Stringclasse qui utilise le tableau char:

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

La deuxième façon consiste donc à utiliser ceci directement:

String str2 = String.valueOf(ch);

Cette valueOfméthode en Stringclasse utilise le tableau char:

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

Donc, la troisième façon consiste à utiliser un tableau anonyme pour encapsuler un seul caractère, puis le passer au Stringconstructeur:

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

La quatrième façon consiste à utiliser la concaténation:

String str3 = "" + ch;

Cela utilisera en fait la appendméthode de la StringBuilderclasse qui est en fait préférée lorsque nous faisons la concaténation en boucle.

Voici quelques méthodes, sans ordre particulier:

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

Je convertis Char Array en String

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

J'ai essayé les suggestions mais j'ai fini par les mettre en œuvre comme suit

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