Heho zusammen,
ich hab einen Path von Windows bekommen und will nun alle \ mit / ersetzten. Zur Zeit versuche ich es gerade mit temp_path.replaceAll("\\", "/"); Jedoch kommt dann immer eine PatternSyntaxException. Hat jemand eine Idee wie ich den Fehler lösen kann?
Du musst backslashes im Regex sowie im Java Quellcode escapen, daher werden aus einem \ vier \\
ah jetzt geht es.
Danke
Hallo,
ich habe dafür vorhin eine Programm erstellt:
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package pkg16unkenntlich;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JFileChooser;
/**
* @author CB
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
// TODO code application logic here
String[] keys = "abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if goto implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while".split(" ");
Arrays.sort(keys);
HashMap<String, String> map = new HashMap<String, String>();
for (String string : keys) {
map.put(string, string);
}
int index = 1;
Pattern pat = Pattern.compile("\\w{5,}");
JFileChooser jfc = new JFileChooser();
if (jfc.showOpenDialog(null) != JFileChooser.APPROVE_OPTION) {
return;
}
File f1 = jfc.getSelectedFile();
if (jfc.showSaveDialog(null) != JFileChooser.APPROVE_OPTION) {
return;
}
File f2 = jfc.getSelectedFile();
if (!f1.isFile() || !f1.canRead() || !f2.isFile() || !f2.canWrite()) {
return;
}
PrintWriter pw = new PrintWriter(new BufferedOutputStream(new FileOutputStream(f2), 1024 * 1024 * 16));
BufferedReader br = new BufferedReader(new FileReader(f1), 1024 * 1024 * 16);
String line;
while ((line = br.readLine()) != null) {
int start = 0;
Matcher m = pat.matcher(line);
while (m.find()) {
pw.print(line.substring(start, m.start()));
start = m.end();
if (!map.containsKey(m.group())) {
map.put(m.group(), "irgendwas_" + index++);
}
pw.print(map.get(m.group()));
}
pw.println(line.substring(start));
}
br.close();
pw.flush();
pw.close();
System.out.println("Erfolgreich");
}
}```
Das müsste jetzt leicht geändert werden:
``` Pattern pat = Pattern.compile("\\\\");```
``` PrintWriter pw = new PrintWriter(new BufferedOutputStream(new FileOutputStream(f2), 1024 * 1024 * 16));
BufferedReader br = new BufferedReader(new FileReader(f1), 1024 * 1024 * 16);
String line;
while ((line = br.readLine()) != null) {
int start = 0;
Matcher m = pat.matcher(line);
while (m.find()) {
pw.print(line.substring(start, m.start()));
start = m.end();
pw.print("/");
}
pw.println(line.substring(start));
}
br.close();
pw.flush();
pw.close();```
Damit klappt es jetzt.
Anmerkung: line.substring() kann auch "" zurückgeben, dann wird nichts angefügt,
falls Du das mit Files machen möchtest, ist PrintWriter und BufferedReader schon eine gute Wahl,
f1 sollte != f2 sein (Überprüfung vorhin vergessen),
Pattern (nur einmal initialisieren)/Matcher(/StringBuilder) sind eig. schnell, ich weiß jetzt nicht, ob schneller als String#replaceAll(, ); , aber wenn replaceAll öfter aufgerufen wird, dann vielleicht schon.
Viele Grüße, CBbb :)wer die 4 Backslashes nicht mag (so wie ich) kann auch dies nutzen:Pattern.compile(Pattern.quote(File.separator));
bye
TT
Es würde ja noch einfacher gehen wenn man mal die Doc lesen würde und damit wüsste das String.replaceAll(String, String) als ersten Parameter eine RegEx, also eine Regular Expression (Regulärer Ausdruck), erwartet.
Und wenn man dann noch weiterlesen würde und auf String.replace(String, String) stößt und dann mitbekommt das dies keine RegEx verlangt sondern wirklich das Zeichen was ersetzt werden soll.
Womit dann folgender Code genau das macht was man will :
public class SomeClass
{
public static void main(String[] args)
{
String file=(new File(".")).getAbsolutePath();
System.out.println(file);
file=file.replace("\\", "/");
System.out.println(file);
}
}```
Aber naja, da könnte man jetzt den Intiligenzbestien bei Oracle den Vorwurf machen sich damals über die Bezeichnung dieser zwei Methoden nicht all zu viel Gedanken gemacht zu haben, denn wie man sieht kommt es immer wieder zu diesem und ähnlichen Anfänger-Fehlern.Nur dass replace nur das erste Vorkommen ersetzt, replaceAll alle.
wer einen einfacheren Weg postet sollte schon genau aufpassen,
noch mehr aber wer meint, den zu korrigieren 
public String replace(CharSequence target, CharSequence replacement)
Replaces each substring of this string that matches the literal target sequence […]
ausprobieren sowieso,
ein bisschen kam mir der Gedanke auch bekannt vor, aber wird wohl kaum je anders gewesen sein in dieser Methode,
muss an der allgemeinen Unschärfe Klarstring vs. Regex liegen, an den Methodennamen replace vs. replaceAll sowieso
wobei die einfachere Methode intern auch RegEx verwendet…, dahingehend spart man zumindest nix
edit: jetzt habe ich mich von dem \ auch halb als Doppelzeichen verwirren lassen,
es wird aber doch Zeichen für Zeichen ersetzt, die replace-Methode mit char ist die effizienteste:
Ich möchte eure Kompetenz nicht in Frage stellen, aber :
Das die Namenswahl eher sub-optimal ist hatte ich ja schon angemerkt, aber die Doc (auf die ich bei sowas immer gerne verweise) liefert die nötigen Erklärungen.