Estoy escribiendo una lógica de programación Java para imprimir wrods con el número de ocurrencia y número de línea. A continuación se muestra el código
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 salida que estoy recibiendo es
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]
Pero estoy teniendo dos números.
Primero: si ve "la" ocurrencia es 4, pero el número de línea es [1,1,2,2] en lugar que debería ser [1,2] solamente.
Segunda: Quiero ordenarlos. Se debe clasificarse por primera vez por orden de cardinalidad y el orden alfabético descendente continuación.
Me gusta esto:
the 4 [1,2]
fox 2 [1,2]
lazy 2 [1,2]
angry 1 [1]
bowl 1 [1]
.
.
Siempre es mejor a las unidades de distancia lógicos abstractos de datos dentro de las clases. En su problema tiene dos unidades claras:
Palabras ocurrencia (cadena de palabras y números de línea).
class WordOccurrence { private final String word; private final int lineNumber; ... }Estadísticas sobre los sucesos palabras (número, serie de números de línea en el que se producen, etc).
class WordStats { private List<Word> occurrences; public String getWord() { ... } public int getCount() { ... } public Set<Integer> getLines() { ... } }
Con estas clases primero puede romper su texten una Mapde las Listde WordOccurrence; por lo que para cada palabra diferente, el Mapcontendrán una entrada con:
- Clave igual a la real
Stringpalabra - Valor igual a A
Listque contienenWordOccurrenceobjetos para cada una de sus ocurrencias en eltext
Usted puede lograr esto con algo como:
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;
}
A continuación, puede transformar fácilmente en un mapa Listde WordStats(ordenados usando un criterio parametrizables flexibles) con algo como esto:
List<WordStats> createStats(String text, Comparator<WordStats> sortingCriteria) {
return createOccurrencesMap(text).values().stream()
.map(WordStats::new)
.sorted(sortingCriteria)
.collect(Collectors.toList());
}
¡Y eso es! Una vez que usted analiza el problema en componentes más pequeños intuitivamente agrupados de forma lógica (clases, métodos, estructuras de datos, etc.), lo único que queda es conectar a todos ellos.
El código siguiente es una demostración de trabajo completo de esta solución para que usted juegue con:
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;
}
}
}
Espero que esto ayude.