web-dev-qa-db-fra.com

Comment convertir un caractère en chaîne?

J'ai un char et j'ai besoin d'un String. Comment puis-je convertir de l'un à l'autre?

javastringchartype-conversion
788
Landon Kuhn

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 compile jusqu'à:

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

ce qui est moins efficace parce que la StringBuilder est soutenue 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) "se met au fond" en encapsulant le char dans un tableau à élément unique et en le transmettant au constructeur privé du package String(char[], boolean) , ce qui évite la copie du tableau.

621
Paul Bellora

Bonne question. J'ai du suivant cinq 6 méthodes 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();

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

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

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

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

D'autre part, String.valueOf(char value) appelle le constructeur privé de package suivant . 

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

Code source de String.Java dans 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 char en String.

  1. Comment convertir un caractère primitif en chaîne en Java
  2. Comment convertir un caractère en chaîne dans Java avec Exemple
225
WarFox

Vous trouverez ci-dessous différentes façons de convertir des caractères c à des chaînes (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
45
sactiw

Utilisez l'un des éléments suivants:

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

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

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

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

15
Óscar López

Comme @WarFox l'a déclaré - il existe 6 méthodes pour convertir char en chaîne. Cependant, le plus rapide serait via concaténation, malgré les réponses ci-dessus affirmant qu'il s'agit de String.valueOf. Voici un repère 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 constater, le plus rapide serait c + "" ou "" + c;

VM version: JDK 1.8.0_131, VM 25.131-b11

Cette différence de performance est due à l'optimisation -XX:+OptimizeStringConcat. Vous pouvez lire à ce sujet ici .

15
Dmitriy Dumanskiy

Nous avons plusieurs façons de convertir une char en String. Une méthode consiste à utiliser la méthode statique toString() dans Character classe:

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

En fait, cette méthode toString utilise en interne la méthode valueOf de la classe String qui utilise le tableau de caractères:

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

Donc la seconde méthode consiste à utiliser ceci directement:

String str2 = String.valueOf(ch);

Cette méthode valueOf dans la classe String utilise le tableau de caractères:

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

Le troisième moyen consiste donc à utiliser un tableau anonyme pour envelopper un seul caractère, puis en le passant au constructeur String:

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

La quatrième méthode consiste à utiliser la concaténation:

String str3 = "" + ch;

Cela utilisera en fait la méthode append de la classe StringBuilder qui est réellement préférée lorsque nous effectuons la concaténation dans une boucle.

4
i_am_zero

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

Je convertis Char Array en String

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

J'ai essayé les suggestions, mais j'ai fini par l'appliquer 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;
                }
            }
        }});
0
zmicer