FileWriter写文件数据大小超过8192就会出错???

[Brind]

import java.io.FileWriter;
import java.io.IOException;

public class TestFile {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

try {
FileWriter file = new FileWriter("1.txt");
char chRecvBuf[] = new char[4096];
int offset = 0;
for (int i = 0; i < 2; i++) {

file.write(chRecvBuf, offset, 4096);
offset += 4096;
}
file.close();

System.out.println("Ok");
} catch (IOException e) {
System.out.println(e.toString());
}
}

}

这段代码 for循环部分循环次数超过2就会出错, 难道FileWriter只能写小于4096的文件么?

[dlxu]

在file.write(chRecvBuf, offset, 4096);
后面加上
file.flush();
这么一句

[Brind]

FileWriter file = new FileWriter(m_strCmd.substring(4, m_strCmd.length()));
char chRecvBuf[] = new char[4096];
int nSize;
while(true)
{
nSize = m_sockIn.read(chRecvBuf);
if(nSize <= 0)
break;
file.write(chRecvBuf, 0, nSize);
}
file.close();

多谢楼上, 我改成这样就不出异常了. 不过用这断代码保存MP3不能播放...
是不是文件指针不动, 一直在写一个文件啊

[treeroot]

唉

[Brind]

想不通啊， 自己顶一下

[Brind]

不管用, 还是有异常

[treeroot]

晕呀,你的数组越界了呀!
和文件何干?

[maquan]

楼主看到的异常应该是 IndexOutOfBoundaryException 吧？
循环体内的 file.write(chRecvBuf, offset, 4096); 第二次被调用时，实际上是
file.write(chRecvBuf, 4096, 4096);
可是你的 chRecvBuf 的下标最多只能是 4095 啊！

[Brind]

楼上, 我有点不明白. 我的数组中实际是每次都有新的数据去更新它, 上面我只写了一部分代码. 实际每次循环都是从socket读取4096个字符, 然后往文件里写. 假如我的文件要1mb那数组的缓冲区也要1mb么?

StartSocket();
m_sockOut.write(m_strCmd);
m_sockOut.flush();

FileWriter file = new FileWriter(m_strCmd.substring(4, m_strCmd.length()));
char chRecvBuf[] = new char[4096];
int nSize, offset = 0;
while(true)
{
nSize = m_sockIn.read(chRecvBuf);
if(nSize <= 0)
break;

file.write(chRecvBuf, offset, nSize);
offset += nSize;
}
file.close();

StopSocket();

[ibiswang]

你对 file.write(chRecvBuf, offset, length); API更本没有理解。

chRecvBuf:是将要被写到文件中的字节数组----源;
offset:是由源中，即chRecvBuf中何处开始取字节值；----我想你理解为由文件的何处开始写。
length:是由chRecvBuf中取多少字串写到文件中.

也就是说，它代表的意思是：将chREcvBuf中由offset开始先后length个字节写入到文件中。

我想，你的理解是：从文件offset开始，将chrecvbuf中长度为lenght的字串写到文件中。

[Brind]

楼上你的例子, 不适用我的情况. 你的是知道文件有多大然后缓冲区就顶那么大, 缓冲区 == 文件大小. 我的是不知道文件有多大, 所以缓冲区定义4096 每次循环都从socket读取新的内容. 可是java的文件操作很奇怪

while(true)
{
nSize = m_sockIn.read(chRecvBuf); 每次循环都会从socket中读取新的数据
if(nSize <= 0)
break;
file.write(chRecvBuf, 0, nSize); 这个偏移量(offset)是缓冲区的偏移为什么不是物理文件的偏移啊? write之后再次被调用时是否还是从文件头开始写啊?
offset += nSize;
}

[mingxuan3000]

up

[interpb]

你可以
seek()已经存在的字节

[crazycy]

呵呵

[Brind]

我的输入是socket用你的方法可以么？ 一个是SOCKET 一个是FileOutputStream fileOut 这样能用么？

[紫炎圣骑]

MP3还是用流读写吧

简单写了一下，你可以参考参考
File file = new File("f:/download/fsx.wmv");
FileInputStream fileIn = new FileInputStream(file);

File out = new File("f:/download/aaa.wmv");
if (out.exists())
{
out.delete();
}
out.createNewFile();

FileOutputStream fileOut = new FileOutputStream(out);

final int MAX_BYTE = 60000000;
long streamTotal = 0;
int streamNum = 0;
int leave = 0;
byte[] b = null;
int i = 0;

streamTotal = fileIn.available();
streamNum = (int) Math.floor(streamTotal / MAX_BYTE);
leave = (int) streamTotal % MAX_BYTE;

b = new byte[(int) streamTotal];
while ((i = fileIn.read(b)) != -1)
{

fileOut.write(b, 0, b.length);
}

//如果mp3大于60m，那就得拆分来写了，因为byte数组只支持60m
// if(streamNum > 0)
// {
// for (int j = 0; j < streamNum; j++)
// {
// b = new byte[MAX_BYTE];
// fileIn.read(b, 0, MAX_BYTE);
// fileOut.write(b);
// fileOut.flush();
// }
// }
//
// b = new byte[leave];
// fileIn.read(b, 0, leave);
// fileOut.write(b);
// fileOut.flush();

fileIn.close();
fileOut.close();

[Brind]

问题终于解决了, 最后用RandomAccessFile 并且seek 想了半天才发现错在缓冲区是char 而传输二进制文件应该用byte.

-------------------------------------------------------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.net.InetSocketAddress;
import java.net.Socket;

public class Console {

Socket m_sock;
InetSocketAddress m_IpAddress;
PrintWriter m_sockOut;
BufferedReader m_sockIn;
BufferedReader m_cmdIn;
String m_strCmd, m_strIp;
int m_nPort;

void Initial(String strIp, int nProt)
{
m_cmdIn = new BufferedReader(new InputStreamReader(System.in));
m_strIp = strIp;
m_nPort = nProt;
System.out.println("-------------- 终端维护系统 --------------");
}

void StartSocket()
{
m_IpAddress = new InetSocketAddress(m_strIp, m_nPort);
m_sock = new Socket();
try
{
m_sock.connect(m_IpAddress, 100);
m_sock.setSoTimeout(3000);

m_sockIn = new BufferedReader(new InputStreamReader(m_sock.getInputStream()));
m_sockOut = new PrintWriter(m_sock.getOutputStream(), true);
}
catch(IOException e)
{
System.out.println(e.toString());
}
}

void StopSocket()
{
try
{
if(m_sockIn != null)
m_sockIn.close();
if(m_sockOut != null)
m_sockOut.close();
if(m_sock != null)
m_sock.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}

}

boolean ReceiveCmd()
{
try
{
m_strCmd = m_cmdIn.readLine();
if(m_strCmd.equals("exit"))
return false;
}
catch(IOException e)
{
System.out.println(e.toString());
}

return true;
}

void ProcessCmd()
{
if(m_strCmd.equals("ls"))
{
try
{
StartSocket();
m_sockOut.write(m_strCmd);
m_sockOut.flush();

while(true)
{
String strReadSocket = m_sockIn.readLine();
if(strReadSocket == null)
break;
System.out.println(strReadSocket);
}

StopSocket();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}


if(m_strCmd.startsWith("cd"))
{
StartSocket();

m_sockOut.write(m_strCmd);
m_sockOut.flush();

StopSocket();
}

if(m_strCmd.equals("pwd"))
{
try
{
StartSocket();
m_sockOut.write(m_strCmd);
m_sockOut.flush();

String strReadSocket = m_sockIn.readLine();
System.out.println(strReadSocket);

StopSocket();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}

if(m_strCmd.startsWith("get"))
{
InputStream sockIn;

try
{
m_IpAddress = new InetSocketAddress(m_strIp, m_nPort);
m_sock = new Socket();

m_sock.connect(m_IpAddress, 100);
m_sock.setSoTimeout(3000);
sockIn = m_sock.getInputStream();
m_sockOut = new PrintWriter(m_sock.getOutputStream(), true);

m_sockOut.write(m_strCmd);
m_sockOut.flush();

RandomAccessFile file = new RandomAccessFile(m_strCmd.substring(4, m_strCmd.length()), "rw");
byte byWriteBuf[] = new byte[4096];
long nSize, offset = 0;
while(true)
{
nSize = sockIn.read(byWriteBuf);
if(nSize <= 0)
break;

file.seek(offset);
file.write(byWriteBuf);
offset += nSize;
}
file.close();
sockIn.close();

StopSocket();
}
catch(IOException e)
{
System.out.println(e.toString());
}

System.out.println("文件传输完成.");
}

if(m_strCmd.startsWith("run"))
{
try
{
StartSocket();
m_sockOut.write(m_strCmd);
m_sockOut.flush();

System.out.println(m_sockIn.readLine());

StopSocket();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}