非阻塞 (NIO) 读取行

Question

I need to read a file line by line using java.nio , but nio doesn't have a method like readline() to read one, complete line at a time. What solutions are there?

Answer 1

I understand you guys don't like limitations, but in case the one asking don't have access to IO package or not allowed to import it for some reason the top answer is not helpful...

Two ways to do it completely IO free:

1. java.nio.file.Files.lines , Returns a stream of lines, which is part of .util package and not .io package like bufferedReader.

2. java.nio.file.Files.readAllLines , Returns a collection of lines which is iterable. Proceed to use an iterator or for each to extract a single line.

cheers

Answer 2

Why? NIO doesn't support reading lines. You can read millions of lines a second with BufferedReader.readLine(). I suggest that is sufficient.

Answer 3

Oracle introduces a example in the tutorial. https://docs.oracle.com/javase/tutorial/essential/io/file.html#streams

Path file = ...;
try (InputStream in = Files.newInputStream(file);
    BufferedReader reader =
      new BufferedReader(new InputStreamReader(in))) {
    String line = null;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException x) {
    System.err.println(x);
}

Answer 4

Using java.nio.file.Files you can do:

Path path = FileSystems.getDefault().getPath("/path/to", "file.txt");
Files.lines(path).forEach(line ->
    // consume line
);

As the lines(path) method returns a Stream , you can take advantage of any other method of the Stream API, like reading just the first line (if one exists) with:

Optional<String> firstLine = Files.lines(path).findFirst();

Answer 5

It works for me....

 public static void main(String[] args) throws IOException 
    {
        RandomAccessFile aFile = new RandomAccessFile
                ("F:\\DetailsMy1.txt", "r");
        FileChannel inChannel = aFile.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1);
        StringBuffer line = new StringBuffer();
        while(inChannel.read(buffer) > 0)
        {
            buffer.flip();
            for (int i = 0; i < buffer.limit(); i++)
            {
                char ch = ((char) buffer.get());
                if(ch=='\r'){
                    System.out.print(line+"[EOL]");
                    line=new StringBuffer();
                }else{
                    line.append(ch);
                }
            }
            buffer.clear(); // do something with the data and clear/compact it.
        }
        inChannel.close();
        aFile.close();
    }

Answer 6

In support of EJP and others above, you might reference this article: http://www.javaworld.com/article/2078654/java-se/java-se-five-ways-to-maximize-java-nio-and-nio-2.html

In particular: "While NIO is often promoted for its performance advantages, it's more precise to say it is highly responsive. In some cases NIO actually performs worse than basic Java I/O. For simple sequential reads and writes of small files, for instance, a straightforward streams implementation might be two or three times faster than the corresponding event-oriented channel-based coding. Also, non-multiplexed channels -- that is, channels in separate threads -- can be much slower than channels that register their selectors in a single thread."

I would highlight the statement that NIO In some cases [...] performs worse than basic Java I/O . The author follows up with a list of questions to drive a quick analysis of whether NIO is the right choice. If you (or the next person to come along) still decides to pursue NIO there is a good explanation of its use with code example.

Answer 7

1) You could convert a BufferedReader to a Stream using the lines method

List<String> list = new ArrayList<>();

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
    list = br.lines().collect(Collectors.toList());    
}

2) Get a Stream directly using the Files.lines method:

try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
    stream
        .filter(s -> s.endswith("/"))
        .map(String::toUpperCase)
        .forEach(System.out::println);
}

As DanielBraun points out in his answer, you could also use the readAllLines method instead of the lines method, difference being, straight from the docs:

Unlike readAllLines, this method does not read all lines into a List, but instead populates lazily as the stream is consumed.

The package summary page from Java docs gives a nice and concise overview about Streams, and this article also lists out a few other ways of reading a file by line in Java.

Answer 8

NIO is typically used to do either direct memory access or block mediated bulk data transfers. It does do other things, but other features have more to do with blocking and non-blocking data access.

As such, you might want to use NIO to grab the data quickly (or in a non-blocking manner); however, if you want to "read line by line" you would be better served by doing the line detection after NIO has read in the available data. This could easily be implemented by putting a "line reading" facade over the buffer that NIO just read.

Answer 9

simply use: https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#lines-java.nio.file.Path-

EDIT (humanreadable translation, regards to MeetTitan): Which means: use java.nio.file.Files.lines(Path) - it returns a Stream<String> representing the lines of the file. It's an method provided by the Java API. One could consult the Javadoc in order to see the details. The most relevant information is therefore: Files.lines() exists since Java 1.8. Use it.