Q: Quelle est la différence entre les méthodes java.lang.String replace() et replaceAll(), à part que les dernières utilisent regex.

A: Juste la regex. Tous les deux remplacent tout :)

Http://docs.oracle.com/javase/6/docs/api/java/lang/String.html

PS:

Il y a aussi un replaceFirst() (qui prend une expression rationnelle)

La méthode replace() est surchargée pour accepter à la fois une primitive char et un CharSequence comme arguments.

Maintenant, en ce qui concerne les performances, la méthode replace() est un peu plus rapide que replaceAll() car celle-ci compile d'abord le motif regex puis correspond avant de finalement le remplacer alors que la première correspond simplement à l'argument fourni et remplace.

Puisque nous savons que la correspondance de motif regex est un peu plus complexe et par conséquent plus lente, alors préférer replace() à replaceAll() est suggéré dans la mesure du possible.

Par exemple, pour des substitutions simples comme vous l'avez mentionné, il est préférable d'utiliser:

replace('.', '\\');

Au lieu de:

replaceAll("\\.", "\\\\");

Remarque: les arguments de la méthode de conversion ci-dessus dépendent du système.

replace() et replaceAll() remplacent toutes les occurrences de la chaîne.

Exemples

Je trouve toujours des exemples utiles pour comprendre les différences.

replace()

Utiliser replace() si vous voulez juste pour remplacer certains char avec un autre char ou certains String avec un autre String (en fait CharSequence).

Exemple 1

Remplacer toutes les occurrences du caractère x avec o.

String myString = "__x___x___x_x____xx_";

char oldChar = 'x';
char newChar = 'o';

String newString = myString.replace(oldChar, newChar);
// __o___o___o_o____oo_

Exemple 2

Remplacez toutes les occurrences de la chaîne fish par sheep.

String myString = "one fish, two fish, three fish";

String target = "fish";
String replacement = "sheep";

String newString = myString.replace(target, replacement);
// one sheep, two sheep, three sheep

replaceAll()

Utilisez replaceAll() Si vous voulez utiliser un modèle d'expression régulière .

Exemple 3

Remplacez n'importe quel nombre par un x.

String myString = "__1_6____3__6_345____0";

String regex = "\\d";
String replacement = "x";

String newString = myString.replaceAll(regex, replacement); 
// __x_x____x__x_xxx____x

Exemple 4

Supprime tous les espaces.

String myString = "   Horse         Cow\n\n   \r Camel \t\t Sheep \n Goat        ";

String regex = "\\s";
String replacement = "";

String newString = myString.replaceAll(regex, replacement); 
// HorseCowCamelSheepGoat

Voir aussi

Documentation

• replace(char oldChar, char newChar)
• replace(CharSequence target, CharSequence replacement)
• replaceAll(String regex, String replacement)
• replaceFirst(String regex, String replacement)

Expressions Régulières

• Tutoriel
• Liste des modèles

String replace(char oldChar, char newChar)

Renvoie une nouvelle chaîne résultant du remplacement de toutes les occurrences d'oldChar dans cette chaîne par newChar.

String replaceAll(String regex, String replacement

Remplace chaque sous-chaîne de cette chaîne qui correspond à l'expression régulière donnée par le remplacement donné.

1. replace() et replaceAll() acceptent deux arguments et remplacent toutes les occurrences de la première sous-chaîne(premier argument) dans une chaîne par la deuxième sous-chaîne (deuxième argument).
2. replace() accepte une paire de char ou charsequence et replaceAll() accepte une paire de regex.

3. Il n'est pas vrai que replace () fonctionne plus rapidement que replaceAll () puisque les deux utilisent le même code dans son mise en œuvre

   Motif.compiler(regex).matcher(ce).replaceAll (remplacement);

Maintenant, la question est de savoir quand utiliser le remplacer et quand utiliser replaceAll(). Lorsque vous voulez remplacer une sous-chaîne par une autre sous-chaîne quel que soit son lieu d'occurrence dans la chaîne, utilisez replace(). Mais si vous avez une préférence ou une condition particulière comme remplacer uniquement les sous-chaînes au début ou à la fin d'une chaîne, utilisez replaceAll(). Voici quelques exemples pour prouver mon point:

String str = new String("==qwerty==").replaceAll("^==", "?"); \\str: "?qwerty=="
String str = new String("==qwerty==").replaceAll("==$", "?"); \\str: "==qwerty?"
String str = new String("===qwerty==").replaceAll("(=)+", "?"); \\str: "?qwerty?"

Comme mentionné dans la réponse de wickeD, avec replaceAll, la chaîne de remplacement est gérée différemment entre replace et replaceAll. Je m'attendais à ce qu'a [3] et a[4] aient la même valeur, mais ils sont différents.

public static void main(String[] args) {
    String[] a = new String[5];
    a[0] = "\\";
    a[1] = "X";
    a[2] = a[0] + a[1];
    a[3] = a[1].replaceAll("X", a[0] + "X");
    a[4] = a[1].replace("X", a[0] + "X");

    for (String s : a) {
        System.out.println(s + "\t" + s.length());
    }
}

La sortie de ceci est:

\   1
X   1
\X  2
X   1
\X  2

Ceci est différent de perl où le remplacement ne nécessite pas le niveau supplémentaire d'échappement:

#!/bin/perl
$esc = "\\";
$s = "X";

$s =~ s/X/${esc}X/;
print "$s " . length($s) . "\n";

Qui imprime \X 2

Cela peut être une nuisance, comme lorsque vous essayez d'utiliser la valeur renvoyée par Java.SQL.DatabaseMetaData.getSearchStringEscape () avec replaceAll ().

Vieux fil que je connais mais je suis un peu nouveau à Java et je découvre l'une de ses choses étranges. J'ai utilisé String.replaceAll() mais j'obtiens des résultats imprévisibles.

Quelque chose comme ça gâche la chaîne:

sUrl = sUrl.replaceAll( "./", "//").replaceAll( "//", "/");

J'ai Donc conçu cette fonction pour contourner le problème bizarre:

//String.replaceAll does not work OK, that's why this function is here
public String strReplace( String s1, String s2, String s ) 
{
    if((( s == null ) || (s.length() == 0 )) || (( s1 == null ) || (s1.length() == 0 )))
     { return s; }

   while( (s != null) && (s.indexOf( s1 ) >= 0) )
    { s = s.replace( s1, s2 ); }
  return s;
}

Ce qui vous permet de faire:

sUrl=this.strReplace("./", "//", sUrl );
sUrl=this.strReplace( "//", "/", sUrl );

Il existe deux méthodes replace() en Java, l'une d'elles prend le caractère comme premier paramètre et L'autre prend CharSequence (qui est une super Interface pour String, Stringbuffer, etc.) comme premier paramètre. Ces deux méthodes remplacent toutes les occurrences de char ou CharSequence avec la valeur que vous fournissez dans le 2ème paramètre.

La méthode ReplaceAll prend l'expression régulière comme premier paramètre, vous devez donc lui donner une expression rationnelle et le contenu correspondant sera remplacé par la chaîne que vous passez en 2ème paramètre.

Pour une différence complète entre la méthode replace () et replaceAll (), vous pouvez vous référer ici différence entre la méthode replace(), replaceAll() et replaceFirst() dans la chaîne Java

replace() la méthode n'utilise pas de motif regex alors que la méthode replaceAll() utilise un motif regex. Donc replace() fonctionne plus vite que replaceAll().

replace et replaceAll changez les string et char dans tous les mots mais replaceAll supporte regex (Expression régulière). Il y a aussi replaceFirst qui est comme replaceAll en ce sens qu'ils supportent tous les deux regex et les chaînes de changement et les caractères, la différence entre eux est que lorsque vous utilisez replaceFirst avec regex, il remplace la première regex seulement.

// Java_codes_for_more_explanation ; 

String name1 = "Omar Ahmed Hafez" ;

name1 = name1.replace("Omar", "Ahmed");

System.out.println(name1);

/////////////////////////////////////////////

String name2 = "Omar Ahmed Hafez" ;

name2 = name2.replaceAll("\\s", "-");

// The first parameter("\\W") is regex and it mean replace #ALL
// space by "-" and it change All regex in the line as its replaceALL

System.out.println(name2);

////////////////////////////////////////////

String name3 = "Omar Ahmed Hafez" ;

name3 = name3.replaceFirst ("\\s", "-");

// The first parameter("\\W") is regex and it mean replace #FIRST
// space ONLT by "-" (as //it replaceFirst so it replace the first
// regex only :)  

System.out.println(name3);

Et sortie:

Ahmed Ahmed Hafez

Omar-Ahmed-Hafez

Replace fonctionne sur le type de données char mais replaceAll fonctionne sur le type de données String et les deux remplacent toutes les occurrences du premier argument par le second argument.