[JAVA] Trovare le stringhe simili ad una stringa data

[ascatem2]

Vorrei trovare data una stringa che usi i '*' per sottintendere + caratteri e '?' per sottintendere un carattere tutte le stringhe associabili, ad esempio:

Array in cui cercare:

abaco
abano
abate
acacia

Stringa da cercare:
a?ac*

risultato

abaco
acacia

ovviamente la stringa da cercarepotrebbe avere + '?' e/o + '*'

come posso fare?
grazie!!

[ascatem2]

ho risolto così, ma vorrei sapere se secondo voi va bene:

/**il metodo confronta una stringa e un pattern e ritorna true se sono simili
@param s stringa da confrontare
@param m pattern
@return se s è simile a m o no
*/
public static boolean simili(String s,String m){
	int j=0;
	for(int i=0;i<s.length() && j<m.length();i++)
		if((m.charAt(j)=='*')|| (m.charAt(j)=='?')||(m.charAt(j)==s.charAt(i)))
			j++;
    return !(j<m.length());
}//simili

[nether]

non mi sembra che vada sempre bene, ad esempio:

Array in cui cercare:

abaco
abano
abate
acacia

Stringa da cercare:
aba?

risultato

abaco

il che e' sbagliato... il risultato "abaco" in questo caso lo dovresti potresti ottenere con stringhe tipo abac?, abac*, ab*, aba??, ecc. ecc. ecc. ma non con "aba?".
infatti e' molto chiaro come nel codice i caratteri che dovrebbero fare da wildcard come ? e * sono trattati allo stesso identico modo.

Secondo me ti conviene trasformare la stringa "inserita dall'utente" (quella con i ? e gli *) in una regex e far matchare quella..
Dai un'occhio alla classe Pattern qui sotto..
http://java.sun.com/j2se/1.5.0/docs/...x/Pattern.html

[ascatem2]

nel mio esempio al stringa da cercare è

Stringa da cercare:
a?ac*

[Andrea1979]

con le regex è "molto semplice"

Pattern p = Pattern.compile("a(.){1}ac.");
    String[] strings = {"abaco", "abano", "abate", "acacia", "babaco"};
    for (int i = 0; i < strings.length; i++) {
      System.out.println(strings[i] + " è riconosciuta come stringa valida? :" +
                         p.matches(p.pattern(), strings[i]));
    }

Altrimenti dovrai lavorare di charAt... dipende dalle specifiche del tuo, permettimi di dirlo, esercizio.

Per dovere di completezza, visto che penso sia la prima volta che vieni in contatto con un simile argomento (regex), ci sono delle regole che magari possono essere un po' oscure e che vediamo di spiegare brevemente (ce n'è un fottio di regole, io ti spiego solo quelle che ho utilizzato)

Il mio pattern è: a(.){1}ac.

Il punto . ha un significato particolare: è come * nel tuo esercizio: può assumere qualsiasi valore, incluso una stringa di lunghezza variabile.
() servono a raggruppare e consentono di specificare dopo un quantificatore, tra parentesi grafe
(.){1} in sostanza vuol dire: va bene qualsiasi carattere, purchè sia ripetuto una ed una sola volta.
Il resto dei caratteri nell'esempio non assumono significati funzionali particolari.

[ascatem2]

A me serve per una cosa scolastica, sì

Volevo fare qualcosa tipo la ricerca di windows, se tu cerchi puoi inserire i caratteri jolly '*' e '?' e giacché non sarò io poi il fruitore della ricerca, ma "l'utente finale" devo farlo il + semplice possibile.

cmq, seguendo il tuo schema (ho già capito che le regex dovrò studiarmele, sembrano molto utili):

* = (.)
? = (.){1}

giusto? quindi se io alla parola inserita sostituisco * e ? con le corrispettive regex sono apposto? e poi quindi posso usare il metodo match della classe String per la ricerca

[nether]

Originariamente inviato da ascatem2
nel mio esempio al stringa da cercare è

Stringa da cercare:
a?ac*

si, io mi riferivo al codice che avevi postato in precedenza (quello che faceva uso dei charAt), e ti mostravo un possibile scenario in cui il risultato non era quello che ti saresti aspettato.

Grazie ad Andrea1979 che ci ha fornito il pattern corretto da utilizzare (io non mi sarei mai ricordato senza andare a riguardare la documentazione..) puoi risolvere tutto quanto semplicemente cosi':

String stringaUtente = "a?ac*"; //la stringa definita dall'utente
stringaUtente = stringaUtente.replaceAll("?", "(.){1}");
stringaUtente = stringaUtente.replace('*', '.');
Pattern p = Pattern.compile(stringaUtente);
    String[] strings = {"abaco", "abano", "abate", "acacia", "babaco"};
    for (int i = 0; i < strings.length; i++) {
      System.out.println(strings[i] + " è riconosciuta come stringa valida? :" +
                         p.matches(p.pattern(), strings[i]));
    }

[Andrea1979]

sì, usare il raggruppatore () su * è però inutile: ti basta il punto semplice come l'ho messo io. Il punto è infatti una di quelle entità riservate nella compilazione di un pattern. Puoi poi utilizzare tutti i metodi che vuoi che prendano una regex e un testo per fare il match. Ho fatto l'esempio in quel modo perché ho riciclato del codice che avevo a portata di mano.

[ascatem2]

perfetto vi ringrazio di cuore ora modifico il codice

già che ci sono vi dico anche lo scopo del programma

Laboratorio di Sistemi

Gestire in jsp un glossario in XML la cui struttura è:

<glossario>
  <voce>
    <vocabolo>...</vocabolo> 
    <descrizione>...</descrizione> 
  </voce>
  .
  .
  .
  .
</glossario>

e in particolare: inserimento di nuovi vocaboli, cancellazione di vocaboli, visualizzazione del glossario, modifica di vocaboli, operazioni sui glossari(cancellazione di un intero glossario, caricamento di un glossario, rinominare un glossario, creazione di un nuovo glossario).

finito ciò devo dargli anche una grafica decente (la parte imho + difficile)

la parte con le regex mi serviva per cercare le parole e poi permettere la modifica o la cancellazione delle stesse.

[Andrea1979]

Spero però che tu stia utilizzando un parser XML decente (SAX o che) per gestire i file XML in java, altrimenti, te lo dico spassionatamente, stai reinventando nemmeno la ruota, ma l'acqua tiepidina...