Java，对象化文件中的唯一字符并通过字符对象的increment()方法计算出现次数

Question

我正在开发一个java程序，它接受一个文本文件作为输入，为每个字符创建一个“CharacterFrequency”对象并计算每个字符出现的次数。到目前为止，我已经为构建对象构建了类，该类似乎以其当前形式起作用，但我在主循环中的逻辑程序流方面遇到了问题。我不知道如何构造 for if else while 循环等来循环字符并增加每个对象的计数。

有些人要求澄清，所以让我尝试用其他术语来表达。

从第一个字符对象开始，如果我们循环遍历 charArray 数组，我首先看到一个新字符，我需要为其创建一个新的 CharacterFrequency 对象，然后继续迭代 charArray 并找到更多出现的情况并对其进行计数通过使用CharacterFrequency 类的increment() 方法对文档中找到的特定字符进行递增。最终结果是找到的每个字符的 CharacterFrequency 对象以及出现次数。

任何帮助将不胜感激。谢谢。

主循环:

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.io.FileReader;
import java.io.IOException;

public class CharFreqMain {

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

        //declare variables and object types
        ArrayList<CharacterFrequency> charObjectsArray = new ArrayList<CharacterFrequency>();


        //try to open file and if not found catch file not found exception and exit
        try {
            //create scanner object of text file BufferedReader for efficiency
            BufferedReader br = new BufferedReader(new FileReader("C:/text.txt"));

            //create string to store each line
            String s;

            //while loop reads each line of BufferedReader br and creates string
            while ((s = br.readLine()) != null) {

                //create character array from string s
                char[] charArray = s.toCharArray();
                CharacterFrequency newcharobj = new CharacterFrequency();
                System.out.println(charArray);

                //iterate though character array
                for (char c : charArray) {

                    //check if the current object has the same character being checked and increment
                    if (c == newcharobj.getCharacter()) {
                        newcharobj.increment(1);
                    }
                    else {
                        newcharobj.setCharacter(c);
                    }

                    charObjectsArray.add(newcharobj);
                }
            }

            //close BufferedReader br
            br.close();
        }

        //code speaks for itself
        catch (FileNotFoundException e) {
            System.out.println("File Not Found");
            System.exit(0);
        }

        finally {

            //iterate through objects in charObjs Array and print characters and freqs to console
            for (CharacterFrequency charObject : charObjectsArray) {

                try {
                    System.out.println(charObject.getCharacter() + " | " + charObject.getFrequency());

                }
                catch(NullPointerException e) {

                }

                //build write to file Here
            }
        }
    }
}

字符频率类别:

public class CharacterFrequency {

    char character;
    int frequency;
    int i;
    int freq = 0;

    public char getCharacter() {
        return this.character;
    }

    public void setCharacter(char character) {
        this.character = character;
    }

    public int getFrequency() {
        return this.frequency;
    }

    public void setFrequency(int frequency) {
        this.frequency = frequency;
    }

    public void increment(int i) {
        freq = freq + i;
    }

}

这部分代码具体是我需要帮助的:

        //create character array from string s
        char[] charArray = s.toCharArray();
        CharacterFrequency newcharobj = new CharacterFrequency();
        System.out.println(charArray);

        //iterate though character array
        for (char c : charArray) {

            //check if the current object has the same character being checked and increment
            if (c == newcharobj.getCharacter()) {
                newcharobj.increment(1);
            }
            else {
                newcharobj.setCharacter(c);
            }

            charObjectsArray.add(newcharobj);
        }
    }

Answer 1

据我所知，您似乎想阅读每一行，然后构建 CharacterFrequency每个字符的对象及其出现的次数。

这可以通过 Java 流 API 轻松完成:

List<CharacterFrequency> resultSet =
                new BufferedReader(new FileReader("C:/text.txt"))
                .lines()
                .flatMap(s -> s.chars().mapToObj(a -> (char)a))
                .collect(Collectors.groupingBy(Function.identity(),
                        Collectors.summingInt(e -> 1)))
                .entrySet()
                .stream()
                .map(e -> new CharacterFrequency(e.getKey(), e.getValue()))
                .collect(Collectors.toCollection(ArrayList::new));

这假设您在CharacterFrequency中有一个构造函数类如下:

public CharacterFrequency(char character, int frequency) {
      this.character = character;
      this.frequency = frequency;
}

破译上述解决方案:

• lines BufferedReader的方法上面的结果是 Stream<String> ，其中元素是从中读取的行 BufferedReader .
• .flatMap(s -> s.chars().mapToObj(a -> (char)a))会将每个字符串转换为 Stream<Character>其中flatMap然后折叠所有嵌套的 Stream<Stream<Character>>成单Stream<Character> .
• 与.collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(e -> 1))) 我们检索 Map<Character, Integer>其中键是字符，整数表示给定字符出现的次数。
• 然后我们从 entrySet 创建一个流与 .entrySet().stream()并创建CharacterFrequency带有 .map(e -> new CharacterFrequency(e.getKey(), e.getValue())) 的对象
• 最后，我们收集到一个列表实现 .collect(Collectors.toCollection(ArrayList::new));