Java-Datei-E/A: In welcher Bedingung sollte ich das doppelte Schreiben von Buchstaben in einer Textdatei stoppen?

Question

Also bin ich kurz davor, meinen Code für Zeichenhäufigkeit in Java zu beenden. Die Anweisungen sind also, eine Textdatei zu erhalten und die Zeichenhäufigkeiten (von A-Z, a-z und 0-9) in eine andere Textdatei zu speichern, aber die Anzahl der Frequenzen wird dort sortiert. Hier ist, was ich kam mit:

import java.io.File; 
    import java.io.FileNotFoundException; 
    import java.io.PrintWriter; 
    import java.util.Scanner; 

    import javax.swing.JFileChooser; 

public class Machine_Exer6 { 

public void charfrequency() { 
    // TODO Auto-generated method stub 
    File infile = null; 
    File result = null; 
    Scanner myscan = null; 
    JFileChooser fc= new JFileChooser(); 

    fc.showOpenDialog(null); 
    infile = fc.getSelectedFile(); 

    fc.setSelectedFile(new File("")); 

    fc.showSaveDialog(null); 
    result = fc.getSelectedFile(); 

    try { 
     myscan = new Scanner(infile); 
     while(myscan.hasNextLine()){ 
      String str = myscan.nextLine(); 
      Alphanumeric(str, result); 
     } 

    } catch (FileNotFoundException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    }finally{ 
     myscan.close(); 
    } 



} 

private void Alphanumeric(String str, File result) { 
    // TODO Auto-generated method stub 


    int ctr=0; 
    PrintWriter printtofile = null; 
    try { 
     printtofile = new PrintWriter(result); 
    } catch (FileNotFoundException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 

    try{ 
     for(int j=0; j<str.length(); j++){ 
      for (int i=0; i<str.length(); i++){ 
       if((str.charAt(j)==str.charAt(i) || str.charAt(j)==Character.toUpperCase(str.charAt(i))) && (Character.isAlphabetic(str.charAt(j)) || Character.isDigit(str.charAt(j)))){ 
        ctr++; 
       } 

      } 

      if (ctr!=0){ 
       printtofile.println(str.charAt(j)+": "+ctr); 
       ctr=0; 
      } 

     } 
    }finally{ 
     printtofile.close(); 
    } 

} 

Aber dann, als ich versuchen, eine Textdatei zu lesen, sagen wir, dass ihr Inhalt wie hat:

„Immer wenn

Wo auch immer, wo immer, wo immer

Sie sind

Ich werde lieben, lieben, lieben. "

Die erstellte Textdatei sieht wie folgt aus:

i: 2

w: 1

i: 2

l: 5

l: 5

l: 5

O: 3

v: 3

e: 3

l: 5

O: 3

v: 3

e: 3

l: 5

O: 3

v: 3

e: 3

, auch die Großbuchstaben in dem Kleinen Zähler nicht enthalten. Gibt es eine Möglichkeit, das zu beheben?

Answer 1

helfen Dies könnte:

import java.io.*; 
import java.util.*; 

public class Frequency { 

    private static final int DIGIT_START = 48; 
    private static final int DIGIT_END = 57; 
    private static final int UPPER_START = 65; 
    private static final int UPPER_END = 90; 
    private static final int LOWER_START = 97; 
    private static final int LOWER_END = 122; 

    private final BufferedReader reader; 
    private final Map<Character, Integer> frequencyCounter; 

    public Frequency(File file) throws FileNotFoundException { 

     reader = new BufferedReader(new FileReader(file)); 
     frequencyCounter = new HashMap<>(); 
    } 

    public void calculateFrequency() throws IOException { 

     int input; 

     while((input = reader.read()) != -1){ 
      if(isAlphaNeumeric(input)){ 
       char validInput = (char)Character.toLowerCase(input); 
       if(!frequencyCounter.containsKey(validInput)){ 
        frequencyCounter.put(validInput, 1); 
       } 
       else{ 
        frequencyCounter.put(validInput, 
         frequencyCounter.get(validInput) + 1); 
       } 
      } 
     } 
    } 

    public boolean isAlphaNeumeric(int toTest){ 

     return isAlphaNewNeumericHelp(toTest, DIGIT_START, DIGIT_END) || 
       isAlphaNewNeumericHelp(toTest, UPPER_START, UPPER_END) || 
       isAlphaNewNeumericHelp(toTest, LOWER_START, LOWER_END); 
    } 

    private boolean isAlphaNewNeumericHelp(int toTest, 
              int lowerBound,   
              int upperBound){ 

     return toTest >= lowerBound && toTest <= upperBound; 
    } 

    public void printFrequency(){ 

     final List<Map.Entry<Character, Integer>> stringCounts = 
      new ArrayList<>(frequencyCounter.entrySet()); 

     Collections.sort(stringCounts, 
      (o1, o2) -> o1.getKey().compareTo(o2.getKey())); 

     stringCounts.forEach(System.out::println); 
    } 

    public static void main(String[] args) throws IOException { 

     Frequency frequency = new Frequency(new File("file")); 
     frequency.calculateFrequency(); 
     frequency.printFrequency(); 
    } 
} 

Die Map verfolgt alle der Grafen. Nachdem Sie festgestellt haben, dass ein Zeichen gültig ist, erzwingen Sie es in Kleinbuchstaben und wandeln es in eine char. Wenn Map keinen Eintrag enthält, der dem gültigen Zeichen entspricht, fügen Sie einen hinzu, andernfalls aktualisieren Sie die Map Wertseite. Für jetzt einfach die sortierten Ergebnisse auf der Konsole ausdrucken.

Ich hoffe, es hilft.