Discussion :

[neljaouh]

Bonjour,

Je veux enlever les espaces "blanc" dans du String " -12.121 74.060 5", mon code est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
package vue;
 
public class WindowsMain {
 
 
	public static void main(String[] args) {
 
 
    	String line = "    -12.121     74.060   5";
 
		String[] stab = line.split(" [ \\s]+");
 
		System.out.println("Taille :" + stab.length);
	    for (int x=0; x<stab.length; x++)
	         System.out.println("|"+stab[x]+"|");
 
 
	}
}

Output :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
Taille :4
||
|-12.121|
|74.060|
|5|

Comment faire pour ne plus avoir le premier espace et n'avoir que les nombres ? c'est quoi la regex expression qui me permettras cela ?

[Pill_S]

pas besoin de changer de regexp, je pense qu'il suffit de tester chaque token pour voir s'il est vide ou non:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
String[] splits = s.split("\\s");
for(String split : splits) {
  if(!"".equals(split.tim())) {
    // faire qq chose...
  }
}

[tupac25]

Sinon tu peux faire ceici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

replaceAll(" ", "");

[thelvin]

Sinon tu peux faire ceici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

replaceAll(" ", "");

Euh...
- Si tu le fais avant le split(), ça enlève les séparateurs entre nombres.
- Si tu le fais après le split(), ça ne change rien à rien.

[neljaouh]

Oui, c'est une façon de faire, mais je dois traiter des centaines de milliers de lignes, et je pense qu'une vérification ou des pré-traitements sont un peu coûteux.

Est ce que la méthode split est plus rapide que le StringTokenizer ?

[neljaouh]

Et merci pour vos réponses !!

[floctc]

Bonjour,
pourquoi ne pas tout simplement changer de séparateur entre les nombres?
Sinon, j'utilise la méthode String.trim() pour supprimer les espaces.

[thelvin]

Oui, c'est une façon de faire, mais je dois traiter des centaines de milliers de lignes, et je pense qu'une vérification ou des pré-traitements sont un peu coûteux.

À moins de le faire sur un téléphone portable, des centaines de milliers de lignes n'est rien du tout. Ne t'occupe pas de ce genre d'optimisation, Java s'en sortira mieux que toi. Pas la peine de me croire sur parole, vérifie. La seule optimisation qui doit t'intéresser, c'est le calcul de complexité minimale.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Est ce que la méthode split est plus rapide que le StringTokenizer ?

Non... Elle fait bien plus de choses. Mais pourquoi s'embêter ?

[le y@m's]

Le plus simple me semble de tout simplement utiliser la méthode trim() avant la méthode split().
Ainsi le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
String line = "    -12.121     74.060   5";
String[] stab = line.trim().split("\\s+");
for (int x = 0; x < stab.length; x ++) {
    System.out.println("|" + stab[x] + "|");
}

Affiche

|-12.121|
|74.060|
|5|

[adiGuba]

Salut,

À moins de le faire sur un téléphone portable, des centaines de milliers de lignes n'est rien du tout.

Pas forcément... La création d'une regexp peu s'avérer couteuse.
Mais c'est facilement corrigeable après coup en cas de problème, et en effet il vaut mieux se centrer sur l'algorithme que sur l'optimisation


Sinon petite question pour neljaouh : tu veux enlever les blancs... mais pourquoi faire ?
Je veux dire quel est l'objectif exact de tout cela ?


a++

[eyquem]

Salut,

En Python il y a une méthode de chaîne join() qui fusionne plusieurs chaînes en alternance avec un séparateur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
ch = "    -12.121     74.060   5"
print '|\n|'.join(ch.split()) 
# affiche
-12.121|
|74.060|
|5

Et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
ch = "    -12.121     74.060   5"
print '|' + '|\n|'.join(ch.split()) + '|'
# affiche
|-12.121|
|74.060|
|5|

C'est court , et l'avantage est qu'il est plus rapide d'afficher la chaine
'|-12.121|\n|74.060|\n|5|'
qu'effectuer séparément l'affichage de plusieurs lignes.



J’aimerais savoir s’il existe une fonction similaire à join() en Java. Je n’ai pas trouvé dans la doc (après une recherche sommaire).

[thelvin]

Pas dans la bibliothèque de base, mais la plupart des bibliothèques de framework en proposent une, dans leurs "utilitaires String".

Ceci étant dit, ce que tu nous fais là peut se faire avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"|" + ch.trim().replaceAll("\\s+", "|\n|") + "|";

[eyquem]

Merci pour la réponse.


L’analogue de ton instruction en Python est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
import re
print '|' + re.sub('\\s+','|\n|',ch.strip()) + '|'

C’est à dire qu’on est obligé d’importer le module d’expressions régulières.

Il n’en est pas de même en Java ? replaceAll() est immédiatement disponible en tant que fonction de la bibliothèque de base ?




Mais replaceALL() et sub() ne font pas la même chose que join(): elles prennent une chaîne comme argument et renvoient une chaîne.
Tandis que join() prend une liste, et plus généralement n’importe quelle séquence de chaînes et renvoie la concaténation des élements de la séquence.

J’aimerais savoir les frameworks dans lesquels il y a des analogues de join() en Java et sous quel(s) nom(s) on les trouve.




Nota:
mon instruction Python peut aussi s’écrire
print '|\n|'.join(ch.split()).join('||')

[adiGuba]

Il n’en est pas de même en Java ? replaceAll() est immédiatement disponible en tant que fonction de la bibliothèque de base ?

Cela fait partie de l'API de base...

Mais replaceALL() et sub() ne font pas la même chose que join(): elles prennent une chaîne comme argument et renvoient une chaîne.
Tandis que join() prend une liste, et plus généralement n’importe quelle séquence de chaînes et renvoie la concaténation des élements de la séquence.

En même temps tu fais un split() suivi d'un join() pour simuler un remplacement... Donc je ne vois pas en quoi c'est gênant de faire un replaceAll(). Au contraire même...

J’aimerais savoir les frameworks dans lesquels il y a des analogues de join() en Java et sous quel(s) nom(s) on les trouve.

Aucune idée... mais bon cela peut se coder en deux deux...

a++

[eyquem]

En même temps tu fais un split() suivi d'un join() pour simuler un remplacement... Donc je ne vois pas en quoi c'est gênant de faire un replaceAll(). Au contraire même...

Tout à fait.
J’ai tendance à considérer moi aussi qu’il est plus “naturel“ de faire une transformation d’une chaîne au moyen d’une fonction replaceALL() ou sub() que de devoir d’abord découper la chaîne avec split() puis de recoller les morceaux avec join() et un séparateur comme colle.



Cependant:


1) en Python join() est disponible comme fonction built-in tandis que re.sub() nécessite une importation, même si on peut limiter cette importation à juste la fonction sub() et non pas le module en entier.

En Java, replaceAll() utilise les expressions régulières mais est built-in: cela me surprend, mais c’est bien -> on peut l’utiliser facilement, de préférence à join()

Ceci dit, que ce soit avec join() ou avec replaceAll()/sub() , on est obligé de recourir à une deuxième fonction pour obtenir les arguments conformes pour ces fonctions à partir de la chaîne de départ: split() avant join() , et trim()/strip() pour replaceAll()/sub() . L’utilisation de split() en Python n’est donc pas le point déterminant.

Pour moi le point déterminant est la réticence que j’ai à devoir importer quelque chose juste pour faire un petit truc comme ça. Si ça peut se faire facilement avec replaceAll() en Java, c’est pareil, pour moi.



2) ignorant la facilité d’utilisation de replaceAll() en Java, et étant porté à utiliser join() plutôt que re.sub() en Python, je me suis étonné de ne pas voir de réponse proposant de créer une seule chaîne à afficher plutôt que plusieurs et c’est l’occasion de me renseigner sur l’existence d’une analogue de join() en Java.

On me dit que ça existe, mais je constate que contrairement à replaceAll() , ça n’a pas l’air évident de disposer de cette fonction puisqu’elle se trouve dans certains frameworks, sans bien savoir où.

Alors que cette fonction est très intéressante.
On connaît les inconvénients posés par le fait que les chaînes sont non-mutables, ce qui est le cas aussi bien en Python qu’en Java:
quand on veut concaténer les chaînes d’une séquence S sans connaître à l’avance le nombre d’éléments de S, et par conséquent sans pouvoir écrire directement une expression finie du genre S[0] + S[1] + S[2] + S[3] + S[4] + S[5], et qu’on est donc obligé d’écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
somme = ”
for el in S:
    somme = somme + el

il y a autant d’opérations somme + el et de nouvelle instance de chaîne créées qu’il y a d’éléments dans la chaîne.

Tandis que "".join(S) concatène l’ensemble des éléments de S en une seule passe, c’est à dire que la chaîne résultat est la seule instance de chaîne construite lors du processus.

Il m’intéresse de savoir si Java dispose d’une fonction aussi performante et de la connaître précisément.



------------------------


Soit dit en passant, ma préférence pour une méthode replace() ou sub() à la place d’une méthode join() (quand c’est possible sans importation) est elle bien justifiée ?

Car je ne vois pas trop comment une replace() fait autrement que couper une chaîne en morceaux, remplacer certains morceaux par les modifications, et recoller le tout. La même chose que split() suivie de join() , quoi.




Nota: on peut aussi écrire une expression génératrice pour produire le même résultat, en Python:
print '\n'.join( mot.join('||') for mot in ch.split() )

[le y@m's]

Pour moi le point déterminant est la réticence que j’ai à devoir importer quelque chose juste pour faire un petit truc comme ça. Si ça peut se faire facilement avec replaceAll() en Java, c’est pareil, pour moi.

Pourquoi cette réticence à faire un import ? Quand il existe des choses qui simplifient le code, qui permettent de le rendre plus compréhensible pourquoi s'en priver ? En quoi un import est-il négatif ?

2) ignorant la facilité d’utilisation de replaceAll() en Java, et étant porté à utiliser join() plutôt que re.sub() en Python, je me suis étonné de ne pas voir de réponse proposant de créer une seule chaîne à afficher plutôt que plusieurs ...

Dans la majorité des cas lorsqu'on split une chaine c'est pour pouvoir traiter chaque élément un à un. Dans l'exemple de neljaouh, je pense que l'affichage ne servait qu'à illustrer le "problème" .

On connaît les inconvénients posés par le fait que les chaînes sont non-mutables, ce qui est le cas aussi bien en Python qu’en Java:
quand on veut concaténer les chaînes d’une séquence S sans connaître à l’avance le nombre d’éléments de S, et par conséquent sans pouvoir écrire directement une expression finie du genre S[0] + S[1] + S[2] + S[3] + S[4] + S[5], et qu’on est donc obligé d’écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
somme = ”
for el in S:
    somme = somme + el

il y a autant d’opérations somme + el et de nouvelle instance de chaîne créées qu’il y a d’éléments dans la chaîne.

cf StringBuilder

[adiGuba]

1) en Python join() est disponible comme fonction built-in tandis que re.sub() nécessite une importation, même si on peut limiter cette importation à juste la fonction sub() et non pas le module en entier.

Je n'ai pas critiqué cela

En fait c'est plutôt ta démarche que je critique. Plus précisément le fait de vouloir traduire "tel quel" un code Python en Java. (note que ceci n'est pas spécifique à Java mais valable pour n'importe quel langage).


En fait plutôt que de te dire : en Python je fait "ceci" : comment faire la même chose en Java ?
Tu devrais plutôt te poser la question suivante : Comment faire "cela" en Java ?


Une solution dans un langage n'est pas forcément adapté à un autre langage

On me dit que ça existe, mais je constate que contrairement à replaceAll() , ça n’a pas l’air évident de disposer de cette fonction puisqu’elle se trouve dans certains frameworks, sans bien savoir où.

En effet à ma connaissance il n'y a pas de tel méthode dans l'API standard.
Mais comme je l'ai dit ce n'est pas bien méchant à implémenter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
	public static String join(String separator, String... strings) {
		if (strings == null || strings.length == 0)
			return "";
 
		StringBuilder buf= new StringBuilder(strings[0]);
		for (int i = 1; i < strings.length; i++) {
			buf.append(separator).append(strings[i]);
		}
		return buf.toString();
	}

On connaît les inconvénients posés par le fait que les chaînes sont non-mutables, ce qui est le cas aussi bien en Python qu’en Java:
quand on veut concaténer les chaînes d’une séquence S sans connaître à l’avance le nombre d’éléments de S, et par conséquent sans pouvoir écrire directement une expression finie du genre S[0] + S[1] + S[2] + S[3] + S[4] + S[5], et qu’on est donc obligé d’écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
somme = ”
for el in S:
    somme = somme + el

il y a autant d’opérations somme + el et de nouvelle instance de chaîne créées qu’il y a d’éléments dans la chaîne.

En effet. C'est pourquoi on utilise en Java les classes StringBuffer/StringBuilder pour cela

Car je ne vois pas trop comment une replace() fait autrement que couper une chaîne en morceaux, remplacer certains morceaux par les modifications, et recoller le tout. La même chose que split() suivie de join() , quoi.

Ben oui... quel est le problème ?


a++

[thelvin]

[...] et c’est l’occasion de me renseigner sur l’existence d’une analogue de join() en Java.

On me dit que ça existe, mais je constate que contrairement à replaceAll() , ça n’a pas l’air évident de disposer de cette fonction puisqu’elle se trouve dans certains frameworks, sans bien savoir où.

Il n'y en a pas dans la bibliothèque de base Java, c'est tout. Au fond, on peut se demander pourquoi, mais il n'y en a pas. Peut-être parce qu'on ne sait pas trop dans quelle classe ça se mettrait, et que ça se code en 2 minutes chrono, test compris.

Du coup, les bibliothèques dites "utilitaires," que ce soit commons-lang ou Spring ou bien d'autres, reconnaissent que c'est bien pratique d'avoir quelque chose de ce genre, et en fournissent une.
Peu importe quelle bibliothèque. À partir du moment où c'est une bibliothèque qui inclut des "trucs souvent utiles", tu peux être certain qu'il y a ça dedans.

[dingoth]

La classe Splitter de Guava t'aidera bien à mon avis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
String chaine = "    -12.121     74.060   5";
Iterable<String> splitted = Splitter.on(' ').omitEmptyStrings().split(chaine);

@Eyquem:

La classe Joiner de la même bibliothèque fait... des joins relativement bien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
String[] chaines = {"a", null, "b", "c" };
String joined = Joiner.on(", ").skipNulls().join(chaines);