Combien d'espaces Java String.trim () supprimera-t-il?
En Java, j'ai une chaîne comme celle-ci:
" content ".
String.trim() supprimera-t-il tous les espaces de ces côtés ou un seul espace sur chacun d'eux?
Tous .
Renvoie : une copie de cette chaîne avec les espaces blancs de début et de fin supprimés, ou cette chaîne si elle ne contient aucun espace.
~ Cité de Java 1.5.0 docs
(Mais pourquoi ne pas l'essayer et voir par vous-même?)
A partir du code source (décompilé):
public String trim()
{
int i = this.count;
int j = 0;
int k = this.offset;
char[] arrayOfChar = this.value;
while ((j < i) && (arrayOfChar[(k + j)] <= ' '))
++j;
while ((j < i) && (arrayOfChar[(k + i - 1)] <= ' '))
--i;
return (((j > 0) || (i < this.count)) ? substring(j, i) : this);
}
Les deux while que vous pouvez voir signifient que tous les caractères dont l'unicode est situé au-dessous de l'espace, au début et à la fin, sont supprimés.
En cas de doute, écrivez un test unitaire:
@Test
public void trimRemoveAllBlanks(){
assertThat(" content ".trim(), is("content"));
}
NB: bien sûr le test (pour JUnit + Hamcrest) n'échoue pas
Une chose à souligner, cependant, est que String.trim a une définition particulière de "espace". Il ne supprime pas les espaces Unicode, mais supprime également les caractères de contrôle ASCII que vous pouvez ne pas considérer comme des espaces.
Cette méthode peut être utilisée pour couper les espaces au début et à la fin d'une chaîne. En fait, tous les caractères de contrôle ASCII sont également supprimés.
Si possible, vous voudrez peut-être utiliser StringUtils.strip () de Commons Lang, qui traite également les espaces Unicode (et est null-safe également).
Voir API pour la classe String:
Retourne une copie de la chaîne, en omettant les espaces de début et de fin.
Les blancs des deux côtés sont supprimés:
Notez que trim() ne modifie pas l'instance de chaîne, elle retournera un nouvel objet:
String original = " content ";
String withoutWhitespace = original.trim();
// original still refers to " content "
// and withoutWhitespace refers to "content"
Basé sur le Java docs ici , le .trim() remplace le '\ u0020' qui est communément appelé un espace.
Mais notez bien que le '\ u00A0' ( nicode NO-BREAK SPACE ) est également considéré comme un espace et .trim() ne le supprimera PAS. Ceci est particulièrement courant en HTML.
Pour l'enlever, j'utilise:
tmpTrimStr = tmpTrimStr.replaceAll("\\u00A0", "");
Un exemple de ce problème a été discuté ici .
Exemple de Java trim() supprimer des espaces:
public class Test
{
public static void main(String[] args)
{
String str = "\n\t This is be trimmed.\n\n";
String newStr = str.trim(); //removes newlines, tabs and spaces.
System.out.println("old = " + str);
System.out.println("new = " + newStr);
}
}
SORTIE
old =
This is a String.
new = This is a String.
De Java docs (source de classe String),
/**
* Returns a copy of the string, with leading and trailing whitespace
* omitted.
* <p>
* If this <code>String</code> object represents an empty character
* sequence, or the first and last characters of character sequence
* represented by this <code>String</code> object both have codes
* greater than <code>'\u0020'</code> (the space character), then a
* reference to this <code>String</code> object is returned.
* <p>
* Otherwise, if there is no character with a code greater than
* <code>'\u0020'</code> in the string, then a new
* <code>String</code> object representing an empty string is created
* and returned.
* <p>
* Otherwise, let <i>k</i> be the index of the first character in the
* string whose code is greater than <code>'\u0020'</code>, and let
* <i>m</i> be the index of the last character in the string whose code
* is greater than <code>'\u0020'</code>. A new <code>String</code>
* object is created, representing the substring of this string that
* begins with the character at index <i>k</i> and ends with the
* character at index <i>m</i>-that is, the result of
* <code>this.substring(<i>k</i>, <i>m</i>+1)</code>.
* <p>
* This method may be used to trim whitespace (as defined above) from
* the beginning and end of a string.
*
* @return A copy of this string with leading and trailing white
* space removed, or this string if it has no leading or
* trailing white space.
*/
public String trim() {
int len = count;
int st = 0;
int off = offset; /* avoid getfield opcode */
char[] val = value; /* avoid getfield opcode */
while ((st < len) && (val[off + st] <= ' ')) {
st++;
}
while ((st < len) && (val[off + len - 1] <= ' ')) {
len--;
}
return ((st > 0) || (len < count)) ? substring(st, len) : this;
}
Notez qu'après avoir démarré et duré, il appelle la méthode de la sous-chaîne de la classe String.
Si votre entrée de chaîne est:
String a = " abc ";
System.out.println(a);
Oui, la sortie sera "abc"; Mais si votre entrée de chaîne est:
String b = " This is a test "
System.out.println(b);
La sortie sera This is a test Ainsi, la suppression supprime uniquement les espaces avant votre premier caractère et après votre dernier caractère de la chaîne et ignore les espaces intérieurs. Ceci est une partie de mon code qui optimise légèrement la méthode intégrée String trim en supprimant les espaces intérieurs et en supprimant les espaces avant et après votre premier et dernier caractère de la chaîne. J'espère que ça aide.
public static String trim(char [] input){
char [] output = new char [input.length];
int j=0;
int jj=0;
if(input[0] == ' ' ) {
while(input[jj] == ' ')
jj++;
}
for(int i=jj; i<input.length; i++){
if(input[i] !=' ' || ( i==(input.length-1) && input[input.length-1] == ' ')){
output[j]=input[i];
j++;
}
else if (input[i+1]!=' '){
output[j]=' ';
j++;
}
}
char [] m = new char [j];
int a=0;
for(int i=0; i<m.length; i++){
m[i]=output[a];
a++;
}
return new String (m);
}
trim() supprimera tous les blancs de début et de fin. Mais soyez conscient: votre chaîne n'est pas changée. trim() renverra une nouvelle instance de chaîne à la place.
Une chose très importante est qu’une chaîne entièrement composée d’espaces blancs renvoie une chaîne vide.
si un string sSomething = "xxxxx", où x représente des espaces blancs, sSomething.trim() renvoie une chaîne vide.
si un string sSomething = "xxAxx", où x désigne des espaces, sSomething.trim() renvoie A.
si sSomething ="xxSomethingxxxxAndSomethingxElsexxx", sSomething.trim() renvoie SomethingxxxxAndSomethingxElse, notez que le nombre de x entre les mots n'est pas modifié.
Si vous voulez une chaîne bien nette, combinez trim() avec regex comme indiqué dans cet article: Comment supprimer les espaces en double dans la chaîne à l'aide de Java? .
L'ordre n'a pas de sens pour le résultat, mais trim() first serait plus efficace. J'espère que ça aide.
Cela supprimera tous les espaces des deux côtés.
Pour ne conserver qu'une instance pour la chaîne, vous pouvez utiliser ce qui suit.
str = " Hello ";
ou
str = str.trim();
Alors la valeur de la chaîne str, sera str = "Hello"
Trim () fonctionne pour les deux côtés.
Javadoc pour String a tous les détails. Supprime les espaces blancs (espace, tabulations, etc.) des deux extrémités et renvoie une nouvelle chaîne.
String formattedStr=unformattedStr;
formattedStr=formattedStr.trim().replaceAll("\\s+", " ");
Si vous voulez vérifier ce qui va faire une méthode, vous pouvez utiliser BeanShell . C'est un langage de script conçu pour être aussi proche que possible de Java. D'une manière générale, il est interprété Java avec quelques relaxations. Une autre option de ce type est Groovy language. Ces deux langages de script fournissent une boucle pratique Read-Eval-Print connue des langages interprétés. Vous pouvez donc lancer la console et simplement taper:
" content ".trim();
Vous verrez alors "content" après avoir appuyé sur Enter (ou Ctrl+R dans la console Groovy).