Conversion d'une chaîne de phrases en un tableau de mots en Java

Vous pouvez utiliser BreakIterator.getWordInstance pour trouver tous les mots d'une chaîne.

public static List<String> getWords(String text) {
    List<String> words = new ArrayList<String>();
    BreakIterator breakIterator = BreakIterator.getWordInstance();
    breakIterator.setText(text);
    int lastIndex = breakIterator.first();
    while (BreakIterator.DONE != lastIndex) {
        int firstIndex = lastIndex;
        lastIndex = breakIterator.next();
        if (lastIndex != BreakIterator.DONE && Character.isLetterOrDigit(text.charAt(firstIndex))) {
            words.add(text.substring(firstIndex, lastIndex));
        }
    }

    return words;
}

Test:

public static void main(String[] args) {
    System.out.println(getWords("A PT CR M0RT BOUSG SABN NTE TR/GB/(G) = RAND(MIN(XXX, YY + ABC))"));
}

Sortie:

[A, PT, CR, M0RT, BOUSG, SABN, NTE, TR, GB, G, RAND, MIN, XXX, YY, ABC]

Maintenant, cela peut être fait simplement avec split comme il faut regex:

String s = "This is a sample sentence with []s.";
String[] words = s.split("\W+");

cela va donner des mots comme: {"this","is","a","sample","sentence", "s"}

\W+ correspond à tous les caractères non-alphabétiques apparaissant une ou plusieurs fois. Donc, il n'est pas nécessaire de remplacer. Vous pouvez consulter d'autres modèles aussi.

Vous pouvez aussi utiliser BreakIterator.getWordInstance.

Vous pouvez simplement fendre votre chaîne comme ça en utilisant ceci expression

String l = "sofia, malgré tout aimait : la laitue et le choux !" <br/>
l.split("[[ ]*|[,]*|[\.]*|[:]*|[/]*|[!]*|[?]*|[+]*]+");

la réponse la plus simple et la meilleure à laquelle je puisse penser est d'utiliser la méthode suivante définie sur la chaîne java -

String[] split(String regex)

Et il suffit de faire "Ceci est un exemple de phrase".Split.)" "( Parce qu'il prend un regex, vous pouvez faire des divisions plus compliquées ainsi, qui peuvent inclure la suppression de ponctuation non désirée et d'autres caractères semblables.

Utiliser string.replace(".", "").replace(",", "").replace("?", "").replace("!","").split(' ') pour diviser votre code en un tableau sans point, virgule, Point d'interrogation, ou point d'exclamation. Vous pouvez ajouter / supprimer autant d'appels de remplacement que vous le souhaitez.

essayez d'utiliser ce qui suit:

String str = "This is a simple sentence";
String[] strgs = str.split(" ");

qui va créer une sous-chaîne à chaque index du tableau de chaînes en utilisant l'espace comme point de division.

essaye ceci:

String[] stringArray = Pattern.compile("ian").split(
"This is a sample sentence"
.replaceAll("[^\p{Alnum}]+", "") //this will remove all non alpha numeric chars
);

for (int j=0; i<stringArray .length; j++) {
  System.out.println(i + " \"" + stringArray [j] + "\"");
}

ci-dessous est un extrait de code qui divise un sentense en mot et donne son compte aussi.

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;

 public class StringToword {
public static void main(String[] args) {
    String s="a a a A A";
    String[] splitedString=s.split(" ");
    Map m=new HashMap();
    int count=1;
    for(String s1 :splitedString){
         count=m.containsKey(s1)?count+1:1;
          m.put(s1, count);
        }
    Iterator<StringToword> itr=m.entrySet().iterator();
    while(itr.hasNext()){
        System.out.println(itr.next());         
    }
    }

}

chaîne.replaceAll () ne fonctionne pas correctement avec des locales différentes de prédéfinies. Au moins en jdk7u10.

cet exemple crée un dictionnaire de mots à partir de textfile avec le jeu de caractères Cyrillique Windows CP1251

    public static void main (String[] args) {
    String fileName = "Tolstoy_VoinaMir.txt";
    try {
        List<String> lines = Files.readAllLines(Paths.get(fileName),
                                                Charset.forName("CP1251"));
        Set<String> words = new TreeSet<>();
        for (String s: lines ) {
            for (String w : s.split("\s+")) {
                w = w.replaceAll("\p{Punct}","");
                words.add(w);
            }
        }
        for (String w: words) {
            System.out.println(w);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

j'ai déjà posté cette réponse quelque part, je vais la refaire ici. Cette version n'utilise aucune méthode majeure intégrée. vous avez le tableau char, convertissez-le en chaîne. j'Espère que ça aide!

import java.util.Scanner;

public class SentenceToWord 
{
    public static int getNumberOfWords(String sentence)
    {
        int counter=0;
        for(int i=0;i<sentence.length();i++)
        {
            if(sentence.charAt(i)==' ')
            counter++;
        }
        return counter+1;
    }

    public static char[] getSubString(String sentence,int start,int end) //method to give substring, replacement of String.substring() 
    {
        int counter=0;
        char charArrayToReturn[]=new char[end-start];
        for(int i=start;i<end;i++)
        {
            charArrayToReturn[counter++]=sentence.charAt(i);
        }
        return charArrayToReturn;
    }

    public static char[][] getWordsFromString(String sentence)
    {
        int wordsCounter=0;
        int spaceIndex=0;
        int length=sentence.length();
        char wordsArray[][]=new char[getNumberOfWords(sentence)][]; 
        for(int i=0;i<length;i++)
        {
            if(sentence.charAt(i)==' ' || i+1==length)
            {
            wordsArray[wordsCounter++]=getSubString(sentence, spaceIndex,i+1); //get each word as substring
            spaceIndex=i+1; //increment space index
            }
        }
        return  wordsArray; //return the 2 dimensional char array
    }


    public static void main(String[] args) 
    {
    System.out.println("Please enter the String");
    Scanner input=new Scanner(System.in);
    String userInput=input.nextLine().trim();
    int numOfWords=getNumberOfWords(userInput);
    char words[][]=new char[numOfWords+1][];
    words=getWordsFromString(userInput);
    System.out.println("Total number of words found in the String is "+(numOfWords));
    for(int i=0;i<numOfWords;i++)
    {
        System.out.println(" ");
        for(int j=0;j<words[i].length;j++)
        {
        System.out.print(words[i][j]);//print out each char one by one
        }
    }
    }

}

une autre façon de le faire est StringTokenizer. ex: -

 public static void main(String[] args) {

    String str = "This is a sample string";
    StringTokenizer st = new StringTokenizer(str," ");
    String starr[]=new String[st.countTokens()];
    while (st.hasMoreElements()) {
        starr[i++]=st.nextElement();
    }
}

Vous pouvez utiliser le code simple suivant

String str= "This is a sample sentence.";
String[] words = str.split("[[ ]*|[//.]]");
for(int i=0;i<words.length;i++)
System.out.print(words[i]+" ");