Je suis en train d'écrire une logique de programme java pour l'impression wrods avec le nombre de occurance et le numéro de ligne. Voici le code
package test;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class Countcharacters {
/**
* @param args
*/
static HashMap<String, Integer> countcharact=new HashMap<>();
static HashMap<String, String> linenumbertrack=new HashMap<>();
static int count=1;
static void countwords(String line){
//System.out.println(line);
String[] input=line.split("\\s");
int j=0;
String linenumber="";
for(int i=0;i<input.length;i++){
//System.out.println(input[i]);
if(countcharact.containsKey(input[i])==true){
j=countcharact.get(input[i]);
linenumber=linenumbertrack.get(input[i]);
countcharact.put(input[i],j+1);
linenumbertrack.put(input[i],linenumber+", "+count);
}
else{
countcharact.put(input[i], 1);
linenumbertrack.put(input[i],count+"" );
}
}
count++;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
String inp="the quick brown fox jumped over the lazy dog's bowl.\nthe dog was angry with the fox for considering him lazy.";
String[] line=inp.split("\n");
for(int i=0;i<line.length;i++){
Countcharacters.countwords(line[i]);
}
Set<String> s=countcharact.keySet();
for(String c:s){
System.out.println(c+" "+countcharact.get(c)+" "+"["+linenumbertrack.get(c)+"]");
}
}
}
La sortie que je reçois est
over 1 [1]
quick 1 [1]
lazy. 1 [2]
lazy 1 [1]
considering 1 [2]
jumped 1 [1]
was 1 [2]
for 1 [2]
angry 1 [2]
brown 1 [1]
him 1 [2]
fox 2 [1, 2]
the 4 [1, 1, 2, 2]
with 1 [2]
bowl. 1 [1]
dog's 1 [1]
dog 1 [2]
Mais j'ai deux question.
1er: si vous voyez « la » occurrence est 4 mais le nombre de ligne est [1,1,2,2] Il devrait plutôt être [1,2] seulement.
2: Je veux les trier. Il doit être d'abord trié par ordre décroissant de cardinalité puis par ordre alphabétique.
Comme ça:
the 4 [1,2]
fox 2 [1,2]
lazy 2 [1,2]
angry 1 [1]
bowl 1 [1]
.
.
Il est toujours préférable d'abstraire unités logiques loin de données au sein des classes. Dans votre problème, vous avez deux unités claires:
occurrence de mots (chaîne de texte et les numéros de ligne).
class WordOccurrence { private final String word; private final int lineNumber; ... }Statistiques sur les mots (occurrences nombre, série de numéros de ligne où ils se produisent, etc.).
class WordStats { private List<Word> occurrences; public String getWord() { ... } public int getCount() { ... } public Set<Integer> getLines() { ... } }
Avec ces classes , vous pouvez d' abord décomposer votre textdans un Mapde Listde WordOccurrence; donc pour chaque autre mot, Mapcontiendra une entrée avec:
- Clé égale à la réelle
Stringmot - Valeur égale à une
Listcontenant desWordOccurrenceobjets pour chacune de ses occurrences dans letext
Vous pouvez y parvenir avec quelque chose comme:
public static Map<String, List<WordOccurrence>> createOccurrencesMap(String text) {
text = text.replaceAll("\\.", " ");
// text = text.replaceAll("'s", ""); // dog's != dog ???
Map<String, List<WordOccurrence>> result = new HashMap<>();
String[] lines = text.split("\n");
for (int i = 0; i < lines.length; i++)
for (String word : lines[i].split("\\s+"))
result.computeIfAbsent(word, w -> new ArrayList<>())
.add(new WordOccurrence(word, i + 1));
return result;
}
Ensuite , vous pouvez facilement transformer cette carte en Listde WordStats( en utilisant un critère trié paramétrables flexible) avec quelque chose comme ceci:
List<WordStats> createStats(String text, Comparator<WordStats> sortingCriteria) {
return createOccurrencesMap(text).values().stream()
.map(WordStats::new)
.sorted(sortingCriteria)
.collect(Collectors.toList());
}
Et c'est tout! Une fois que vous cassez votre problème en petits composants intuitivement regroupées de manière logique (classes, méthodes, structures de données, etc.), la seule chose à gauche est de les câbler tout.
Le code suivant est une démonstration de travail complète de cette solution pour vous de jouer avec:
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
public class CountWords {
public static void main(String[] args) {
String text = "the quick brown fox jumped over the lazy dog's bowl.\nthe dog was angry with the fox for considering him lazy.";
Comparator<WordStats> sortingCriteria = Comparator
.comparing(WordStats::getCount).reversed()
.thenComparing(WordStats::getWord);
createStats(text, sortingCriteria).forEach(System.out::println);
}
public static List<WordStats> createStats(String text, Comparator<WordStats> sortingCriteria) {
return createOccurrencesMap(text).values().stream()
.map(WordStats::new)
.sorted(sortingCriteria)
.collect(Collectors.toList());
}
public static Map<String, List<WordOccurrence>> createOccurrencesMap(String text) {
text = text.replaceAll("\\.", " ");
// text = text.replaceAll("'s", ""); // dog's != dog ???
Map<String, List<WordOccurrence>> result = new HashMap<>();
String[] lines = text.split("\n");
for (int i = 0; i < lines.length; i++)
for (String word : lines[i].split("\\s+"))
result.computeIfAbsent(word, w -> new ArrayList<>())
.add(new WordOccurrence(word, i + 1));
return result;
}
static class WordStats {
private List<WordOccurrence> occurrences;
public WordStats(List<WordOccurrence> words) {
this.occurrences = words;
}
public String getWord() {
return occurrences.get(0).getWord();
}
public int getCount() {
return occurrences.size();
}
public Set<Integer> getLines() {
return occurrences.stream().map(WordOccurrence::getLineNumber).collect(Collectors.toSet());
}
public String toString() {
return String.format("%s %d %s", getWord(), getCount(), getLines());
}
}
static class WordOccurrence {
private final String word;
private final int lineNumber;
public WordOccurrence(String word, int lineNumber) {
this.word = word;
this.lineNumber = lineNumber;
}
public String getWord() {
return word;
}
public int getLineNumber() {
return lineNumber;
}
public String toString() {
return word + "@" + lineNumber;
}
}
}
J'espère que cela t'aides.