# String mit Platzhalter



## --- (30. Jan 2009)

Hallo,

ich möchte in einer Map suchen, ob ein passender Eintrag entsprechend einem vorgegebenen String vorhanden ist.

Hierbei ist das Problem, dass der String Platzhalter beinhaltet, z.b. "Pl??z" 
Möglich zu findender Eintrag in Map wäre hier Platz.
'?' steht für einen beliebigen Buchstaben, das Vorkommen des ? im String, kann beliebig oft und an beliebiger Stelle sein.

Leider habe ich bei den Methoden von String nichts passendes gefunden. Gibt es so eine Methode nicht oder habe ich nicht richtig gesucht?

Bin für Tipps dankbar, Tipps zum googeln wärn auch super..
Danke


----------



## Gast (30. Jan 2009)

Ja, das ist relative einfach mit String.matches(RegEx) machbar.

Einfach die passende regular expression schreiben und fertig.


----------



## --- (30. Jan 2009)

Danke, probiers aus


----------



## --- (30. Jan 2009)

Nochmal danke für den Tip. Da gibts dann auch genug Bsp.

Leider habe ich schon beim Auslesen der Map ein Problem. Das Speichern der Daten in Map ist ok.
Der Iterator, mit dem ich die einzelnen "word" auslesen will funktioniert nicht. Hier steht statt der Werte zu word, immer beschr. Habe ich den Iterator falsch deklariert?
Iterator<Entry<String, List<String>>> it = map.entrySet().iterator(); ist aus CodeKorrektur von eclipse

hier mein Testprogramm


```
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Patterns 
{ 
	public static void main(String[] args) 
	{ 
        
       //Map füllen
		Map<String, List<String>> map = new TreeMap<String, List<String>>();
        
  		List<String> word = new ArrayList<String>();
  		List<String> beschr = new ArrayList<String>();
  
  		map.put("word", word);
  		map.put("beschr", beschr);
  
  		List<String> list = map.get("word");
  		list.add("JAVA");
  		list.add("TEST");
  		list.add("NEU");
  
  		list = map.get("beschr");
  		list.add("VERSUCH");
  		list.add("PROGRAMMIERSPRACHE");
  		list.add("ALT");
  		
  		System.out.println("word: " + map.get("word"));
  		System.out.println("beschr: " + map.get("beschr"));
  		//Pattern
  		String s1 = "T.*.*.*"; 
  		
        Pattern p = Pattern.compile(s1); 
        
        Iterator<Entry<String, List<String>>> it = map.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry en = it.next();
            String comp = en.getKey().toString(); // debug: hier comp = beschr statt einzelne Einträge
        	Matcher m = p.matcher(comp); 
            Boolean b = m.matches(); 
            System.out.println("passt? --> " + b); 
          
        }    
    } 
}
```

vielen Dank..


----------



## SlaterB (30. Jan 2009)

der Key kann nur 'word' oder 'beschr' sein, denn nur diese fügst du als Key in die Map ein,

wenn du die zugehörige Liste haben willst, dann ist das en.getValue() 
und die musst du dann auch noch per for-Schleife durchlaufen

von selber programmiert sich das nicht


----------



## Vayu (30. Jan 2009)

naja du kriegst ja über den iterator die listen zurück und nicht deren inhalt. sprich du müsstest noch eine ebene tiefer greifen und die listen dann nochmal iterieren.

machs am besten so

dein pattern ist auch ein bisschen "overkill" ein .* sagt schon aus es dürfen beliebig viele ODER kein zeichen folgen. Wenn du aussagen möchtest, dass nach dem T nur 3 zeichen kommen dürfen schreib T... oder T.{3} oder T[A-Z]{3}


```
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Patterns {
    public static void main(String[] args) {

        // Map füllen
        Map<String, List<String>> map = new TreeMap<String, List<String>>();

        List<String> word = new ArrayList<String>();
        List<String> beschr = new ArrayList<String>();

        map.put("word", word);
        map.put("beschr", beschr);

        List<String> list = map.get("word");
        list.add("JAVA");
        list.add("TEST");
        list.add("NEU");

        list = map.get("beschr");
        list.add("VERSUCH");
        list.add("PROGRAMMIERSPRACHE");
        list.add("ALT");

        System.out.println("word: " + map.get("word"));
        System.out.println("beschr: " + map.get("beschr"));
        // Pattern
        String s1 = "T...";

        Pattern p = Pattern.compile(s1);

        for( String key : map.keySet() ) {
            for( String entry : map.get(key) ) {
                Matcher m = p.matcher(entry);
                Boolean b = m.matches();
                System.out.println("passt? " + entry + " --> " + b);
            }
        }
    }
}
```


----------



## --- (30. Jan 2009)

Danke.

Das Pattern sollte bedeuten nach T mussen 3 beliebige Zeichen kommen, das hast Du richtig erkannt.
Wie kann ich in der Schleife abfangen, dass nur die words bei der Suche berücksichtigt werden?

```
Pattern p = Pattern.compile(s1); 

        for( String key : map.keySet() ) { 
            for( String entry : map.get(key) ) {  //hier nicht alle, nur die map.get("word"));
                Matcher m = p.matcher(entry); 
                Boolean b = m.matches(); 
                System.out.println("passt? " + entry + " --> " + b); 
            } 
        }
```


----------



## Vayu (30. Jan 2009)

```
for( String key : map.keySet() ) {
            if(!key.equals("word")) continue;
            for( String entry : map.get(key) ) {
                Matcher m = p.matcher(entry);
                Boolean b = m.matches();
                System.out.println("passt? " + entry + " --> " + b);
            }
        }
```


----------

