逐行迭代文本文件的内容 - 是否有最佳实践？ （与PMD的AssignmentInOperand相比）

Question

我们有一个 Java 应用程序，它有一些能够读取文本文件的模块。他们使用这样的代码非常简单：

BufferedReader br = new BufferedReader(new FileReader(file));  
String line = null;  
while ((line = br.readLine()) != null)  
{  
   ... // do stuff to file here  
} 

我在我的项目上运行了PMD，并在while (...)<中遇到了“AssignmentInOperand”违规。 /代码>行。

除了显而易见的方法之外，是否还有更简单的方法来执行此循环：

String line = br.readLine();  
while (line != null)  
{  
   ... // do stuff to file here  
   line = br.readLine();  
} 

这是否被认为是更好的实践？ （尽管我们“复制”了 line = br.readLine() 代码？）

Answer 1

我知道这是一篇旧帖子，但我（几乎）有同样的需求，我使用 Apache Commons 中 FileUtils 的 LineIterator 解决了它。
从他们的 javadoc：

LineIterator it = FileUtils.lineIterator(file, "UTF-8");
try {
    while (it.hasNext()) {
    String line = it.nextLine();
    // do something with line
    }
} finally {
    it.close();
}

检查文档：
http://commons .apache.org/proper/commons-io/javadocs/api-release/org/apache/commons/io/LineIterator.html

Answer 2

对 流 和 java-8 和 Try-With-Resources 允许您以更紧凑的语法实现您想要的效果。

Path path = Paths.get("c:/users/aksel/aksel.txt");

try (Stream<String>  lines = Files.lines(path)) {
    lines.forEachOrdered(line->System.out.println(line));
} catch (IOException e) {
    //error happened
}

Answer 3

我经常使用 while((line = br.readLine()) != null) 构造...但是，最近我遇到了这个不错的替代方案：

BufferedReader br = new BufferedReader(new FileReader(file));

for (String line = br.readLine(); line != null; line = br.readLine()) {
   ... // do stuff to file here  
}

这仍然是重复 readLine() 调用代码，但逻辑很清晰，等等。

另一次我使用 while(( ... ) ...) 构造是从流读取到 byte[] 数组时...

byte[] buffer = new byte[size];
InputStream is = .....;
int len = 0;
while ((len = is.read(buffer)) >= 0) {
    ....
}

这也可以转换为 for 循环with：

byte[] buffer = new byte[size];
InputStream is = .....;
for (int len = is.read(buffer); len >= 0; len = is.read(buffer)) {
    ....
}

我不确定我是否真的更喜欢 for 循环替代方案......但是，它会满足任何 PMD 工具，并且逻辑仍然清晰，等等。

Answer 4

我一般更喜欢前者。我一般不喜欢比较中的副作用，但这个特定的例子是一个惯用语，它是如此常见和方便，以至于我不反对它。

（在 C# 中，有一个更好的选择：返回一个 IEnumerable 的方法，您可以使用 foreach 对其进行迭代；这在 Java 中没有那么好，因为在末尾没有自动处置增强的 for 循环...而且还因为您不能从迭代器中抛出 IOException，这意味着您不能只是将其中一个替换为另一个。

）方式：重复行问题比操作数内赋值问题更困扰我。我习惯于一目了然地接受这种模式 - 对于重复的行版本，我需要停下来检查一切是否都在正确的位置。这可能是一种习惯，但我不认为这是一个问题。

Answer 5

根据 Jon 的回答，我认为创建一个装饰器来充当文件迭代器应该很容易，这样您就可以使用 foreach 循环：

public class BufferedReaderIterator implements Iterable<String> {

    private BufferedReader r;

    public BufferedReaderIterator(BufferedReader r) {
        this.r = r;
    }

    @Override
    public Iterator<String> iterator() {
        return new Iterator<String>() {

            @Override
            public boolean hasNext() {
                try {
                    r.mark(1);
                    if (r.read() < 0) {
                        return false;
                    }
                    r.reset();
                    return true;
                } catch (IOException e) {
                    return false;
                }
            }

            @Override
            public String next() {
                try {
                    return r.readLine();
                } catch (IOException e) {
                    return null;
                }
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }

        };
    }

}

公平警告：这会抑制读取期间可能发生的 IOExceptions，并简单地停止读取过程。目前还不清楚 Java 中是否有一种方法可以解决这个问题，而不会引发运行时异常，因为迭代器方法的语义已明确定义，并且必须遵守才能使用 for-each 语法。另外，在这里运行多个迭代器会产生一些奇怪的行为；所以我不确定这是否值得推荐。

不过，我确实对此进行了测试，并且确实有效。

无论如何，您可以使用 for-each 语法作为一种装饰器来受益：

for(String line : new BufferedReaderIterator(br)){
    // do some work
}

Answer 6

我有点惊讶没有提到以下替代方案：

while( true ) {
    String line = br.readLine();
    if ( line == null ) break;
    ... // do stuff to file here
}

在 Java 8 之前，它是我最喜欢的，因为它清晰且不需要重复。 IMO，break 是具有副作用的表达式的更好选择。不过，这仍然是一个习语问题。

Answer 7

Google 的 Guava Libraries 提供了使用静态方法的替代解决方案CharStreams.readLines(Readable, LineProcessor) 以及用于处理每一行的 LineProcessor 实现。

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
    CharStreams.readLines(br, new MyLineProcessorImpl());
} catch (IOException e) {
    // handling io error ...
}

while 循环的主体现在放置在 LineProcessor 实现中。

class MyLineProcessorImpl implements LineProcessor<Object> {

    @Override
    public boolean processLine(String line) throws IOException {
        if (// check if processing should continue) {
            // do sth. with line
            return true;
        } else {
            // stop processing
            return false;
        }
    }

    @Override
    public Object getResult() {
        // return a result based on processed lines if needed
        return new Object();
    }
}

Answer 8

在 PMD 中，AssignmentInOperand 是一个有争议的规则，该规则的原因是：“这会使代码更加复杂且难以阅读”（请参考 http://pmd.sourceforge.net/rules/controversial.html)

如果您确实想这样做，您可以禁用该规则。就我而言，我更喜欢前者。