Le moyen le plus efficace de rendre le premier caractère d'une chaîne en minuscule?

Quelle est la manière la plus efficace de créer le premier caractère d'une Stringminuscule?

Je peux penser à plusieurs façons de procéder:

Utilisation charAt()avecsubstring()

String input   = "SomeInputString";
String output  = Character.toLowerCase(input.charAt(0)) +
                   (input.length() > 1 ? input.substring(1) : "");

Ou en utilisant un chartableau

 String input  = "SomeInputString";
 char c[]      = input.toCharArray();
 c[0]          = Character.toLowerCase(c[0]);
 String output = new String(c);

Je suis sûr qu'il existe de nombreux autres moyens pour y parvenir. Que recommandez-vous?

J'ai testé les approches prometteuses en utilisant JMH . Code de référence complet .

Hypothèse lors des tests (pour éviter de vérifier les cas d'angle à chaque fois): la longueur de la chaîne d'entrée est toujours supérieure à 1.

Résultats

Benchmark           Mode  Cnt         Score        Error  Units
MyBenchmark.test1  thrpt   20  10463220.493 ± 288805.068  ops/s
MyBenchmark.test2  thrpt   20  14730158.709 ± 530444.444  ops/s
MyBenchmark.test3  thrpt   20  16079551.751 ±  56884.357  ops/s
MyBenchmark.test4  thrpt   20   9762578.446 ± 584316.582  ops/s
MyBenchmark.test5  thrpt   20   6093216.066 ± 180062.872  ops/s
MyBenchmark.test6  thrpt   20   2104102.578 ±  18705.805  ops/s

Les scores sont des opérations par seconde, plus il y en a, mieux c'est.

Des tests

1. test1 était d'abord l'approche d'Andy et Hllink:

   string = Character.toLowerCase(string.charAt(0)) + string.substring(1);

2. test2était la deuxième approche d'Andy. Il est également Introspector.decapitalize()suggéré par Daniel, mais sans deux ifdéclarations. First a ifété supprimé en raison de l'hypothèse de test. Le second a été supprimé, car il enfreignait l'exactitude (c'est-à-dire que l'entrée "HI"reviendrait "HI"). C'était presque le plus rapide.

   char c[] = string.toCharArray();
   c[0] = Character.toLowerCase(c[0]);
   string = new String(c);
   

3. test3était une modification de test2, mais au lieu de Character.toLowerCase(), j'ajoutais 32, qui fonctionne correctement si et seulement si la chaîne est en ASCII. C'était le plus rapide. c[0] |= ' 'du commentaire de Mike a donné la même performance.

   char c[] = string.toCharArray();
   c[0] += 32;
   string = new String(c);
   

4. test4utilisé StringBuilder.

   StringBuilder sb = new StringBuilder(string);
   sb.setCharAt(0, Character.toLowerCase(sb.charAt(0)));
   string = sb.toString();
   

5. test5utilisé deux substring()appels.

   string = string.substring(0, 1).toLowerCase() + string.substring(1);

6. test6utilise la réflexion pour changer char value[]directement dans String. C'était le plus lent.

   try {
       Field field = String.class.getDeclaredField("value");
       field.setAccessible(true);
       char[] value = (char[]) field.get(string);
       value[0] = Character.toLowerCase(value[0]);
   } catch (IllegalAccessException e) {
       e.printStackTrace();
   } catch (NoSuchFieldException e) {
       e.printStackTrace();
   }
   

Conclusions

Si la longueur de la chaîne est toujours supérieure à 0, utilisez test2.

Sinon, nous devons vérifier les cas d'angle:

public static String decapitalize(String string) {
    if (string == null || string.length() == 0) {
        return string;
    }

    char c[] = string.toCharArray();
    c[0] = Character.toLowerCase(c[0]);

    return new String(c);
}

Si vous êtes sûr que votre texte sera toujours en ASCII et que vous recherchez des performances extrêmes car vous avez trouvé ce code dans le goulot d'étranglement, utilisez test3.

Je suis tombé sur une bonne alternative si vous ne souhaitez pas utiliser une bibliothèque tierce:

import java.beans.Introspector;

Assert.assertEquals("someInputString", Introspector.decapitalize("SomeInputString"));

Quand il s'agit de manipulation de chaînes, jetez un œil à Jakarta Commons Lang StringUtils .

Si vous souhaitez utiliser Apache Commons, vous pouvez effectuer les opérations suivantes:

import org.apache.commons.lang3.text.WordUtils;
[...] 
String s = "SomeString"; 
String firstLower = WordUtils.uncapitalize(s);

Résultat: someString

Malgré une approche orientée char, je suggérerais une solution orientée String. String.toLowerCase est spécifique aux paramètres régionaux, je prendrais donc en compte ce problème. String.toLowerCaseest de préférer les minuscules selon Character.toLowerCase . De plus, une solution orientée char n'est pas entièrement compatible avec unicode, car Character.toLowerCase ne peut pas gérer les caractères supplémentaires.

public static final String uncapitalize(final String originalStr,
            final Locale locale) {
        final int splitIndex = 1;
        final String result;
        if (originalStr.isEmpty()) {
        result = originalStr;
        } else {
        final String first = originalStr.substring(0, splitIndex).toLowerCase(
                locale);
        final String rest = originalStr.substring(splitIndex);
        final StringBuilder uncapStr = new StringBuilder(first).append(rest);
        result = uncapStr.toString();
        }
        return result;
    }

MISE À JOUR: À titre d'exemple à quel point le paramètre régional est important, laissez-nous en minuscules Ien turc et en allemand:

System.out.println(uncapitalize("I", new Locale("TR","tr")));
System.out.println(uncapitalize("I", new Locale("DE","de")));

produira deux résultats différents:

je

je

Les chaînes en Java sont immuables, donc dans les deux cas, une nouvelle chaîne sera créée.

Votre premier exemple sera probablement un peu plus efficace car il suffit de créer une nouvelle chaîne et non un tableau de caractères temporaire.

Une méthode statique très courte et simple pour archiver ce que vous voulez:

public static String decapitalizeString(String string) {
    return string == null || string.isEmpty() ? "" : Character.toLowerCase(string.charAt(0)) + string.substring(1);
}

Si ce dont vous avez besoin est très simple (par exemple, noms de classe java, pas de paramètres régionaux), vous pouvez également utiliser la classe CaseFormat dans la bibliothèque Google Guava .

String converted = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, "FooBar");
assertEquals("fooBar", converted);

Ou vous pouvez préparer et réutiliser un objet convertisseur, ce qui pourrait être plus efficace.

Converter<String, String> converter=
    CaseFormat.UPPER_CAMEL.converterTo(CaseFormat.LOWER_CAMEL);

assertEquals("fooBar", converter.convert("FooBar"));

Pour mieux comprendre la philosophie de la manipulation des chaînes de Google Guava, consultez cette page wiki .

String testString = "SomeInputString";
String firstLetter = testString.substring(0,1).toLowerCase();
String restLetters = testString.substring(1);
String resultString = firstLetter + restLetters;

Je n'ai rencontré cela qu'aujourd'hui. J'ai essayé de le faire moi-même de la manière la plus piétonne. Cela a pris une ligne, bien que longue. Voici

String str = "TaxoRank"; 

System.out.println(" Before str = " + str); 

str = str.replaceFirst(str.substring(0,1), str.substring(0,1).toLowerCase());

System.out.println(" After str = " + str);

Donne:

Avant str = TaxoRanks

Après str = taxoRanks

val str = "Hello"
s"${str.head.toLower}${str.tail}"

Résultat:

res4: String = hello