web-dev-qa-db-fra.com

Comment vérifier si un mot est présent dans une phrase en utilisant Java?

Je suis nouveau dans la programmation et le travail sur une fonction pour retourner vrai si un mot est présent dans une phrase. J'ai essayé la méthode indexOf(), mais j'ai aussi rencontré un problème avec cette approche:

Supposons que ma phrase soit I am a, Java Programmer.

Si nous cherchons le mot ram avec la méthode indexOf(), alors il retournera true car ram est présent dans Programmer alors que le la sortie correcte doit être false car ram n'est pas présent en tant que mot mais en tant que modèle.

Comment puis-je contourner ce problème? Le code que j'utilise actuellement est:

boolean isPresent(String Word, String sentence)
{
    if(sentence.indexOf(Word) >= 0)
        return true;
    else
        return false;
}

NOTE: Le mot ram est juste un exemple pour montrer l'un des problèmes de mon approche actuelle. Ce n'est pas que je doive travailler avec ram seulement tout le temps .Le mot peut être quelconque, comme par exemple a, suivi d'une virgule dans la phrase ci-dessus.

PDATE: Merci à tous pour vos commentaires et solutions. J'en ai sélectionné une comme réponse acceptée (j'en aurais choisi plus si cela était autorisé :-)), mais beaucoup ont été utiles.

javapattern-matching
33
user2966197

essayez regex

boolean contains = s.matches(".*\\bram\\b.*");

\ b signifie limite de mot

39
Evgeniy Dorofeev

Puisque vous voulez chercher un mot, il y a trois cas:

  1. Le mot au début de la phrase ne signifie aucun espace au début mais un espace à la fin.
  2. Mot entre l'espace de la phrase aux deux extrémités.
  3. Word à la fin seulement l'espace à la fin.

Pour couvrir les trois cas, une solution possible est la suivante:

String str = "I am a Java programmer";
String[] splited = str.split("\\b+"); //split on Word boundries
Arrays.asList(splited).contains("ram"); //search array for Word

ici fonctionne démo

21
Zaheer Ahmed

Question:

Comment définissez-vous un mot?

Réponse possible:

Bouquet de caractères séparés par d'autres. Ce deuxième ensemble de caractères est défini par ce que vous choisissez. Supposons que vous choisissiez ces personnes pour être . ,?;. Donc, si vous scindez la chaîne d'entrée avec ces caractères (appelés délimiteurs ), vous obtiendrez un tas de chaînes qui sont des mots Maintenant, pour savoir si l’entrée contient le mot Word ou non, passez en boucle sur ces chaînes pour vérifier si elles correspondent à votre requête.

Code:

boolean isPresent(String query, String s) {    
    String [] deli = s.split("[.\\s,?;]+");

    for(int i=0;i<deli.length;i++)
        if(query.equals(deli[i]))
            return true;

    return false;    
}

tl; dr:

Si vous voulez qu'un mot soit défini comme tout ce qui est composé d'alphabets, de chiffres et de soulignés, une expression régulière est prête pour vous: \W+.

String [] deli = s.split("\\W+");

Pensez à lire cet article si vous voulez en savoir plus sur Java Regex.

10
Rikayan Bandyopadhyay

Si vous voulez faire correspondre un mot à une phrase même avec de la ponctuation, vous aurez besoin d'une expression rationnelle comme celle-ci:

  static boolean matchesWord(String toMatch, String matchIn) {
     return Pattern.matches(".*([^A-Za-z]|^)"+toMatch+"([^A-Za-z]|$).*", matchIn);
  }

(Vous pouvez utiliser\W, mais cela ne compte pas les soulignés comme une ponctuation.)

Concaténer simplement des espaces au début et à la fin ne correspondra pas, par exemple, le mot "programmeur" dans la chaîne "Je suis un programmeur Java") car il n'y a pas d'espace à la fin. aussi ne fera pas correspondre les mots directement avant ou après la ponctuation.

2
broomweed

Examinez la méthode String.matches(). Si vous construisez correctement l'expression régulière, elle devrait pouvoir faire ce que vous voulez. Un bon point de départ pour les expressions régulières est le Java: http://docs.Oracle.com/javase/tutorial/essential/regex/

2
awksp

Cela fonctionnera, en supposant que chaque mot soit séparé par un espace. J'ai ajouté la fonction principale pour plus de clarté. Find_str renvoie -1 si le mot n'existe pas. sinon, il retourne la position de la Parole par rapport à d'autres mots. Ici, 2 seront retournés, ce qui signifie que la deuxième Parole est 'am'.

import Java.util.*;
public class HelloWorld{

    public static void main(String []args){
        String str="I am a Java Programmer";
        String str1="am";
        int x=find_str(str,str1);
        System.out.println(x);

    }

    public static int find_str(String main,String search) {

        int i; 
        int found=-1;

        String[] s=main.split(" ");
        for(i=0;i<s.length;i++)
        {
            if(search.equals(s[i]))
            found=i+1;
        }
        return found;
    }
}
1
Tina Maria

Essayez cette solution

    int index = sent.indexOf(find);
    if (index != -1) {
        if (index == 0) {
            System.out.println("true");
        }
        else if (index + find.length() == sent.length())
        {
            System.out.println("true");
        }
        else if (sent.charAt(index - 1) == ' ' && sent.charAt(find.length() + index) == ' ') {
            System.out.println("true");
        } else {
            System.out.println("false");
        }

    } else {
        System.out.println("false");
    }

Si vous voulez quelque chose de plus que votre question initiale, alors plutôt que de vérifier s'il y a des espaces, vérifiez qu'ils ne sont pas compris entre 0-9 et a-Z, cela devrait couvrir tous les caractères tels que les virgules, etc.

1
Scary Wombat
String s="I am a Java programmer";
    String s1="Java";
    String []p=s.split("\\s*(=>|,|\\s)\\s*");
        for(int i=0;i<p.length;i++)
        {
            if(s1.equals(p[i]))
            {
                System.out.println(p[i]);
            }

        }
1
Boopathi

Une approche plus simple est la suivante: si vous considérez qu'un mot est quelque chose comme

"Mon pc il y a RAM mémoire" (entre les espaces)

vous pouvez concattre dans vos espaces de fonctions indexOf avant et après le mot que vous recherchez, comme ceci

if (phrase.indexOf ("" + Word + "")> = 0) {

1
jhonis.souza

Il s’agit d’une solution de contournement plutôt maladroite, mais qui devrait permettre d’obtenir les bons résultats. Recherchez la sous-chaîne que vous recherchez dans la chaîne et recherchez les caractères avant et après votre sous-chaîne. Vérifiez-les en utilisant leurs valeurs ascii (int)substring.charAt(x);pour voir si ce sont des lettres ou non. S'ils ne sont pas des lettres ou s'ils ne correspondent pas à la chaîne, vous savez que vous avez trouvé un mot. Sinon, vous savez que cela fait simplement partie d'une Parole.

La logique sera très longue - c'est pourquoi je ne la code pas pour vous, mais tentez votre chance et laissez-moi savoir si vous avez besoin de précisions.

0
joepeacock001

Hlo. Vous pouvez diviser la phrase sous forme de tableau, puis vous mettez dans la liste. Après cela, vous pouvez utiliser la méthode contient pour vérifier que Word est présent ou non. Veuillez essayer ce code ..

import Java.util.ArrayList;
import Java.util.Arrays;


 public class karthitest {
  public static void main(String[] args) {
    String sentence = "I am Karthick";
    String Word = "I";

    if(isWordExist(sentence, Word)){
    System.out.println("Word is exist");
    }
}

public static boolean isWordExist(String sentence, String Word){
    boolean ans = Boolean.FALSE;        
    ArrayList<String> wordList = null;

    try {

        if(sentence != null && Word != null){
            wordList = new ArrayList<String>(Arrays.asList(sentence.split("[^a-zA-z]+")));              
            if(wordList.contains(Word)){
                ans = Boolean.TRUE;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        // TODO: handle exception
    }
    return ans;
}

}
0
Karthikeyan Sukkoor