我知道使用BufferedReader(包装FileReader)将比使用BufferedInputStream(包装FileInputStream)慢得多,因为原始字节必须转换为字符.但我不明白为什么它这么慢!以下是我正在使用的两个代码示例:
BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(filename));
try {
byte[] byteBuffer = new byte[bufferSize];
int numberOfBytes;
do {
numberOfBytes = inputStream.read(byteBuffer, 0, bufferSize);
} while (numberOfBytes >= 0);
}
finally {
inputStream.close();
}
和:
BufferedReader reader = new BufferedReader(new FileReader(filename), bufferSize);
try {
char[] charBuffer = new char[bufferSize];
int numberOfChars;
do {
numberOfChars = reader.read(charBuffer, 0, bufferSize);
} while (numberOfChars >= 0);
}
finally {
reader.close();
}
我已尝试使用各种缓冲区大小的测试,所有缓冲区大小都是150兆字节的文件.以下是结果(缓冲区大小以字节为单位;时间以毫秒为单位):
Buffer Input
Size Stream Reader
4,096 145 497
8,192 125 465
16,384 …我有一个InputStream我需要在开头和结尾添加字符,并应该以另一个类型的变量结束InputStream.我怎么能轻易做到这一点？
1)缓冲流如何在后台工作,它们与普通流有什么不同？使用它们的优点是什么？
2)DataInputStream也是以字节为基础的.但它有方法readLine().这里有什么意义？
为了在Java中获得最快的TCP传输速度,这是更好的:
选项A:
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
选项B:
BufferedInputStream in = new BufferedInputStream(socket.getInputStream());
BufferedOutputStream out = new BufferedOutputStream(socket.getOutputStream());
我已经读过,当将8 KiB写入OutputStream时,性能会受到影响,建议它一次性写入小块而不是pver 8 KiB.8 KiB是BufferedOutputStream的默认缓冲区大小.
但是我还读到,当通过网络传输数据时,尽可能快地清除字节是很好的.这意味着使用缓冲区并以小块写入会增加不必要的开销.
那么,选项A还是选项B？哪个效果最好？
现在我猜测选项A提供了最高的传输速度,同时消耗了比选项B更多的CPU.选项B可能更好,因为它没有那么慢,但节省了大量的CPU.
-
奖金问题:触摸TCP窗口大小是个好主意吗？例如,将其设置为64 KiB:
socket.setReceiveBufferSize(65536);
socket.setSendBufferSize(65536);
我尝试在测试机器上将其设置为128 KiB,因为我读到它可以提高速度但是当服务器有几个连接时,CPU是100%而不是2%,就像我单独离开时一样.我猜128 KiB太高了,除非你有一台能够处理流量急流的好服务器,但将它设置为32 KiB是否明智？我认为我的默认值是8 KiB.
("socket"是"java.net.Socket")
我有一个程序,我一直在努力下载文件.除非用户使用AVG,否则一切都很完美.奇怪的是,似乎为了解决这个问题,必须禁用AVG的"电子邮件保护"; 将我的程序或JRE添加到例外列表不起作用.
我通过使用从URL获得的BufferedInputStream下载内容.用户一直在报告下载过程开始正常,但冻结了~5%-15%(变化).使用JProgressBar显示下载进度.
有什么方法可以避免这种情况吗？不得不逐个处理它是一件痛苦的事......
我一直在寻找答案,但实际上找不到任何东西.今天早些时候,我问我如何通过字节数组将文件转换为字符串,然后再返回,以便稍后检索.
人们告诉我的是,我必须只存储字节数组,以避免令人讨厌的编码问题.所以现在我已经开始研究了这个问题,但现在我已经碰壁了.
基本上,我之前使用过无缓冲的流,将文件转换为字节数组.这在理论上很好用,但它会占用大量内存,最终会导致堆大小异常.我应该使用缓冲流(或者我被告知),而我现在遇到的问题是从BufferedInputStream到byte [].我试图复制并使用本文档中的方法
我为缓冲流交换无缓冲流的地方.唯一的问题是,我不能直接将缓冲输出流转换为字节数组,因为我可以使用无缓冲的流.
救命？:)
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public final class BufferedByteStream {
private static final int BUF_SIZE = 1024000;
public static long copy(BufferedInputStream from, BufferedOutputStream to) throws IOException {
byte[] buf = new byte[BUF_SIZE];
long total = 0;
while(true) {
int r = from.read(buf);
if(r == -1) {
break;
}
to.write(buf, 0, r);
total += r;
}
return total;
}
public static byte[] toByteArray(BufferedInputStream in) throws IOException {
BufferedOutputStream out = new …我正在编写一个简单的客户端/服务器应用程序,我发现使用DataInputStream读取数据非常方便,因为它允许您选择要读取的内容(无需自己从字节转换),但我想知道它是否会最好将它包装在BufferedInputStream中,或者如果这只会增加不必要的开销？
我问的原因是因为我不知道直接从套接字流中读取是多么昂贵(当使用BufferedInputStream时,它只会从套接字流中读取一次,然后使用DataInputStream从BufferedInputStream中乘以时间).
收到的数据通常很小,大约20-25字节.
提前感谢您的回答!:d
我试图使用以下代码从IHTTPSession.getInputStream()读取InputStream,但每次都给出Socket TimeOut异常.
private String readInStream(InputStream in){
StringBuffer outBuffer=new StringBuffer();
BufferedInputStream bis=new BufferedInputStream(in);
try {
while(bis.available()>0){
int ch= bis.read();
outBuffer.append((char)ch);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Log.e("DATA_Length", "outputBuffer :"+outBuffer.toString().length());
return outBuffer.toString();
}
我也尝试了以下方法,但出现了同样的异常
private String readInStream(InputStream in){
String line="";
StringBuffer outBuffer=new StringBuffer();
BufferedReader rd=new BufferedReader(new InputStreamReader(in));
try {
while((line=rd.readLine()) != null){
outBuffer.append(line);
}
} catch (IOException e) {
Log.e("IOException", "IOException in readInStream:");
e.printStackTrace();
}
Log.e("DATA_Length", "outputBuffer :"+outBuffer.toString().length());
return outBuffer.toString();
}
我试图使用File对象初始化FileInputStream对象.我在线上收到FileNotFound错误
fis = new FileInputStream(file);
这很奇怪,因为我已经通过相同的方法打开这个文件多次执行正则表达式.
我的方法如下:
private BufferedInputStream fileToBIS(File file){
FileInputStream fis = null;
BufferedInputStream bis =null;
try {
fis = new FileInputStream(file);
bis = new BufferedInputStream(fis);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return bis;
}
java.io.FileNotFoundException:C:\ dev\server\tomcat6\webapps\sample-site(拒绝访问)
java.io.FileInputStream.open(本机方法)
java.io.FileInputStream.(未知来源)
java
控制器上的controller.ScanEditRegions.process(ScanEditRegions.java:64)
处于controller.ScanEditRegions.tidyHTML(ScanEditRegions.java:38)
的controller.ScanEditRegions.fileToBIS(ScanEditRegions.java:52)
处的.io.FileInputStream.(未知来源)
.
.ScanEditRegions.visitAllDirsAndFiles(ScanEditRegions.java:148)
在controller.Manager.main(Manager.java:10)
java filenotfoundexception bufferedinputstream fileinputstream
我是Java流的新手，我想读取特定的文件内容，然后需要从头开始读取。我创建了一个 BufferedInputStream，但我对 BufferedInputStream.mark(int markLimit) 的文档感到困惑
文档说：
public void mark(int readlimit)
此方法在输入中标记一个位置，可以通过调用 reset() 方法将流“重置”到该位置。参数readlimit是设置标记后在标记失效之前可以从流中读取的字节数。例如，如果调用 mark() 时的读取限制为 10，那么当调用 reset() 方法之前从流中读取了 11 个字节的数据时，则该标记无效，并且不需要流对象实例记住标记。
请注意，此方法可以记住的字节数可以大于内部读取缓冲区的大小。它也不依赖于支持标记/重置功能的从属流。
覆盖： FilterInputStream 类中的标记
参数： readlimit - 标记失效之前可以读取的字节数**
我的代码是：
public class Test {
public static void main(String[] args) throws IOException {
File resource = new File("beforeFix.txt");
FileInputStream fileInputStream = new FileInputStream(resource);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
int i = bufferedInputStream.read();
bufferedInputStream.mark(1);
i = bufferedInputStream.read();
i = bufferedInputStream.read();
i = bufferedInputStream.read();
i = bufferedInputStream.read();
i = bufferedInputStream.read();
i = bufferedInputStream.read();
i …