Frage zu Pattern/Matcher

[ttttttt]

Hallo liebe Community,
heute habe ich mich ein wenig auf Basis des hilfreichen FAQs
Grundzüge von Pattern-Matching und Split mit Pattern-Mathing beschäftigt.
Einige Probleme konnte ich dabei aber noch nicht eigenhändig lösen.

Grundlegend möchte ich ein Programm schreiben, das in der Lage ist, die Grafikadressen von Bildern einer Seite aus dem Seitenquelltext der jeweiligen Seite heraus zu lesen. Exemplarisch:

Das Bild mit der Adresse http://www.all-art.org/Visual%20History/modern%20era/mucha/28.jpg wird im Quelltext der dazugehörigen Seite (derjenigen Seite, in die es eingebettet ist) wie folgt erwähnt:

<img border="1" src="../Visual%20History/modern%20era/mucha/28.jpg" width="566" height="800"><br>

Diesen Code möchte ich nicht komplett erhalten, sondern nur den Teil ab http:// ODER .. bis jpg. Hier also:

../Visual%20History/modern%20era/mucha/28.jpg

Damit stellt sich die Frage:
Verwende ich mit

String regex = "(http://|\\.\\.).*(jpg)";

die richtige Zeichenreihenfolge für's Pattern-Matching? Ich fürchte nämlich, die Sache mit dem Maskierungs-\ hab' ich noch nicht richtig raus ...

Zweitens: Ich habe versucht eine Methode compare zu schreiben, die das Pattern-Matching durchführt. Diese Methode ist in eine while-Schleife eingebaut.
Ich hätte gerne, dass ich somit alle passenden Grafikadresse (hier zbsp: ../Visual%20History/modern%20era/mucha/28.jpg) als String in einem Array oder einer ArrayList speichern kann.
Wie mache ich das? Denn die Methode gibt doch nur ein boolean zurück, nicht aber die Adresse ...
Hier Auszüge aus dem Code:

	public static boolean compare(String regex, CharSequence input ) 
	{ 
	 Pattern p = Pattern.compile(regex); 
	 Matcher m = p.matcher( input ); 
	 return m.matches();
	 //gibt boolean zurück, es sollten aber auch die passenden Codeteile (also die BilderURL)
	 //als String zurück gegeben werden. Wie funktioniert das?
	}

Auszug aus der main:

	      String line;
	      String regex = "(http://|\\.\\.).*(jpg)";
	            
	          //liest so viele Zeilen aus wie vorhanden
	          while ((line = in.readLine()) != null)
                          //führt für jede Zeile compare durch
	        	  compare(regex, line)

 

[eRaaaa]

Also ich würde es mit [c]"<img .* src=\"(.+\\.jpg).*"[/c] mal versuchen, wobei das vermutlich auch nicht optimal ist.Es gibt ja nicht umsonst HTML-Parser etc. wieso benutzt du nicht einfach schon etwas fertiges ?
Zu deiner zweiten Fragen, nunja, entweder diese Methode fügt den String/URL direkt in die Liste ein, sie gibt nur den String zurück(oder eben null wenn nichts gefunden wurde, das kannst du ja abfragen) oder ein Holder(boolean + String)

	public static void main(String[] args) throws Exception {
		String s = "<img border=\"1\" src=\"../Visual%20History/modern%20era/mucha/28.jpg\" width=\"566\" height=\"800\"><br>";
		System.out.println(compare("<img .* src=\"(.+\\.jpg).*", s)); //../Visual%20History/modern%20era/mucha/28.jpg
	}

	public static String compare(String regex, CharSequence input) {
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(input);
		if(m.find()){
			return m.group(1);
		}
		return null;
	}

 

[Mizar]

Ich würde das ganze so machen:

public class Main
{
	public static void main(String[] args)
	{
		String data = "";
		try {
			InputStream is = new URL("http://www.java-forum.org/java-basics-anfaenger-themen/111960-frage-pattern-matcher.html").openStream();
			Scanner scanner = new Scanner(is);
			data = scanner.useDelimiter("\\Z").next();
			scanner.close();
			is.close();
		} catch(Exception e) {
			e.printStackTrace();
		}
		Pattern pattern = Pattern.compile("<img(?:\"[^\"]*\"|'[^']*'|[^\"'>])*src=(\"[^\"]+\"|'[^']+')(?:\"[^\"]*\"|'[^']*'|[^\"'>])*/?\\s*>");
		Matcher matcher = pattern.matcher(data);
		while(matcher.find()) {
            // Hier die Treffer dann einem Array, Liste oder was auch immer hinzufügen
            // Als Test nur eine Konsolenausgabe:
			System.out.println(matcher.group(1));
		}
	}
}

Der RegEx wäre also (mit Escapesequenzen):

<img(?:\"[^\"]*\"|'[^']*'|[^\"'>])*src=(\"[^\"]+\"|'[^']+')(?:\"[^\"]*\"|'[^']*'|[^\"'>])*/?\\s*>

Wie du vielleicht siehst, habe ich den Code zu Testzwecken gleich mal auf diesen Thread hier losgelassen und es ergaben sich die folgenden Treffer zum Zeitpunkt meines Postings(gekürzt):

"http://www.java-forum.org/images/misc/java_forum_org.gif"
"http://www.buecherbillig.de/images/82661797s.jpg"
"http://www.java-forum.org/images/misc/navbits_start.gif"
"http://www.java-forum.org/iconimages/java-basics-anfaenger-themen/frage-pattern-matcher_ltr.gif"
und einige mehr...

Ich hoffe die dabei mit enthaltenen Anführungszeichen stören nicht all zu sehr, dafür ist der RegEx recht "robust".

EDIT: Hmpf, da war eRaaaa wohl schneller ;(

 

[ttttttt]

Also ich würde es mit [c]"<img .* src=\"(.+\\.jpg).*"[/c] mal versuchen,

Stimmt ja, die Zeichen vor der Grafikadresse müssen auch noch in irgendeiner Form im Pattern verpackt werden,
es wird immer der String als ganzes betrachtet und nicht erst ab da, wo der Teil beginnt, den ich gerne hätte

wobei das vermutlich auch nicht optimal ist.

Auch wieder richtig... denn eigentlich interessiere ich mich nicht für den kompletten String,
sondern nur für einen gewissen Teil daraus (die Grafikadresse). Ist Pattern-Matching überhaupt
geeignet für mein Vorhaben? Muss der String vllt. noch vorher gesplittet werden?

Es gibt ja nicht umsonst HTML-Parser etc. wieso benutzt du nicht einfach schon etwas fertiges ?

Das Programm schreibe ich nur zu Übungszwecken, um den Umgang mit der Sprache zu lernen.

	public static void main(String[] args) throws Exception {
		String s = "<img border=\"1\" src=\"../Visual%20History/modern%20era/mucha/28.jpg\" width=\"566\" height=\"800\"><br>";
		System.out.println(compare("<img .* src=\"(.+\\.jpg).*", s)); //../Visual%20History/modern%20era/mucha/28.jpg
	}

	public static String compare(String regex, CharSequence input) {
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(input);
		if(m.find()){
			return m.group(1);
		}
		return null;
	}

Danke. Der letzte Teil hat mir wirklich weitergeholfen. Ich hatte mich nämlich hier umgeschaut und dachte, es wäre nur möglich 'nen boolean zurück zu geben.

Edit.: So, grade nochmal aktualisiert
Der zweite Beitrag verdeutlicht die Lösung auf jeden Fall noch einmal.
Vielen Dank, ich werde mich dann jetzt mal an's verstehen machen.

 

[ttttttt]

Hallo allerseits,
da ich immer noch an diesem Programm arbeite,
hier nochmal eine Frage zu meinem (hoffentlich) letzten Problem:

die auf Basis von Mizar's Code gematchten Quelltextstellen würde ich ganz gerne einer ArrayList

import java.net.URL;

ArrayList<URL> imgURL = new ArrayList<URL>();

hinzufügen.


die für mich denkbar einfachste Lösung

imgURL.add("http://www.hier-die-adresse.com/");

funktioniert aber leider nicht, offenbar kann in eine URL ArrayList kein String hinzugefügt werden.
Das ist für mein Vorhaben erst mal recht schade... und etwas verwirrend, denn

URL test = new URL("http://www.hier-die-adresse.com/");

funktioniert doch auch, und übergibt einen String in ein einzelnes URL Objekt ???:L

Bitte um Hilfe.

 

[SlaterB]

eine kleine Metallkugel kann man in eine Plastikschale legen, und vor dir steht ein Regal mit Gitterboden, geeignet für Plastikschalen,
wenn du jetzt eine Metallkugel aufs Regal legst fällt diese durchs Gitter und alle sind traurig,
die Moral von der Geschichte: Metallkugeln nur in Plastikschalen, diese dann aufs Gitter

Strings nur in URLs, diese dann in die ArrayList, die ArrayList kann nicht automatisch ein URL-Objekt anlegen

 

[Mizar]

Ich weiß zwar das das Thema mittlerweile als erledigt gilt, aber dennoch eine kleine Ergänzung: Den zuvor von mir geposteten RegEx konnte ich noch dahingehend erweitern, dass er nun tatsächlich nur noch die Adressen der Bilder ohne Anführungszeichen als Ergebnis zurückliefert. So schaut er nun aus (mit Escapesequenzen für Java):

<img(?:\"[^\"]*\"|'[^']*'|[^\"'>])*src=[\"']((?<=\")[^\"]+|(?<=')[^']+)[\"'](?:\"[^\"]*\"|'[^']*'|[^\"'>])*/?\\s*>

Erweitert habe ich das ganze an folgender Stelle mit lookbehind-Ausdrücken:

src=[\"']((?<=\")[^\"]+|(?<=')[^']+)[\"']

Viel Spaß damit