Come trovare un’intera parola in una stringa in java

Ho una stringa che devo analizzare per parole chiave diverse. Ad esempio, ho la stringa:

“Verrò a trovarti agli 123woods”

E le mie parole chiave sono

‘123woods’ ‘woods’

Dovrei segnalare ogni volta che ho una partita e dove. Dovrebbero essere considerati anche più eventi. Tuttavia, per questo, dovrei ottenere una corrispondenza solo su 123woods, non sui boschi. Questo elimina l’uso del metodo String.contains (). Inoltre, dovrei essere in grado di avere una lista / gruppo di parole chiave e controllare allo stesso tempo per il loro verificarsi. In questo esempio, se ho “123woods” e “come”, dovrei ottenere due occorrenze. L’esecuzione del metodo dovrebbe essere veloce sui testi di grandi dimensioni.

La mia idea è di usare StringTokenizer ma non sono sicuro se funzionerà bene. Eventuali suggerimenti?

L’esempio sotto è basato sui tuoi commenti. Utilizza un elenco di parole chiave, che verranno ricercate in una determinata stringa utilizzando i limiti delle parole. Usa StringUtils da Apache Commons Lang per creare l’espressione regolare e stampare i gruppi corrispondenti.

String text = "I will come and meet you at the woods 123woods and all the woods"; List tokens = new ArrayList(); tokens.add("123woods"); tokens.add("woods"); String patternString = "\\b(" + StringUtils.join(tokens, "|") + ")\\b"; Pattern pattern = Pattern.compile(patternString); Matcher matcher = pattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group(1)); } 

Se stai cercando prestazioni più elevate, potresti dare un’occhiata a StringSearch : algoritmi di corrispondenza dei modelli ad alte prestazioni in Java.

Usa regex + contorni di parole come gli altri hanno risposto.

 "I will come and meet you at the 123woods".matches(".*\\b123woods\\b.*"); 

sarà vero

 "I will come and meet you at the 123woods".matches(".*\\bwoods\\b.*"); 

sarà falso

Che ne dici di qualcosa come Arrays.asList(String.split(" ")).contains("xx") ?

Vedere String.split () e Come posso verificare se una matrice contiene un determinato valore .

Spero che questo funzioni per te:

 String string = "I will come and meet you at the 123woods"; String keyword = "123woods"; Boolean found = Arrays.asList(string.split(" ")).contains(keyword); if(found){ System.out.println("Keyword matched the string"); } 

http://codigounico.blogspot.com/

Prova ad abbinare usando le espressioni regolari. Abbinare per “\ b123wood \ b”, \ b è una parola interruzione.

Hai un modo per abbinare la parola esatta da String in Android:

 String full = "Hello World. How are you ?"; String one = "Hell"; String two = "Hello"; String three = "are"; String four = "ar"; boolean is1 = isContainExactWord(full, one); boolean is2 = isContainExactWord(full, two); boolean is3 = isContainExactWord(full, three); boolean is4 = isContainExactWord(full, four); Log.i("Contains Result", is1+"-"+is2+"-"+is3+"-"+is4); Result: false-true-true-false 

Funzione per la parola della partita:

 private boolean isContainExactWord(String fullString, String partWord){ String pattern = "\\b"+partWord+"\\b"; Pattern p=Pattern.compile(pattern); Matcher m=p.matcher(fullString); return m.find(); } 

Fatto

Un modo molto più semplice per farlo è usare split ():

 String match = "123woods"; String text = "I will come and meet you at the 123woods"; String[] sentence = text.split(); for(String word: sentence) { if(word.equals(match)) return true; } return false; 

Questo è un modo più semplice e meno elegante di fare la stessa cosa senza usare token, ecc.

La soluzione sembra essere accettata a lungo, ma la soluzione potrebbe essere migliorata, quindi se qualcuno ha un problema simile:

Questa è un’applicazione classica per algoritmi di ricerca multi-pattern.

Java Pattern Search (con Matcher.find ) non è qualificato per farlo. La ricerca di esattamente una parola chiave è ottimizzata in java, la ricerca di un’espressione o utilizza l’automa non deterministico regex che fa il backtracking sulle mismatch. Nel peggiore dei casi, ogni carattere del testo verrà elaborato per 1 volte (dove 1 è la sum delle lunghezze del modello).

La ricerca a schema singolo è migliore, ma non è nemmeno qualificata. Uno dovrà iniziare l’intera ricerca per ogni modello di parole chiave. Nel peggiore dei casi, ogni carattere del testo verrà elaborato p volte dove p è il numero di motivi.

La ricerca multi-pattern elaborerà ogni carattere del testo esattamente una volta. Gli algoritmi adatti per tale ricerca sarebbero Aho-Corasick, Wu-Manber o Set Backwards Oracle Matching. Questi potrebbero essere trovati in librerie come Stringsearchalgorithms o byteseek .

 // example with StringSearchAlgorithms AhoCorasick stringSearch = new AhoCorasick(asList("123woods", "woods")); CharProvider text = new StringCharProvider("I will come and meet you at the woods 123woods and all the woods", 0); StringFinder finder = stringSearch.createFinder(text); List all = finder.findAll(); 

Puoi usare le espressioni regolari. Usa i metodi Matcher e Pattern per ottenere l’output desiderato

È inoltre ansible utilizzare espressioni regolari corrispondenti al flag \ b (intero limite di parole).

Per abbinare “123woods” anziché “woods”, utilizzare il raggruppamento atomico nella expresssion regolare. Una cosa da notare è che, in una stringa che corrisponde solo a “123woods”, corrisponderà al primo “123woods” ed esce invece di cercare ulteriormente la stessa stringa.

 \b(?>123woods|woods)\b 

cerca 123woods come ricerca primaria, una volta abbinato esce dalla ricerca.

Guardando indietro alla domanda iniziale, dobbiamo trovare alcune parole chiave date in una determinata frase, contare il numero di occorrenze e sapere qualcosa su dove. Non capisco cosa significhi “dove” (è un indice nella frase?), Quindi passerò quello … Sto ancora imparando Java, un passo alla volta, quindi vedrò a quello a tempo debito 🙂

È necessario notare che le frasi comuni (come quella nella domanda originale) possono avere parole chiave ripetute, pertanto la ricerca non può semplicemente chiedere se una determinata parola chiave “esiste o meno” e contarlo come 1 se esiste. Ci può essere più di uno della stessa cosa. Per esempio:

 // Base sentence (added punctuation, to make it more interesting): String sentence = "Say that 123 of us will come by and meet you, " + "say, at the woods of 123woods."; // Split it (punctuation taken in consideration, as well): java.util.List strings = java.util.Arrays.asList(sentence.split(" |,|\\.")); // My keywords: java.util.ArrayList keywords = new java.util.ArrayList<>(); keywords.add("123woods"); keywords.add("come"); keywords.add("you"); keywords.add("say"); 

Guardandolo, il risultato atteso sarebbe 5 per “Say” + “come” + “you” + “say” + “123woods”, contando “say” due volte se andiamo in minuscolo. Se non lo facciamo, il conteggio dovrebbe essere 4, “Dire” essere escluso e “dire” incluso. Belle. Il mio suggerimento è:

 // Set... ready...? int counter = 0; // Go! for(String s : strings) { // Asking if the sentence exists in the keywords, not the other // around, to find repeated keywords in the sentence. Boolean found = keywords.contains(s.toLowerCase()); if(found) { counter ++; System.out.println("Found: " + s); } } // Statistics: if (counter > 0) { System.out.println("In sentence: " + sentence + "\n" + "Count: " + counter); } 

E i risultati sono:

Trovato: Say
Trovato: vieni
Ti ho trovato
Trovato: dire
Trovato: 123woods
Nella frase: dì che 123 di noi verranno e ti incontreranno, ad esempio, nel bosco di 123woods.
Conta: 5

 public class FindTextInLine { String match = "123woods"; String text = "I will come and meet you at the 123woods"; public void findText () { if (text.contains(match)) { System.out.println("Keyword matched the string" ); } } }