puisque vous voulez rechercher un mot il y a trois cas:

1. mot en début de phrase signifie pas d'espace au début, mais l'espace à la fin.
2. mot entre les espaces de phrases aux deux extrémités.
3. mot à la fin seulement espace à la fin.

pour couvrir les trois cas, une solution possible est:

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

Voici la démo de travail

Question:

Comment définissez-vous un mot?

réponse Possible:

groupe de caractères séparés par d'autres caractères. Ce deuxième jeu de caractères est définie par ce que vous choisissez. Supposons que vous choisissiez . ,?; . Donc si vous divisez la chaîne de caractères avec ces caractères (appelés délimiteurs ), vous obtiendrez un tas de chaîne de caractères qui sont mots . Maintenant trouvez si l'entrée contient le mot ou non, faites une 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 quoi que ce soit qui se compose d'alphabets, de nombres et de soulignement, il y a un regex prêt pour vous: \W+ .

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

envisager de lire cet article si vous voulez en savoir plus sur Java Regex.

regardez la méthode String.matches() . Si vous construisez l'expression régulière correctement, il devrait être en mesure de faire ce que vous souhaitez. Un bon point de départ pour les expressions régulières serait les tutoriels Java: http://docs.oracle.com/javase/tutorial/essential/regex /

si vous voulez faire correspondre un mot dans une phrase même avec la ponctuation, vous aurez besoin d'un regex comme ceci:

  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 underscores comme ponctuation.)

ne fait que concaténer les espaces au début et la fin ne correspond pas, par exemple, au mot" programmeur "dans la chaîne" je suis un programmeur Java " parce qu'il n'y a pas d'espace à la fin. Il ne correspondra pas non plus aux mots directement avant ou après la ponctuation.

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]);
            }

        }

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

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

vous pourriez concatter dans votre index des espaces de fonction avant et après le mot que vous cherchez, comme ceci

si (phrase.indexOf(" "+ mot +" ") >= 0) {

d'Essayer 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 d'origine alors à la place de vérifier les espaces, vous devriez vérifier qu'ils ne sont pas entre 0-9 et A-Z, cela devrait couvrir tous les caractères tels que la virgule période, etc.

cela fonctionnera, en supposant que chaque mot est séparé par un espace. J'ai ajouté la fonction principale pour plus de clarté. Le find_str renvoie -1 si le mot n'existe pas. autrement, il renvoie la position du mot par rapport à d'autres mots. Ici, 2 seront retournés, ce qui signifie que le second mot 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;
    }
}

il s'agit d'une solution assez maladroite, mais qui devrait donner les bons résultats. Trouvez le substrat que vous recherchez dans la chaîne, et trouvez les charachteurs avant et après votre substrat. Cochez ces cases en utilisant leurs valeurs ascii (int)substring.charAt(x); pour voir si ce sont des lettres ou non. Si elles ne sont pas toutes les deux des lettres, ou tombent en dehors des limites de la corde, vous savez que vous avez trouvé un mot. Autrement, vous savez que cela fait simplement partie d'un mot.

la logique soyez très long - c'est pourquoi je ne le coderai pas pour vous, mais donnez-moi une chance et faites-moi savoir si vous avez besoin de clarification.

Hlo. Vous pouvez diviser la phrase en tableau puis la mettre en liste. après cela, vous pouvez utiliser la méthode contains pour vous vérifier mot est présent ou pas. 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;
}

}

utiliser contient la méthode

boolean isPresent(String word, String sentence)
{
return sentence.contains(word);   
}

EDIT: si vous voulez rechercher un mot particulier, vous pouvez ajouter un espace avant et après la chaîne de mots

mot = ""+ mot + " ";