Conversion d'une chaîne de phrase en un tableau de chaîne de mots en Java
J'ai besoin que mon programme Java prenne une chaîne comme:
"This is a sample sentence."
et le transformer en un tableau de chaînes comme:
{"this","is","a","sample","sentence"}
Pas de règles ni de ponctuation (de préférence). En passant, l'entrée de chaîne est toujours une phrase.
Y at-il un moyen facile de faire cela que je ne vois pas? Ou devons-nous vraiment beaucoup rechercher des espaces et créer de nouvelles chaînes à partir des zones situées entre les espaces (qui sont des mots)?
String.split () fera presque tout ce que vous voulez. Vous devrez peut-être alors passer en revue les mots pour extraire toute ponctuation.
Par exemple:
String s = "This is a sample sentence.";
String[] words = s.split("\\s+");
for (int i = 0; i < words.length; i++) {
// You may want to check for a non-Word character before blindly
// performing a replacement
// It may also be necessary to adjust the character class
words[i] = words[i].replaceAll("[^\\w]", "");
}
Maintenant, ceci peut être accompli simplement avec split car il faut regex:
String s = "This is a sample sentence with []s.";
String[] words = s.split("\\W+");
cela donnera des mots comme: {"this","is","a","sample","sentence", "s"}
Le \\W+ correspond à tous les caractères non alphabétiques apparaissant une ou plusieurs fois. Donc, il n'y a pas besoin de remplacer. Vous pouvez vérifier d'autres modèles aussi.
Vous pouvez utiliser BreakIterator.getWordInstance pour rechercher 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;
}
Tester:
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]
Vous pouvez également utiliser BreakIterator.getWordInstance.
Vous pouvez simplement diviser votre chaîne comme ça en utilisant ceci regular expression
String l = "sofia, malgré tout aimait : la laitue et le choux !" <br/>
l.split("[[ ]*|[,]*|[\\.]*|[:]*|[/]*|[!]*|[?]*|[+]*]+");
La réponse la plus facile 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 faites juste "Ceci est un exemple de phrase" .split (""). Comme il faut une regex, vous pouvez également effectuer des scissions plus complexes, notamment en supprimant les signes de ponctuation et autres caractères indésirables.
Essayez d'utiliser ce qui suit:
String str = "This is a simple sentence";
String[] strgs = str.split(" ");
Cela créera une sous-chaîne à chaque index du tableau de chaînes en utilisant l’espace comme point de partage.
Utilisez string.replace(".", "").replace(",", "").replace("?", "").replace("!","").split(' ') pour diviser votre code en un tableau sans points, virgules, points d'interrogation ou d'exclamation. Vous pouvez ajouter/supprimer autant d'appels de remplacement que vous le souhaitez.
Essaye ça:
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] + "\"");
}
Voici un extrait de code qui scinde une phrase en Word et en donne le décompte.
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());
}
}
}
string.replaceAll () ne fonctionne pas correctement avec des paramètres régionaux différents de ceux prédéfinis. Au moins dans jdk7u10 .
Cet exemple crée un dictionnaire Word à partir de fichier texte avec le jeu de caractères Windows cyrillic 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();
}
Une autre façon de 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();
}
}
J'ai déjà posté cette réponse quelque part, je le ferai ici à nouveau. Cette version n'utilise aucune méthode incorporée majeure. Vous avez le tableau de caractères, convertissez-le en une 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
}
}
}
}
Vous pouvez utiliser le code suivant simple
String str= "This is a sample sentence.";
String[] words = str.split("[[ ]*|[//.]]");
for(int i=0;i<words.length;i++)
System.out.print(words[i]+" ");