Quelle est la meilleure façon de remplacer tous les caractères spéciaux par leurs noms complets dans une chaîne Java?

Une approche ici serait de maintenir un hashmap contenant tous les symboles et leurs noms de remplacement. Ensuite, effectuez une itération regex sur la chaîne d'entrée et effectuez tous les remplacements.

input:  The quick! brown #fox "jumps" over the lazy dog.
output: The quick Exclamation mark  brown  Hashtag fox  Double quote jumps Double quote  over the lazy dog Fullstop 

Cela imprime:

Map<String, String> terms = new HashMap<>();
terms.put(".", " Fullstop ");
terms.put("!", " Exclamation mark ");
terms.put("\"", " Double quote ");
terms.put("#", " Hashtag ");

String input = "The quick! brown #fox \"jumps\" over the lazy dog.";
Pattern pattern = Pattern.compile("[.!\"#]");
Matcher matcher = pattern.matcher(input);
StringBuffer buffer = new StringBuffer();
while (matcher.find()) {
    matcher.appendReplacement(buffer, terms.get(matcher.group(0)));
}
matcher.appendTail(buffer);

System.out.println("input:  " + input);
System.out.println("output: " + buffer.toString());

L'approche ci - dessus semble un peu bavard, mais en pratique toute la logique de remplacement de base se produit dans une ligne d'un while boucle. Si vous êtes sur Java 8, vous pouvez également utiliser une approche de flux Matcher , mais la logique serait plus ou moins la même.

Vous pouvez utiliser Stream :

String text= "Input: What is stack overflow?";
HashMap<String, String> map = new HashMap<String, String>(){{
    put("\\.", " Fullstop ");
    put("!", " Exclamation mark ");
    put("\"", " Double quote ");
    put("#", " Hashtag ");
    put("?", " question mark");
}};
System.out.println(
        Stream.of(text.split(""))
                .map(s -> map.getOrDefault(s,s))
                .collect(Collectors.joining())
);

Regardez les noms Unicode intégrés:

    String s = "a!\".";
    s.codePoints()
            .filter(cp -> !Character.isAlphabetic(cp))
            .forEach(cp -> System.out.println(Character.getName(cp)));

EXCLAMATION MARK
QUOTATION MARK
FULL STOP

Avec un toLowerCase / capitalize, vous pouvez obtenir un résultat fin et compact.

l'utilisation d'un IntStream permet de le faire d'un seul coup

System.out.println(
    text.codePoints().collect( StringWriter::new,
        (w, c) -> w.write( Character.isAlphabetic( c )
            ? Character.toString( c ) : '‹' + Character.getName( c ) + '›'),
        ( w1, w2 ) -> w1.write( w2.toString() ) ).toString() );

â € ¦ou adapté avec l'idée de Joop Eggen (mais en gardant le texte original)

String text= "Input: What is stack overflow?";
System.out.println(
    text.codePoints().mapToObj( c -> {
      switch( c ) {
      case '.':
        return "‹Fullstop›";
      case '!':
        return "‹Exclamation mark›";
      case '"':
        return "‹Double quote›";
      case '#':
        return "‹Hashtag›";
      case '?':
        return "‹Question mark›";
      default:
        return String.valueOf( (char)c );
      }
    } ).collect( StringWriter::new, StringWriter::write,
        ( w1, w2 ) -> w1.write( w2.toString() ) ).toString() );

obtient: Input‹COLON›‹SPACE›What‹SPACE›is‹SPACE›stack‹SPACE›overflow‹QUESTION MARK›

Vous pouvez le faire en une seule déclaration.

Vous pouvez chaîner les opérations de chaîne, c'est-à-dire que le résultat d'une opération de chaîne peut être passé à l'opération suivante en chaînant comme indiqué ci-dessous:

He asked,  Double quote What is Stackoverflow? Double quote 
How beautiful Exclamation mark 
Neither am I the God nor am I the Devil Fullstop 

Production:

public class Main {
    public static void main(String[] args) {
        String text = "He asked, \"What is Stackoverflow?\"\nHow beautiful!\nNeither am I the God nor am I the Devil.";
        
        text = text.replaceAll("\\.", " Fullstop ")
                .replaceAll("!", " Exclamation mark ")
                .replaceAll("\"", " Double quote ")
                .replaceAll("#", " Hashtag ");
        
        System.out.println(text);
    }
}