J'ai 2 listes une pour la phrase une pour les mots-clés. L'idée est de vérifier si la phrase contient les mots-clés. et mettez-les dans une liste pour chaque phrase dans l'ordre.
Je suis désolé si cela est déjà dupliqué ici à l'avance.
[this,good,dog] [cats,milk] [are,beautiful]
Mon idée était de créer 2 boucles imbriquées pour chaque liste:
dog good this cats milk beautiful are
Le résultat de ceci est:
for (int b = 0; b < sentence.size(); b++) {
for (int c = 0; c < keyword.size(); c++) {
if (sentence.get(b).contains(keyword.get(c))) {
System.out.println(keyword.get(c));
}
}
}
Le résultat souhaité serait:
List <String> sentence= new ArrayList <>();
sentence.add("this is a good dog");
sentence.add("cats drink milk");
sentence.add("Animals are beautiful creatures");
List <String> keyword= new ArrayList <>();
keyword.add("dog");
keyword.add("cats");
keyword.add("beautiful");
keyword.add("good");
keyword.add("are");
keyword.add("this");
keyword.add("milk");
C'est comme obtenir tous les mots-clés existants, dans l'ordre de la phrase, sans rapport avec l'ordre des mots-clés.
puis regroupez les mots-clés existants pour chaque phrase , comme dans l'ordre d'existence.
J'espère que c'est clair. J'apprécierais vraiment toutes les idées. n'a pas à suivre la même méthode.
6 Réponses :
cela devrait le faire, en imprimant exactement au format que vous avez demandé:
for (int b = 0; b < sentence.size(); b++) {
String arr[] = sentence.get(b).split("\\s+");
List result = new ArrayList<>();
for (int c = 0; c < arr.length; c++ ) {
if (keyword.contains(arr[c]))
result.add(arr[c]);
}
System.out.println(result);
}
Essayez quelque chose comme ceci:
for (String sen: sentence) {
System.out.print("[");
boolean first = true;
for (String word: sen.split("[\\s\\p{Punct}]")) {
if (keyword.contains(word)) {
if (first) {
first = false;
} else {
System.out.print(",");
}
System.out.print(word);
}
}
System.out.println("]");
}
il est implicite de la sortie souhaitée que les résultats sont dans une liste. Je pense donc qu'il serait préférable que les résultats soient imprimés à partir d'une liste au lieu d'imprimer explicitement ',' et '[]'
@funkyjelly c'est ce que vous avez fait dans votre réponse.
J'utiliserais ce qui suit:
for(String currentSentence : sentence) {
List<String> keywordsInSentence = new ArrayList<>();
for (String word : currentSentence.split("\\s+")) {
if (keyword.contains(word)) {
keywordsInSentence.add(word);
}
}
System.out.println(keywordsInSentence);
}
Vous pouvez l'essayer ici a >.
(et je renommerais phrase en phrases ou phraseList et de même pour mot-clé code>, sinon c'est juste déroutant)
Si vous avez besoin de faire autre chose pour les mots-clés que de les afficher immédiatement, vous pouvez insérer les listes keywordsInSentence dans une Map > que vous valoriseriez en remplaçant System.out.println par map.put (currentSentence, keywordsInSentence) .
Je pense que Map serait un bon choix ici. Créez simplement des phrases clés pour la carte et des mots-clés comme valeur. Voici le code pour le même.
Map <String, ArrayList<String>> sentences= new HashMap<>();
sentences.put("this is a good dog", new ArrayList<>());
sentences.put("cats drink milk", new ArrayList<>());
sentences.put("Animals are beautiful creatures", new ArrayList<>());
List <String> keyword= new ArrayList <>();
keyword.add("dog");
keyword.add("cats");
keyword.add("beautiful");
keyword.add("good");
keyword.add("are");
keyword.add("this");
keyword.add("milk");
keyword.forEach(word -> sentences.entrySet().stream()
.filter(map -> map.getKey().contains(word)).
forEach(map -> sentences.computeIfAbsent(map.getKey(), key->new ArrayList<>()).add(word)));
sentences.forEach((key, value) -> System.out.println(value));
nécessite trop de modifications. Mais j'aime l'idée de toute façon. Je vous remercie !
Parcourez votre liste de phrases . Pour chaque phrase, parcourez votre liste de mots clés . Ajoutez chaque mot-clé trouvé trouvé dans une tempList, triez la tempList par l'index du mot-clé dans la phrase et enfin ajoutez chaque tempList à une liste de listes. Exemple:
public static void main(String[] args) {
List <String> sentence= new ArrayList <>();
sentence.add("this is a good dog");
sentence.add("cats drink milk");
sentence.add("Animals are beautiful creatures");
List <String> keyword= new ArrayList <>();
keyword.add("dog");
keyword.add("cats");
keyword.add("beautiful");
keyword.add("good");
keyword.add("are");
keyword.add("this");
keyword.add("milk");
List<List<String>> result = new LinkedList<>();
for(String sen: sentence){
List<String> tempList = new ArrayList<>();
for(String key: keyword){
if(sen.contains(key)){
tempList.add(key);
}
}
tempList.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return sen.indexOf(o1) - sen.indexOf(o2) ;
}
});
result.add(tempList);
}
for(List<String> r : result){
System.out.println(r);
}
}
Vous avez besoin d'une légère modification dans votre boucle
for (int i = 0; i < sentence.size(); i++) {
String[] matchArray = new String[sentence.get(i).split(" ").length];
for (int j = 0; j < keyword.size(); j++) {
if (sentence.get(i).contains(keyword.get(j))) {
matchArray[Arrays.asList(sentence.get(i).split(" ")).indexOf(keyword.get(j))] = keyword.get(j);
}
}
List<String> matchList = new ArrayList<String>();
for(String match: matchArray) {
if(match != null) {
matchList.add(match);
}
}
System.out.println(matchList);
}
Pour chaque phrase, créez un tableau avec la même taille que la phrase (juste pour assurer la taille). Maintenant, lorsque des correspondances sont trouvées, récupérez l'index de la correspondance à partir de la phrase et ajoutez un élément à cet index particulier du tableau . Ainsi, à la fin de l'itération des mots clés, vous aurez toutes les correspondances dans un tableau avec des valeurs null si certains mots ne correspondent pas.
Déclarez maintenant une nouvelle liste of String dans lequel ajoutent les éléments du tableau qui ne sont pas nuls. Imprimez enfin la liste.
Vous devez trier les correspondances dans l'ordre de leur apparition dans la phrase. Alors que votre approche affichera [dog, good, this] pour la première phrase, l'OP voulait que ce soit [this, good, dog] .
C'est une solution très souriante et bonne, mais sauf que l'ordre doit être tel qu'il est dans la phrase, pas par la liste des mots-clés.
@Sojimanatsu le code est maintenu pour garder l'ordre des phrases
ouais merci pour la suggestion, je le change de temps en temps en old school. Je chercherai la carte dans ce cas. cela a du sens pour moi, mais si vous pouviez donner un exemple, ce serait également bien.
utilisez
java.util.ArrayList.contains (Object)et supprimez la boucle imbriquée