Différence entre Ssortingng replace () et replaceAll ()

Quelle est la différence entre les méthodes replace() et replaceAll() java.lang.Ssortingng, si ce n’est que regex utilise plus tard? Pour des substitutions simples comme, remplacez . avec / , y a-t-il une différence?

Dans java.lang.Ssortingng , la méthode replace prend soit une paire de caractères, soit une paire de CharSequence (dont Ssortingng est une sous-classe, donc elle prendra une paire de Ssortingng). La méthode replace remplacera toutes les occurrences d’un caractère char ou CharSequence . Par contre, les deux arguments Ssortingng à replaceFirst et replaceAll sont des expressions régulières (regex). Utiliser la mauvaise fonction peut conduire à des bogues subtils.

Q: Quelle est la différence entre les méthodes java.lang.Ssortingng replace() et replaceAll() , si ce n’est que la dernière utilise regex.

A: Juste la regex. Ils remplacent tous les deux 🙂

http://docs.oracle.com/javase/6/docs/api/java/lang/Ssortingng.html

PS:

Il y a aussi un replaceFirst() (qui prend une regex)

La méthode replace() est surchargée pour accepter à la fois un caractère primitif et un caractère CharSequence comme arguments.

En ce qui concerne les performances, la méthode replace() est un peu plus rapide que replaceAll() car cette dernière comstack d’abord le modèle regex, puis établit une correspondance avant de remplacer, tandis que la première correspond simplement à l’argument fourni et remplace.

Comme nous soaps que le filtrage des expressions rationnelles est un peu plus complexe et, par conséquent, plus lent, préférer replace() replaceAll() est suggéré chaque fois que 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 replace() et replaceAll() remplacent toutes les occurrences de la chaîne.

Exemples

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

replace()

Utilisez replace() si vous voulez juste remplacer un caractère par un autre caractère ou une Ssortingng avec une autre Ssortingng (en fait CharSequence ).

Exemple 1

Remplacez toutes les occurrences du caractère x par o .

 Ssortingng mySsortingng = "__x___x___x_x____xx_"; char oldChar = 'x'; char newChar = 'o'; Ssortingng newSsortingng = mySsortingng.replace(oldChar, newChar); // __o___o___o_o____oo_ 

Exemple 2

Remplacez toutes les occurrences du fish cordes par des sheep .

 Ssortingng mySsortingng = "one fish, two fish, three fish"; Ssortingng target = "fish"; Ssortingng replacement = "sheep"; Ssortingng newSsortingng = mySsortingng.replace(target, replacement); // one sheep, two sheep, three sheep 

replaceAll()

Utilisez replaceAll() si vous souhaitez utiliser un modèle d’expression régulière .

Exemple 3

Remplacez n’importe quel nombre par un x .

 Ssortingng mySsortingng = "__1_6____3__6_345____0"; Ssortingng regex = "\\d"; Ssortingng replacement = "x"; Ssortingng newSsortingng = mySsortingng.replaceAll(regex, replacement); // __x_x____x__x_xxx____x 

Exemple 4

Supprimer tous les espaces.

 Ssortingng mySsortingng = " Horse Cow\n\n \r Camel \t\t Sheep \n Goat "; Ssortingng regex = "\\s"; Ssortingng replacement = ""; Ssortingng newSsortingng = mySsortingng.replaceAll(regex, replacement); // HorseCowCamelSheepGoat 

Voir également

Documentation

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

Expressions régulières

  • Didacticiel
  • Liste de motifs
 Ssortingng replace(char oldChar, char newChar) 

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

 Ssortingng replaceAll(Ssortingng regex, Ssortingng replacement 

Remplace chaque sous-chaîne de cette chaîne qui correspond à l’expression régulière donnée avec 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 seconde sous-chaîne (deuxième argument).
  2. replace () accepte une paire de char ou de charsequence et replaceAll () accepte une paire de regex.
  3. Il n’est pas vrai que replace () fonctionne plus vite que replaceAll () car les deux utilisent le même code dans son implémentation

    Pattern.comstack (regex) .matcher (this) .replaceAll (remplacement);

Maintenant, la question est de savoir quand utiliser replace et when use replaceAll (). Lorsque vous souhaitez remplacer une sous-chaîne par une autre sous-chaîne, quel que soit son emplacement 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:

 Ssortingng str = new Ssortingng("==qwerty==").replaceAll("^==", "?"); \\str: "?qwerty==" Ssortingng str = new Ssortingng("==qwerty==").replaceAll("==$", "?"); \\str: "==qwerty?" Ssortingng str = new Ssortingng("===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 que [3] et a [4] aient la même valeur, mais ils sont différents.

 public static void main(Ssortingng[] args) { Ssortingng[] a = new Ssortingng[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 (Ssortingng s : a) { System.out.println(s + "\t" + s.length()); } } 

Le résultat 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’évasion:

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

qui imprime \ X 2

Cela peut être très gênant, comme lorsque vous essayez d’utiliser la valeur renvoyée par java.sql.DatabaseMetaData.getSearchSsortingngEscape () avec replaceAll ().

Vieux fil que je connais mais je suis en quelque sorte nouveau sur Java et découvre une de ces choses étranges. J’ai utilisé Ssortingng.replaceAll() mais 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 étrange:

 //Ssortingng.replaceAll does not work OK, that's why this function is here public Ssortingng strReplace( Ssortingng s1, Ssortingng s2, Ssortingng 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 y a deux méthodes replace () en Java, l’une prend le caractère premier paramètre et l’autre prend le premier paramètre CharSequence (qui est super interface pour Ssortingng, Ssortingngbuffer, etc.). Ces deux méthodes remplacent toutes les occurrences de char ou de CharSequence par la valeur que vous indiquez en 2ème paramètre.

La méthode ReplaceAll prend l’expression régulière comme premier paramètre, vous devez donc lui donner un peu de Regex et le contenu correspondant sera remplacé par le Ssortingng que vous passerez en 2ème paramètre.

Pour la différence complète entre la méthode replace () et la méthode replaceAll (), vous pouvez vous référer ici à la méthode Différence entre replace (), replaceAll () et replaceFirst () dans Java Ssortingng

replace() méthode replace() n’utilise pas le modèle regex alors que la méthode replaceAll() utilise le modèle regex. Donc, replace() est plus rapide que replaceAll() .

replace et replace changer la ssortingng et le ssortingng dans tous les mots, mais replaceAll prend en charge l’expression régulière (expression régulière). Il y a aussi replaceFirst qui est comme replaceAll en ce sens qu’elles supportent toutes les deux regex et que les deux changent de chaîne et de caractère, la différence étant que lorsque vous utilisez replaceFirst avec regex, elle remplace UNIQUEMENT la première regex.

 // Java_codes_for_more_explanation ; Ssortingng name1 = "Omar Ahmed Hafez" ; name1 = name1.replace("Omar", "Ahmed"); System.out.println(name1); ///////////////////////////////////////////// Ssortingng 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); //////////////////////////////////////////// Ssortingng 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 

Remplace les travaux sur le type de données char mais replaceAll fonctionne sur le type de données Ssortingng et remplace tous les occurrences du premier argument par le second.