我需要创建自己的方法 hasNextLine 与块读取和 system.lineseparator

问：

我已经为此苦苦挣扎了将近一个星期。我需要在我的类中创建一个函数，如果 system.in、字符串或文件中有下一行，则返回 true/false。（不管它是否会检测到最后一个空行，因为 Java 原始扫描程序也会这样做） 它应该根据我的技能（在大学学习 2 个月的 java）来编写——我们才刚刚开始编写我们的课程，这是一份家庭作业。我不需要你自己做，但我需要一个建议。我不能使用缓冲阅读器的下一行。我需要使用我自己的阻塞读取（字符数组 ~256-1024 个字符），当我使用该函数/方法时，我需要继续读取上次调用函数时的最后一个字符。

我试过了这个：它在 mac 上不起作用，但在 Windows 上有时它确实取决于缓冲区的大小（char 数组），但我不明白为什么。 此外，第一次读取可能具有 buffer[-1] = '\r' 并且 '\n' 可以在第二个缓冲区中，因此我需要创建一个字符串生成器来存储字符（在第二个字符添加到字符串构建器之前，tbh 1 个字符），然后它们将被识别为行分隔符。

public boolean hasNextLine() {
        refillIfNeeded();
        StringBuilder sep = new StringBuilder();
        while (true) {
            if (getCurrentID() == lastFilled(block)) {
                refillIfNeeded();
                newCurrentID(0);
            }
            if (countofread == -1) {
                break;
            }
            for (int i = getCurrentID(); i < lastFilled(block); i++) {
                if (block[i] == '\n' || block[i] == '\r') {
                    sep.append(block[i]);
                    System.out.println(sep.length());
                    if (sep.toString().equals(separator)) {
                        sep.setLength(0);
                        newCurrentID(i + 1);
                        return true;
                    }
                }
            }
            newCurrentID(lastFilled(block));
        }
        return false;
    }

函数及其代码可以在下面找到：

import java.io.*;

public class MyScanner {

    File source;
    String charsetName;
    String string;
    InputStream in;
    BufferedReader reader;
    int CurrentID = 0;
    char[] block = new char[16];
    int countofread = 0;

    String separator = System.lineSeparator();

    public MyScanner(File source, String charsetName) {
        this.source = source;
        this.charsetName = charsetName;
        try {
            reader = new BufferedReader(
                    new InputStreamReader(new FileInputStream(source), charsetName)
            );
        } catch (IOException e) {
            System.err.println("Unsupported Encoding or File Not Found");
        }
    }

    public MyScanner(File source) {
        this.source = source;
        try {
            reader = new BufferedReader(
                    new InputStreamReader(new FileInputStream(source))
            );
        } catch (FileNotFoundException e) {
            System.err.println("File Not Found");
        }
    }

    public MyScanner(String string) {
        this.string = string;
        reader = new BufferedReader(new StringReader(string));
    }

    public MyScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
    }

    public MyScanner(InputStream in, String charsetName) {
        try {
            reader = new BufferedReader(
                    new InputStreamReader(in, charsetName)
            );
        } catch (UnsupportedEncodingException e) {
            System.err.println("Unsupported Encoding");
        }
    }

    public void close() {
        try {
            reader.close();
        } catch (IOException e) {
            System.err.println("Can't close the scanner");
        }
    }

    public int fillBlock(char[] block) {
        try {
            countofread = reader.read(block);
        } catch (IOException e) {
            System.err.println("Can't fill the block");
        }
        return countofread;
    }

    public int getCurrentID() {
        return CurrentID;
    }

    public void newCurrentID(int newID) {
        CurrentID = newID;
    }

    public int lastFilled(char[] arr) {
        int last = arr.length - 1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == Character.MIN_VALUE) {
                last = i - 1;
                return last;
            }
        }
        return last;
    }

    public void refillIfNeeded() {
        if (getCurrentID() >= lastFilled(block)) {
            fillBlock(block);
        }
    }



    public boolean hasNextLine() {
        refillIfNeeded();
        StringBuilder sep = new StringBuilder();
        while (true) {
            if (getCurrentID() == lastFilled(block)) {
                refillIfNeeded();
                newCurrentID(0);
            }
            if (countofread == -1) {
                break;
            }
            for (int i = getCurrentID(); i < lastFilled(block); i++) {
                if (block[i] == '\n' || block[i] == '\r') {
                    sep.append(block[i]);
                    System.out.println(sep.length());
                    if (sep.toString().equals(separator)) {
                        sep.setLength(0);
                        newCurrentID(i + 1);
                        return true;
                    }
                }
            }
            newCurrentID(lastFilled(block));
        }
        return false;
    }





}