Comment convertir un char en une chaîne?


837

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


187
Voté? Pourquoi devrais-je poser une question aussi simple? Parce que Google n'a pas de résultat de recherche vraiment évident pour cette question. En mettant ceci ici, nous changerons cela.
Landon Kuhn

45
je suis entièrement d'accord avec votre opinion. J'ai voté pour éliminer le vote négatif. Je crois fermement qu'il est plus facile pour tout le monde de googler des sujets comme celui-ci. =)
prolink007

4
Votre recherche a-t-elle inclus la lecture de la documentation de la classe String?
DJClayworth

12
@DJClayworth La plupart des questions SO peuvent recevoir une réponse avec RTFM, mais ce n'est pas très utile. Pourquoi ne pas laisser les gens qui trouvent la question la voter et laisser les choses suivre leur cours?
beldaz

10
@PaulBellora Seulement que StackOverflow est devenu le premier arrêt pour la recherche. S'il y a un lien StackOverlfow dans les 10 premiers résultats de Google, je viens ici.
Martin

Réponses:


642

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.


Je pense que le raccourci se résume à:new StringBuilder("").append('s').toString();
Binkan Salaryman

@BinkanSalaryman utilisant javac 1.8.0_51-b16 puis javap pour décompiler, je vois les appels constructeur / méthode que j'ai dans la réponse. Qu'est-ce que vous utilisez?
Paul Bellora

237

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

50

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

quelqu'un a testé cela?
Lucas Noetzold

34

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

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

33

Utilisez l'un des éléments suivants:

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

17

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 .



4

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.


4

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

2

Je convertis Char Array en String

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

Cela ne fournit pas de réponse à la question. Pour critiquer ou demander des éclaircissements à un auteur, laissez un commentaire sous son article. - De l'avis
pczeus

Je convertis un tableau de caractères en chaîne @pczeus
Shiva

0

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;
                }
            }
        }});
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.