使用ASCII行处理Java IO的最快方法

我正在通过套接字处理ASCII输入/输出流，速度至关重要。我听说使用正确的Java技术确实会带来不同。我有一本教科书说使用缓冲区是最好的方法，但也建议使用DataInputStreamReader链接

对于输出，我使用了一个带OutputStreamWriter的BufferedOutputStream，这似乎很好。但是我不确定输入流使用什么。我正在开发新的生产线，所以扫描仪有用吗？速度至关重要，我需要尽快从网络上获取数据

谢谢

---

PH

A

扫描仪

用于分隔文本。你没有谈论你的数据是什么样子的，所以我不能对此发表评论

如果只想一直读到每个换行符，请使用

BufferedReader r=新的BufferedReader（新的InputStreamReader（Socket.getInputStream（））

及

r.readLine（）

当您得到一个空值时，您将知道您已经耗尽了流中的数据

---

就速度而言，它们都只是从流中读取数据。因此，假设您不需要

扫描仪的额外功能，我看不出使用它有什么特别的原因。
我会使用BufferedReader来执行以下操作：

Collection<String> lines = new ArrayList<String>();
BufferedReader reader = new BufferedReader( new InputStreamReader( Foo.getInputStream()));
while(reader.ready())
{
    lines.add( reader.readLine());
}

myClass.processData(lines); //Process the data after it is off the network.

集合行=新建ArrayList（）；
BufferedReader=新的BufferedReader（新的InputStreamReader（Foo.getInputStream（））；
while（reader.ready（））
{
添加（reader.readLine（））；
}
myClass.processData（行）//在数据脱离网络后对其进行处理。

根据您的情况，您可能会有一个额外的线程来处理“行”中的项目，因为它会被填充，但是您需要使用一个不同的结构来支持集合—一个可以同时使用的结构

编辑：这里是另一个例子


编辑2：我写这个微基准是为了让你开始测量各种方法的性能。一些人评论说，NIO的执行速度不会更快，因为您需要做更多的工作来将数据“按摩”成可用的形式，这样您就可以根据您试图做的任何事情来验证它。当我在我的机器上运行这段代码时，NIO代码在45兆字节的文件中大约快3倍，在100兆字节的文件中快5倍

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Scanner;

public class TestStuff {

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

        final String file_path = "c:\\test-nio.txt";
        readFileUsingNIO(file_path);
        readFileUsingScanner(file_path);

    }

    private static void readFileUsingScanner(final String path_to_file)
            throws FileNotFoundException {
        Scanner s = null;

        final StringBuilder builder = new StringBuilder();
        try {
            System.out.println("Starting to read the file using SCANNER");
            final long start_time = System.currentTimeMillis();
            s = new Scanner(new BufferedReader(new FileReader(path_to_file)));
            while (s.hasNext()) {
                builder.append(s.next());
            }
            System.out.println("Finished!  Read took " + (System.currentTimeMillis() - start_time) + " ms");
        }
        finally {
            if (s != null) {
                s.close();
            }
        }

    }

    private static void readFileUsingNIO(final String path_to_file)
            throws IOException {
        FileInputStream fIn = null;
        FileChannel fChan = null;
        long fSize;
        ByteBuffer mBuf;

        final StringBuilder builder = new StringBuilder();
        try {
            System.out.println("Starting to read the file using NIO");
            final long start_time = System.currentTimeMillis();
            fIn = new FileInputStream("c:\\test-nio.txt");
            fChan = fIn.getChannel();
            fSize = fChan.size();
            mBuf = ByteBuffer.allocate((int) fSize);
            fChan.read(mBuf);
            mBuf.rewind();
            for (int i = 0; i < fSize; i++) {
                //System.out.print((char) mBuf.get());
                builder.append((char) mBuf.get());
            }
            fChan.close();
            fIn.close();
            System.out.println("Finished!  Read took " + (System.currentTimeMillis() - start_time) + " ms");
        }
        catch (final IOException exc) {
            System.out.println(exc);
            System.exit(1);
        }
        finally {
            if (fChan != null) {
                fChan.close();
            }
            if (fIn != null) {
                fIn.close();
            }
        }

    }

导入java.io.BufferedReader；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
导入java.nio.ByteBuffer；
导入java.nio.channels.FileChannel；
导入java.util.Scanner；
公共类测试工具{
公共静态void main（最终字符串[]args）
抛出IOException、InterruptedException{
最终字符串文件\u path=“c:\\test nio.txt”；
readFileUsingNIO（文件路径）；
使用扫描仪读取文件（文件路径）；
}
使用scanner的私有静态void readfiles（到文件的最终字符串路径）
抛出FileNotFoundException{
扫描器s=null；
最终StringBuilder=新StringBuilder（）；
试一试{
System.out.println（“开始使用扫描仪读取文件”）；
最终长启动时间=System.currentTimeMillis（）；
s=新的扫描仪（新的BufferedReader（新的文件阅读器（路径到文件））；
而（s.hasNext（））{
append（s.next（））；
}
System.out.println（“完成！读取时间”+（System.currentTimeMillis（）-start_time）+“ms”）；
}
最后{
如果（s！=null）{
s、 close（）；
}
}
}
私有静态void readFileUsingNIO（到文件的最终字符串路径）
抛出IOException{
FileInputStream fIn=null；
FileChannel fChan=null；
长fSize；
ByteBuffer-mBuf；
最终StringBuilder=新StringBuilder（）；
试一试{
System.out.println（“开始使用NIO读取文件”）；
最终长启动时间=System.currentTimeMillis（）；
fIn=新文件输入流（“c:\\test nio.txt”）；
fChan=fIn.getChannel（）；
fSize=fChan.size（）；
mBuf=ByteBuffer.allocate（（int）fSize）；
fChan.read（mBuf）；
mBuf.倒带（）；
对于（int i=0；i
只是为了好玩

socket = new ServerSocket(2004, 10);
connection = socket.accept();
in = connection.getInputStream();
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
String line = null;
do {
    line = br.readLine();
} while (!"done".equals(line));

使用环回，即，在我的机器上，通过本地进程和适当的“愚蠢”客户端运行到本地主机

requestSocket=newsocket（“localhost”，2004）；
out=requestSocket.getOutputStream（）；
PrintWriter pw=新的PrintWriter（输出）；
字符串行=“…1000个字符长…”；
对于（int i=0；i<2000000-1；i++）{
pw.println（行）；
}
line=“完成”；
pw.println（行）；
pw.flush（）；

您会注意到，这发送了2M“1000字符”行。这只是一个粗略的吞吐量测试

在我的机器loopback上，我获得约190MB/秒的传输速率。字节，而不是比特。190000行/秒

我的观点是，使用bone stock Java sockets的“简单”方式非常快。这将使任何常见的网络连接饱和（这意味着网络将比这里的I/O更慢）

可能“足够快”

requestSocket = new Socket("localhost", 2004);
out = requestSocket.getOutputStream();
PrintWriter pw = new PrintWriter(out);
String line =  "...1000 characters long..."; 
for (int i = 0; i < 2000000 - 1; i++) {
    pw.println(line);
}
line = "done";
pw.println(line);
pw.flush();