Problème de remplacement de caractères

Version imprimable

1 pièce(s) jointe(s)

Bonsoir a tous.

je dispose d'un fichier texte comme suit Pièce jointe 514629

mon but (car le fichier original peut contenir plus de ligne que cela vous l'aurais compris) c'est remplacer W84 par WGE ?

j'arrive pour le moment, grâce au code suivant, a lire ce texte (et oui je suis bien au début de ma création de mon projet).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 package converter; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import static java.lang.System.in; class converter { public static void main(String args[]) { BufferedReader reader = null; int nbLigne = 0; try { reader = new BufferedReader(new FileReader("C:\\Users\\moi\\Desktop\\montest.txt")); String line = reader.readLine(); while (line!=null) { System.out.println(line); line = reader.readLine(); } } catch (IOException ioe) { System.out.println(ioe.getMessage()); } finally { try { if (reader!=null) reader.close(); } catch (IOException e) {} } if (nbLigne >1) { // tu es dans un fichier ligne a ligne } else { // tu es en streaming ou dans un fichier ligne a ligne qui ne contient qu'une seule ligne } } }
Mon problème est que je me demande a quel endroit je peux/dois mettre ma commande de remplacement (qui ne marche pas au passage) et si je dois faire une boucle.
Code:

1 2 3 String remplace = reader.replace ( "W84", "WGE" ); System.out.println(remplace);
je pensais aussi d'une autre manière le faire sous la forme de condition du genre
Si la ligne commence par GEODATUM et que la valeur apres le / est "W84" alors remplace par WGE sinon line++ (sous entendu passe a la ligne) mais j'ai des doutes sur la syntaxe car trop débutant et sur plein de sujet a la fois ...

avez vous un peu de temps pour m'aider s'il vous plait ?

merci a vous par avance.

Salut,

Tout d'abord sache qu'on peut lire ligne à ligne à fichier de manière plus simple et concise :

Code:

1
2
3
4
5
6
7
try {
    for(String line : Files.readAllLines(Paths.get("C:\\Users\\moi\\Desktop\\montest.txt"))) {
        // traitement
    }
} catch (IOException e) {
    e.printStackTrace();
}

ou encore

Code:

1
2
3
4
5
6
7
8
9
try {
    Files.lines(Paths.get("C:\\Users\\moi\\Desktop\\montest.txt")).forEach(
        line-> {
            // traitement
        }
    );
} catch (IOException e) {
    e.printStackTrace();
}

Ensuite ton code de remplacement doit s'appliquer à chaque ligne

Code:

1
2
String remplace = line.replace ( "W84", "WGE" );
System.out.println(remplace);

Donc dans ton code :

Code:

1
2
3
4
5
6
7
8
9
10
while (line!=null) {
 
    System.out.println(line);
 
    String remplace = line.replace ( "W84", "WGE" );
    System.out.println(remplace);
 
    line = reader.readLine();
 
}

Citation:

Envoyé par K2carca

Si la ligne commence par GEODATUM et que la valeur apres le / est "W84" alors remplace par WGE sinon line++ (sous entendu passe a la ligne) mais j'ai des doutes sur la syntaxe car trop débutant et sur plein de sujet a la fois ...

pour le "la ligne commence par"

Code:

1
2
3
4
5
6
7
8
9
10
11
12
while (line!=null) {
 
    System.out.println(line);
 
    if ( line.startsWith( "GEODATUM" ) {
        String remplace = line.replace ( "W84", "WGE" );
        System.out.println(remplace);
    }
 
    line = reader.readLine();
 
}

En revanche "la valeur apres le /", je ne sais pas de quel / tu parles...
[edit]oups j'avais pas vu que tu avais joint ton fichier
donc on peut faire tout simplement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
while (line!=null) {
 
    System.out.println(line);
 
    if ( line.startsWith( "GEODATUM/W84" ) {
        String remplace = line.replace ( "GEODATUM/W84", "GEODATUM/WGE" );
        System.out.println(remplace);
    }
 
    line = reader.readLine();
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
while (line!=null) {
 
    System.out.println(line);
 
    if ( line.startsWith( "GEODATUM/W84" ) {
        String remplace = "GEODATUM/WGE" + line.substring("GEODATUM/W84".length());
        System.out.println(remplace);
    }
 
    line = reader.readLine();
 
}

merci Joel.drigo pour cette réponse.

j'ai bien j'ai en effet essayé vos solution et elle marchent cependant elle n'efface pas la vieille valeurs pour la remplacer par la nouvelle mais ecris une nouvelle ligne.

texte avant
Code:

1 2 3 4 5 6 7 8 9 10 EXE/AIP 1// GEODATUM/W84// -----------------------------------------------------// EXE/AIP 2// GEODATUM/W84// -----------------------------------------------------// EXE/AIP 3// GEODATUM/W84// -----------------------------------------------------//
texte apres vos modifs
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 EXE/AIP 1// GEODATUM/W84// GEODATUM/WGE// -----------------------------------------------------// EXE/AIP 2// GEODATUM/W84// GEODATUM/WGE// -----------------------------------------------------// EXE/AIP 3// GEODATUM/W84// GEODATUM/WGE// -----------------------------------------------------//

Oui, enfin, tu n'as jamais dit que tu voulais modifier le fichier.

Pour modifier le fichier, il faut écrire les lignes modifiées dans un fichier (le même ou un autre).

Par exemple, tu peux faire (ici j'écris les lignes dans un nouveau fichier pour éviter de remplacer l'ancien) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try {
    List<String> lines = Files.readAllLines(Paths.get("C:\\Users\\moi\\Desktop\\montest.txt")); // lecture du fichier ligne à ligne
    List<String> newLines = lines.stream() // parcours de toutes les lignes	    		                     
                                 .map(line-> {
                                     if ( line.startsWith( "GEODATUM/W84") ) { // si la ligne commence par GEODATUM/W84
                                         return "GEODATUM/WGE" + line.substring("GEODATUM/W84".length()); // alors je remplace GEODATUM/W84 par GEODATUM/WGE et je retourne la nouvelle ligne modifiée
                                     }
                                     return line; // sinon je retourne la ligne sans la modifier
                                 }) // remplacement de GEODATUM/W84 par GEODATUM/WGE
                                 .collect(Collectors.toList()); // récupération des résultats dans une liste
    Files.write(Paths.get("C:\\Users\\moi\\Desktop\\montest_new.txt"), newLines); // écriture des nouvelles lignes dans un nouveau fichier
} catch (IOException e) {
    e.printStackTrace();
}

04/11/2019, 07h52
K2carca

merci joel.drigo j'apprends une nouvelle fonction grace a vous.
Petite derniere question svp;

en fait la je connais "l'erreur" (ici W84 doit etre remplace par WGE) mais nous somme d'accord que si a la place de W84 il n'y rien rien (soit - ) ca ne marche pas.
de fait suriez vous s'il existe une class qui permet de lister la structure d'une ligne
je demande car je peux aussi avoir d'autre ligne lesquelles doivent repondre a une certaine structure (MSGID/-/-/INI/UNIDENTIFIED//) et dans lesquelle si elle ne corresponde pas je souhaite appliquer une modification tout en sachant gardant des valeurs qui peuvent s'y trouver. ?

Salut,

La structure d'une ligne c'est une définition qui t'est propre (il y a une infinité de structure possible pour un texte). Mais on peut analyser une chaîne de caractères.

On peut analyser un String par différentes méthodes de la classe String, comme startsWith() déjà utilisée). Il y a notamment split() qui permet de découper une String en plusieurs String que tu peux analyser séparément.
Par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
String[] splitted = line.split("/"); // découper par /
if ( splitted.length>1 ) {
switch(splitted[0]) {
case "GEODATUM":
    // la chaîne commence par GEODATUM
    switch(splitted[1]) {
    case "WGE":
          // la chaîne commence par GEODATUM/WGE
          break;
    case "W84":
          // la chaîne commence par GEODATUM/W84
          break;
    default:
          // autres cas
    break;
default:
    // autre cas : ne commence pas par GEODATUM
}

Il y a contains, matches, etc...

On peut transformer le tableau splitted en List pour pouvoir faire des manipulations comme insérer, ajouter, remplacer, récupérer une sous partie (subList), etc..

On peut utiliser une expression régulière pour reconnaître globalement une chaîne

Code:

1
2
if ( line.matches( "^GEODATUM/(WGE|W84)/.*" ) { // commence par GEODATUM/WGE/ ou GEODATUM/W84/
}

Code:

1
2
3
if ( line.find("MSGID/[^/]+/[^/]+/INI/UNIDENTIFIED/") ) {
  // contient séparés par des /, MSGID, puis n'importe quelle chaîne deux fois, puis INI, puis UNIDENTIFIED
}

Voir la classe Pattern, et les possibilités de parcourir les différentes parties trouvées pour faire du remplacement, par exemple.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
String line = "GEODATUM/WGE/MSGID/-/-/INI/UNIDENTIFIED/CHAISPASQUOI";
 
		Pattern pattern = Pattern.compile("MSGID/[^/]+/[^/]+/INI/UNIDENTIFIED");
 
		StringBuilder sb=new StringBuilder();
		Matcher matcher = pattern.matcher(line);
		while(matcher.find()) {
			matcher.appendReplacement(sb, "MACHIN");
		}
		matcher.appendTail(sb);
 
		String finalLine = sb.toString();
		System.out.println(finalLine);

qui affiche

Citation:

GEODATUM/WGE/MACHIN/CHAISPASQUOI

Tu peux même tester des sous-parties de ce qui a été trouvé par l'expression régulière (par les groupes de capture).

Comme ta ligne ressemble à un chemin de fichier, tu peux utiliser la classe Path qui gère des chemins de fichier
Code:

1 2 3 4 Path path = Paths.get(line); for(Path p : path) { System.out.println(p); }
Affichera avec line = "MSGID/-/-/INI/UNIDENTIFIED"

Citation:

MSGID
-
-
INI
UNIDENTIFIED

Tu peux te faire une classe d'utilitaires avec des méthodes qui t'évitent de réécrire plusieurs fois le même code, pour chercher par exemple des motifs particuliers construits à partir de différents éléments :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class LineUtils {
 
    public static boolean matches(String line, Object...parts) {
        StringJoiner sj = new StringJoiner("/");
        for(Object part : parts) {
             if ( part instanceof Integer ) {
                  for(int i=0; i<(Integer)part; i++) {
                     sj.add("[^/]+");
                  }
             }
             else if ( part instanceof String ) {
                     sj.add((String)part);
             }
        }
        return line.matches("^([^/]+/)*"+sj.toString()+"(/[^/]+)*");
    }
 
}

Et donc faire :

Code:

1
2
if ( LineUtils.matches(line, "MSGID",2, "INI","UNIDENTIFIED") ) {
}

On peut même faire, pour chercher au début, et/ou à la fin :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    public static boolean matches(String line, boolean start, boolean end, Object...parts) {
        StringJoiner sj = new StringJoiner("/");
        for(Object part : parts) {
             if ( part instanceof Integer ) {
                  for(int i=0; i<(Integer)part; i++) {
                     sj.add("[^/]+");
                  }
             }
             else if ( part instanceof String ) {
                     sj.add((String)part);
             }
        }
        StringBuilder sb = new StringBuilder();
        sb.append("^");
        if ( !start ) {
           sb.append("^([^/]+/)*");
        }
        sb.append(sj);
        if ( !end ) {
           sb.append("(/[^/]+)*");
        }
        sb.append("$");
        return line.matches(sb.toString());
    }

Il peut être très intéressant de faire une classe dédiée qui permet de facilement faire les comparaisons et recherches nécessaires pour le traitement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
public class Line implements Iterable<String> {
 
	private int index;
	private int count;
	private String[] splitted;
 
	private Line(String[] splitted, int index, int count) {
		this.splitted = splitted;
		this.index = index;
		this.count = count;
	}
	public Line(String s) {
		this.splitted = s.split("/");
		index = 0;
		count = splitted.length;
	}
 
	public int position() {
		return index;
	}
 
	public int count() {
		return count;
	}
 
	public String current() {
		if (index<count) {
			return splitted[index];
		}
		throw new NoSuchElementException();
	}
 
	public String forward(int n) {
		index = Math.min(count, index+n);
		if ( index<count ) {
			return splitted[index];
		}
		throw new NoSuchElementException();
	}
 
	public String backward(int n) {
		index = Math.max(0, index-n);
		if ( index<count ) {
			return splitted[index];
		}
		throw new NoSuchElementException();
	}
 
	public String next() {
		return forward(1);
	}
 
	public String previous() {
		return backward(1);
	}
 
	public int indexOf(String s) {
		return indexOf(s, index);
	}
	public int indexOf(String s, int start) {
		for(int i=start; i<count; i++) {
			if ( splitted[i].equals(s) ) {
				return i;
			}
		}
		return -1;
	}
 
	public int forwarduntil(String s) {
		for(int i=index; i<count; i++) {
			if ( splitted[i].equals(s) ) {
				index=i;
				return i;
			}
		}
		return -1;
	}
 
	public boolean matches(String...regex) {
		if ( index+regex.length<=count ) {
			for(int i=0; i<regex.length; i++) {
				if ( !splitted[index+i].matches(regex[i]) ) {
					return false;
				}
			}
			return true;
		}
		return false;
	}
 
	@Override
	public int hashCode() {
		return Objects.hashCode(splitted);
	}
 
	public boolean allOf(String...s) {
		if ( s.length==0 ) {
			return false;
		}
		for(int i=0; index+i<count&i<s.length; i++) {
			if ( !splitted[index+i].equals(s[i]) ) {
				return false;
			}
		}
		return true;
	}
 
	public boolean oneOf(String...s) {
		for(int i=0; index+i<count&i<s.length; i++) {
			if ( splitted[index+i].equals(s[i]) ) {
				return true;
			}
		}
		return false;
	}
 
	public boolean allEquals(String...s) {
		if ( s.length!=count ) {
			return false;
		}
		for(int i=0; i<count&i<s.length; i++) {
			if ( !splitted[i].equals(s[i]) ) {
				return false;
			}
		}
		return true;
	}
 
	@Override
	public boolean equals(Object obj) {
		if ( obj instanceof Line ) {
			Line l = (Line) obj;
			if ( l.count == count ) {
				for(int i=0; i<count; i++) {
					if ( !splitted[i].equals(l.splitted[i]) ) {
						return false;
					}
				}
				return true;
			}
		}
		return false;
	}
 
	public Line subLine(int start, int length) {
		return new Line(splitted, start, length);
	}
 
	public Iterator<String> iterator() {
		return new Iterator<String>() {
			int i = 0;
			@Override
			public boolean hasNext() {
				return i<count;
			}
			@Override
			public String next() {
				if (i<count) {
					return splitted[i];
				}
				throw new NoSuchElementException();
			}
		};
	}
 
	@Override
	public String toString() {
		StringJoiner sj = new StringJoiner("/");
		for(String s : splitted) {
			sj.add(s);
		}
		return sj.toString();
	}
 
}

Ensuite tu peux faire par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
Line l = new Line(line);
if ( "GEODATUM".equals(l.current()) ) {
   switch( l.next() ) {
   case "WGE":
       //
       break;
   case "W84":
       //
       break;
   }
}

Code:

1
2
3
4
Line l = new Line(line);
if ( l.allOf("GEODATUM","W84") {
    //
}

Etc...

Je n'ai pas mis de méthode pour modifier la chaîne mais on peut, comme par exemple :

Code:

1
2
3
4
5
public void setCurrent(String value) {
   if ( index>=count) throw new IllegalArgumentException();
   if ( value.indexOf("\")>=0 ) throw new IllegalArgumentException();
   splitted[index]=value;
}

On peut faire tout ce qu'on veut (rendre la taille de la chaîne modifiable (donc ajouter/insérer, supprimer) en stockant dans une ArrayList plutôt qu'un tableau, etc).
On peut implémenter List au lieu d'Iterable pour que Line soit manipulable comme une List, etc.

04/11/2019, 12h09
K2carca

merci joel.drigo pour ces informations.
je vais essayer d'en tirer bonne partie et faire quelques tests.
au pire j'ouvrirai une nouvelle discussion si je ne m'en sors pas.
on s'invente pas programmeur du jour au lendemain et en plus qu'en t'a pas le support.. heureusement il y ce site...et internet mais rien ne vos l'experience de certaine personnes.