java文件如何读取

java读取文件方法大全

一、多种方式读文件内容。

1、按字节读取文件内容

2、按字符读取文件内容

3、按行读取文件内容

4、随机读取文件内容

Java代码

1 import javaioBufferedReader;

2 import javaioFile;

3 import javaioFileInputStream;

4 import javaioFileReader;

5 import javaioIOException;

6 import javaioInputStream;

7 import javaioInputStreamReader;

8 import javaioRandomAccessFile;

9 import javaioReader;

10

11 public class ReadFromFile {

12 /

13 以字节为单位读取文件，常用于读二进制文件，如、声音、影像等文件。

14

15 @param fileName

16 文件的名

17 /

18 public static void readFileByBytes(String fileName) {

19 File file = new File(fileName);

20 InputStream in = null;

21 try {

22 Systemoutprintln("以字节为单位读取文件内容，一次读一个字节：");

23 // 一次读一个字节

24 in = new FileInputStream(file);

25 int tempbyte;

26 while ((tempbyte = inread()) != -1) {

27 Systemoutwrite(tempbyte);

28 }

29 inclose();

30 } catch (IOException e) {

31 eprintStackTrace();

32 return;

33 }

34 try {

35 Systemoutprintln("以字节为单位读取文件内容，一次读多个字节：");

36 // 一次读多个字节

37 byte[] tempbytes = new byte[100];

38 int byteread = 0;

39 in = new FileInputStream(fileName);

40 ReadFromFileshowAvailableBytes(in);

41 // 读入多个字节到字节数组中，byteread为一次读入的字节数

42 while ((byteread = inread(tempbytes)) != -1) {

43 Systemoutwrite(tempbytes, 0, byteread);

44 }

45 } catch (Exception e1) {

46 e1printStackTrace();

47 } finally {

48 if (in != null) {

49 try {

50 inclose();

51 } catch (IOException e1) {

52 }

53 }

54 }

55 }

56

57 /

58 以字符为单位读取文件，常用于读文本，数字等类型的文件

59

60 @param fileName

61 文件名

62 /

63 public static void readFileByChars(String fileName) {

64 File file = new File(fileName);

65 Reader reader = null;

66 try {

67 Systemoutprintln("以字符为单位读取文件内容，一次读一个字节：");

68 // 一次读一个字符

69 reader = new InputStreamReader(new FileInputStream(file));

70 int tempchar;

71 while ((tempchar = readerread()) != -1) {

72 // 对于windows下，\r\n这两个字符在一起时，表示一个换行。

73 // 但如果这两个字符分开显示时，会换两次行。

74 // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。

75 if (((char) tempchar) != '\r') {

76 Systemoutprint((char) tempchar);

77 }

78 }

79 readerclose();

80 } catch (Exception e) {

81 eprintStackTrace();

82 }

83 try {

84 Systemoutprintln("以字符为单位读取文件内容，一次读多个字节：");

85 // 一次读多个字符

86 char[] tempchars = new char[30];

87 int charread = 0;

88 reader = new InputStreamReader(new FileInputStream(fileName));

89 // 读入多个字符到字符数组中，charread为一次读取字符数

90 while ((charread = readerread(tempchars)) != -1) {

91 // 同样屏蔽掉\r不显示

92 if ((charread == tempcharslength)

93 && (tempchars[tempcharslength - 1] != '\r')) {

94 Systemoutprint(tempchars);

95 } else {

96 for (int i = 0; i < charread; i++) {

97 if (tempchars[i] == '\r') {

98 continue;

99 } else {

100 Systemoutprint(tempchars[i]);

101 }

102 }

103 }

104 }

105

106 } catch (Exception e1) {

107 e1printStackTrace();

108 } finally {

109 if (reader != null) {

110 try {

111 readerclose();

112 } catch (IOException e1) {

113 }

114 }

115 }

116 }

117

118 /

119 以行为单位读取文件，常用于读面向行的格式化文件

120

121 @param fileName

122 文件名

123 /

124 public static void readFileByLines(String fileName) {

125 File file = new File(fileName);

126 BufferedReader reader = null;

127 try {

128 Systemoutprintln("以行为单位读取文件内容，一次读一整行：");

129 reader = new BufferedReader(new FileReader(file));

130 String tempString = null;

131 int line = 1;

132 // 一次读入一行，直到读入null为文件结束

133 while ((tempString = readerreadLine()) != null) {

134 // 显示行号

135 Systemoutprintln("line " + line + ": " + tempString);

136 line++;

137 }

138 readerclose();

139 } catch (IOException e) {

140 eprintStackTrace();

141 } finally {

142 if (reader != null) {

143 try {

144 readerclose();

145 } catch (IOException e1) {

146 }

147 }

148 }

149 }

150

151 /

152 随机读取文件内容

153

154 @param fileName

155 文件名

156 /

157 public static void readFileByRandomAccess(String fileName) {

158 RandomAccessFile randomFile = null;

159 try {

160 Systemoutprintln("随机读取一段文件内容：");

161 // 打开一个随机访问文件流，按只读方式

162 randomFile = new RandomAccessFile(fileName, "r");

163 // 文件长度，字节数

164 long fileLength = randomFilelength();

165 // 读文件的起始位置

166 int beginIndex = (fileLength > 4) 4 : 0;

167 // 将读文件的开始位置移到beginIndex位置。

168 randomFileseek(beginIndex);

169 byte[] bytes = new byte[10];

170 int byteread = 0;

171 // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。

172 // 将一次读取的字节数赋给byteread

173 while ((byteread = randomFileread(bytes)) != -1) {

174 Systemoutwrite(bytes, 0, byteread);

175 }

176 } catch (IOException e) {

177 eprintStackTrace();

178 } finally {

179 if (randomFile != null) {

180 try {

181 randomFileclose();

182 } catch (IOException e1) {

183 }

184 }

185 }

186 }

187

188 /

189 显示输入流中还剩的字节数

190

191 @param in

192 /

193 private static void showAvailableBytes(InputStream in) {

194 try {

195 Systemoutprintln("当前字节输入流中的字节数为:" + inavailable());

196 } catch (IOException e) {

197 eprintStackTrace();

198 }

199 }

200

201 public static void main(String[] args) {

202 String fileName = "C:/temp/newTemptxt";

203 ReadFromFilereadFileByBytes(fileName);

204 ReadFromFilereadFileByChars(fileName);

205 ReadFromFilereadFileByLines(fileName);

206 ReadFromFilereadFileByRandomAccess(fileName);

207 }

208 }

二、将内容追加到文件尾部

1 import javaioFileWriter;

2 import javaioIOException;

3 import javaioRandomAccessFile;

4

5 /

6 将内容追加到文件尾部

7 /

8 public class AppendToFile {

9

10 /

11 A方法追加文件：使用RandomAccessFile

12 @param fileName 文件名

13 @param content 追加的内容

14 /

15 public static void appendMethodA(String fileName, String content) {

16 try {

17 // 打开一个随机访问文件流，按读写方式

18 RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");

19 // 文件长度，字节数

20 long fileLength = randomFilelength();

21 //将写文件指针移到文件尾。

22 randomFileseek(fileLength);

23 randomFilewriteBytes(content);

24 randomFileclose();

25 } catch (IOException e) {

26 eprintStackTrace();

27 }

28 }

29

30 /

31 B方法追加文件：使用FileWriter

32 @param fileName

33 @param content

34 /

35 public static void appendMethodB(String fileName, String content) {

36 try {

37 //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件

38 FileWriter writer = new FileWriter(fileName, true);

39 writerwrite(content);

40 writerclose();

41 } catch (IOException e) {

42 eprintStackTrace();

43 }

44 }

45

46 public static void main(String[] args) {

47 String fileName = "C:/temp/newTemptxt";

48 String content = "new append!";

49 //按方法A追加文件

50 AppendToFileappendMethodA(fileName, content);

51 AppendToFileappendMethodA(fileName, "append end \n");

52 //显示文件内容

53 ReadFromFilereadFileByLines(fileName);

54 //按方法B追加文件

55 AppendToFileappendMethodB(fileName, content);

56 AppendToFileappendMethodB(fileName, "append end \n");

57 //显示文件内容

58 ReadFromFilereadFileByLines(fileName);

59 }

60 }

使用Java *** 作文本文件的方法详解

摘要: 最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类

最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int

length)，flush()和close()方法为抽象方法，Reader中read(char[] ch,int off,int length)和close()方法是抽象方法。子类应该分别实现他们。 当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader，它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层 *** 作系统的默认编码方式，例如GBK等。当使用FileReader读取文件的时候。FileReader fr = new FileReader("mingtxt");

int ch = 0;

while((ch = frread())!=-1 )

{

Systemoutprint((char)ch);

}

其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用InputStreamReader来读取文件的时候while((ch = isrread())!=-1)

{

Systemoutprint((char)ch);

}

这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("mingtxt")));

String data = null;

while((data = brreadLine())!=null)

{

Systemoutprintln(data);

}

当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：

FileWriter fw = new FileWriter("hellotxt");

String s = "hello world";

fwwrite(s,0,slength());

fwflush();OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2txt"));

oswwrite(s,0,slength());

oswflush();PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3txt")),true);

pwprintln(s);

不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。

import javaio;public class TestFile2

{

public static void main(String[] args) throws IOException

{

FileReader fr = new FileReader("mingtxt");

char[] buffer = new char[1024];

int ch = 0;

while((ch = frread())!=-1 )

{

Systemoutprint((char)ch);

} InputStreamReader isr = new InputStreamReader(new FileInputStream("mingtxt"));

while((ch = isrread())!=-1)

{

Systemoutprint((char)ch);

} BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("mingtxt")));

String data = null;

while((data = brreadLine())!=null)

{

Systemoutprintln(data);

} FileWriter fw = new FileWriter("hellotxt");

String s = "hello world";

fwwrite(s,0,slength());

fwflush(); OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2txt"));

oswwrite(s,0,slength());

oswflush(); PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3txt")),true);

pwprintln(s);

frclose();

isrclose();

brclose();

fwclose();

oswclose();

pwclose();

}

}

java中多种方式读文件

一、多种方式读文件内容。

1、按字节读取文件内容

2、按字符读取文件内容

3、按行读取文件内容

4、随机读取文件内容

import javaioBufferedReader;

import javaioFile;

import javaioFileInputStream;

import javaioFileReader;

import javaioIOException;

import javaioInputStream;

import javaioInputStreamReader;

import javaioRandomAccessFile;

import javaioReader;

public class ReadFromFile {

/

以字节为单位读取文件，常用于读二进制文件，如、声音、影像等文件。

@param fileName 文件的名

/

public static void readFileByBytes(String fileName){

File file = new File(fileName);

InputStream in = null;

try {

Systemoutprintln("以字节为单位读取文件内容，一次读一个字节：");

// 一次读一个字节

in = new FileInputStream(file);

int tempbyte;

while((tempbyte=inread()) != -1){

Systemoutwrite(tempbyte);

}

inclose();

} catch (IOException e) {

eprintStackTrace();

return;

}

try {

Systemoutprintln("以字节为单位读取文件内容，一次读多个字节：");

//一次读多个字节

byte[] tempbytes = new byte[100];

int byteread = 0;

in = new FileInputStream(fileName);

ReadFromFileshowAvailableBytes(in);

//读入多个字节到字节数组中，byteread为一次读入的字节数

while ((byteread = inread(tempbytes)) != -1){

Systemoutwrite(tempbytes, 0, byteread);

}

} catch (Exception e1) {

e1printStackTrace();

} finally {

if (in != null){

try {

inclose();

} catch (IOException e1) {

}

}

}

}

/

以字符为单位读取文件，常用于读文本，数字等类型的文件

@param fileName 文件名

/

public static void readFileByChars(String fileName){

File file = new File(fileName);

Reader reader = null;

try {

Systemoutprintln("以字符为单位读取文件内容，一次读一个字节：");

// 一次读一个字符

reader = new InputStreamReader(new FileInputStream(file));

int tempchar;

while ((tempchar = readerread()) != -1){

//对于windows下，rn这两个字符在一起时，表示一个换行。

//但如果这两个字符分开显示时，会换两次行。

//因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。

if (((char)tempchar) != 'r'){

Systemoutprint((char)tempchar);

}

}

readerclose();

} catch (Exception e) {

eprintStackTrace();

}

try {

Systemoutprintln("以字符为单位读取文件内容，一次读多个字节：");

//一次读多个字符

char[] tempchars = new char[30];

int charread = 0;

reader = new InputStreamReader(new FileInputStream(fileName));

//读入多个字符到字符数组中，charread为一次读取字符数

while ((charread = readerread(tempchars))!=-1){

//同样屏蔽掉r不显示

if ((charread == tempcharslength)&&(tempchars[tempcharslength-1] != 'r')){

Systemoutprint(tempchars);

}else{

for (int i=0; i<charread; i++){

if(tempchars[i] == 'r'){

continue;

}else{

Systemoutprint(tempchars[i]);

}

}

}

}

} catch (Exception e1) {

e1printStackTrace();

}finally {

if (reader != null){

try {

readerclose();

} catch (IOException e1) {

}

}

}

}

/

以行为单位读取文件，常用于读面向行的格式化文件

@param fileName 文件名

/

public static void readFileByLines(String fileName){

File file = new File(fileName);

BufferedReader reader = null;

try {

Systemoutprintln("以行为单位读取文件内容，一次读一整行：");

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

String tempString = null;

int line = 1;

//一次读入一行，直到读入null为文件结束

while ((tempString = readerreadLine()) != null){

//显示行号

Systemoutprintln("line " + line + ": " + tempString);

line++;

}

readerclose();

} catch (IOException e) {

eprintStackTrace();

} finally {

if (reader != null){

try {

readerclose();

} catch (IOException e1) {

}

}

}

}

/

随机读取文件内容

@param fileName 文件名

/

public static void readFileByRandomAccess(String fileName){

RandomAccessFile randomFile = null;

try {

Systemoutprintln("随机读取一段文件内容：");

// 打开一个随机访问文件流，按只读方式

randomFile = new RandomAccessFile(fileName, "r");

// 文件长度，字节数

long fileLength = randomFilelength();

// 读文件的起始位置

int beginIndex = (fileLength > 4) 4 : 0;

//将读文件的开始位置移到beginIndex位置。

randomFileseek(beginIndex);

byte[] bytes = new byte[10];

int byteread = 0;

//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。

//将一次读取的字节数赋给byteread

while ((byteread = randomFileread(bytes)) != -1){

Systemoutwrite(bytes, 0, byteread);

}

} catch (IOException e){

eprintStackTrace();

} finally {

if (randomFile != null){

try {

randomFileclose();

} catch (IOException e1) {

}

}

}

}

/

显示输入流中还剩的字节数

@param in

/

private static void showAvailableBytes(InputStream in){

try {

Systemoutprintln("当前字节输入流中的字节数为:" + inavailable());

} catch (IOException e) {

eprintStackTrace();

}

}

public static void main(String[] args) {

String fileName = "C:/temp/newTemptxt";

ReadFromFilereadFileByBytes(fileName);

ReadFromFilereadFileByChars(fileName);

ReadFromFilereadFileByLines(fileName);

ReadFromFilereadFileByRandomAccess(fileName);

}

}

二、将内容追加到文件尾部

import javaioFileWriter;

import javaioIOException;

import javaioRandomAccessFile;

/

将内容追加到文件尾部

/

public class AppendToFile {

/

A方法追加文件：使用RandomAccessFile

@param fileName 文件名

@param content 追加的内容

/

public static void appendMethodA(String fileName,

String content){

try {

// 打开一个随机访问文件流，按读写方式

RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");

// 文件长度，字节数

long fileLength = randomFilelength();

//将写文件指针移到文件尾。

randomFileseek(fileLength);

randomFilewriteBytes(content);

randomFileclose();

} catch (IOException e){

eprintStackTrace();

}

}

/

B方法追加文件：使用FileWriter

@param fileName

@param content

/

public static void appendMethodB(String fileName, String content){

try {

//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件

FileWriter writer = new FileWriter(fileName, true);

writerwrite(content);

writerclose();

} catch (IOException e) {

eprintStackTrace();

}

}

public static void main(String[] args) {

String fileName = "C:/temp/newTemptxt";

String content = "new append!";

//按方法A追加文件

AppendToFileappendMethodA(fileName, content);

AppendToFileappendMethodA(fileName, "append end n");

//显示文件内容

ReadFromFilereadFileByLines(fileName);

//按方法B追加文件

AppendToFileappendMethodB(fileName, content);

AppendToFileappendMethodB(fileName, "append end n");

//显示文件内容

ReadFromFilereadFileByLines(fileName);

}

}

int len = contentlength(); 这句不对的。contentlength()返回的字符长度而不是字节长度。

对于非单字节编码而言contentlength()长度永远小于contentgetBytes()length，只有对单字节字符而言这两个长度才相等。

另外分数组处理实在不是好办法，即需要书写更长的代码，运行效率也低于用流方式处理的。

一下是我写的两种方式的处理代码 你能明显的比较出来。流只用一个循环，而字节数组至少要一个双循环。

               String s="实现dhl反对思考浪费你的身份了你看打发士大夫士大夫似的";

//数组方式

byte[] bs=sgetBytes();

int length=5,len=bslength/length,len1;

byte[] tmp=new byte[length];

for(int i=0;i<len;i++){

for(int j=0;j<length;j++)

tmp[j]=bs[ilength+j];

Systemoutprintln(ArraystoString(tmp));

}

tmp=new byte[length];

if((len1=bslength%length)>0){

for(int i=0;i<len1;i++)

tmp[i]=bs[lenlength+i];

Systemoutprintln(ArraystoString(tmp));

}

//流方式

InputStream is=new ByteArrayInputStream(sgetBytes());

int length2=5,len2;

byte[] bs2=new byte[length2];

try {

while((len2=isread(bs2))>0){

if(len2!=length2)

Arraysfill(bs2, len2, 5, (byte)0);

Systemoutprintln(ArraystoString(bs2));

}

} catch (IOException e) {

eprintStackTrace();

}

import javautilScanner;

import javaio;

class MyFile

{

MyFile(String d)

{

thisd=d;

}

void write(String path,String datafile)

{

File f=new File(thisd);

StringBuilder sb=new StringBuilder();

String savepath;

String[] strs;

BufferedOutputStream bos;

byte[] buf;

thispath=pathendsWith("\\") pathsubstring(0,pathlength()-1) : path;

savepath=thispath+"\\"+datafile;

try

{

strs=flist();

for(String str : strs)

{

sbappend(str);

sbappend("\r\n");

}

bos=new BufferedOutputStream(new FileOutputStream(savepath),MyFileSize);

buf=sbtoString()getBytes();

boswrite(buf,0,buflength);

//bosflush();

bosclose();

}

catch(Exception e)

{

Systemoutprintln(egetMessage());

}

}

void show(String datafile)

{

String fp=datafilecontains("\\") datafile : thispath+"\\"+datafile;

File f=new File(fp);

BufferedInputStream bis;

byte[] buf;

try

{

buf=new byte[(int)flength()];

bis=new BufferedInputStream(new FileInputStream(f),MyFileSize);

bisread(buf,0,buflength);

Systemoutprintln(new String(buf));

bisclose();

}

catch(Exception e)

{

Systemoutprintln(egetMessage());

}

}

private static final int Size=81024;

private String d,path;

}

public class P

{

public static void main(String[] args)

{

Scanner sc=new Scanner(Systemin);

MyFile f;

String d,path,datafile;

Systemoutprint("请输入windows系统中某个目录的路径：");

d=scnextLine();

f=new MyFile(d);

Systemoutprint("请输入保存数据的文件的路径：");

path=scnextLine();

Systemoutprint("请输入保存数据的文件的文件名：");

datafile=scnextLine();

fwrite(path,datafile);

fshow(datafile);

scclose();

}

}

/

将指定byte数组以16进制的形式打印到控制台

@param hint String

@param b byte[]

@return void

/

public static void printHexString(String hint, byte[] b) {

Systemoutprint(hint);

for (int i = 0; i < blength; i++) {

String hex = IntegertoHexString(b[i] & 0xFF);

if (hexlength() == 1) {

hex = '0' + hex;

}

Systemoutprint(hextoUpperCase() + " ");

}

Systemoutprintln("");

}

/

@param b byte[]

@return String

/

public static String Bytes2HexString(byte[] b) {

String ret = "";

for (int i = 0; i < blength; i++) {

String hex = IntegertoHexString(b[i] & 0xFF);

if (hexlength() == 1) {

hex = '0' + hex;

}

ret += hextoUpperCase();

}

return ret;

}

/

将两个ASCII字符合成一个字节；

如："EF"--> 0xEF

@param src0 byte

@param src1 byte

@return byte

/

public static byte uniteBytes(byte src0, byte src1) {

byte _b0 = Bytedecode("0x" + new String(new byte[]{src0}))byteValue();

_b0 = (byte)(_b0 << 4);

byte _b1 = Bytedecode("0x" + new String(new byte[]{src1}))byteValue();

byte ret = (byte)(_b0 ^ _b1);

return ret;

}

/

将指定字符串src，以每两个字符分割转换为16进制形式

如："2B44EFD9" --> byte[]{0x2B, 0x44, 0xEF, 0xD9}

@param src String

@return byte[]

/

public static byte[] HexString2Bytes(String src){

byte[] ret = new byte[8];

byte[] tmp = srcgetBytes();

for(int i=0; i<8; i++){

ret[i] = uniteBytes(tmp[i2], tmp[i2+1]);

}

return ret;

}

详细出处参考：>

你的代码是do {

inread(b,0,1024);//读取1024字节到数组b

outwrite(b,0,1024);//把数组b的1024字节的内容写入out关联的文件

} while (inavailable() > 0);//当文件未到末尾时继续做循环体的内容

你从in读取1024，然后向out写1024，再读，再写直到文件结尾，当然可以读写100K的文件啦，多大的文件都行。

文件流 *** 作的时候会自动记录下一个文件内部位置，只要流未关闭，就从上次位置接着 *** 作

import javaio;

class DownThread extends Thread {

//定义字节数组（取水的竹筒）的长度

private final int BUFF_LEN = 32;

//定义读取的起始点

private long start;

//定义读取的结束点

private long end;

//读取文件对应的输入流

private InputStream is;

//将读取到的字节输出到raf中

private RandomAccessFile raf;

//构造器，传入输入流，输出流和读取起始点、结束点

public DownThread(long start, long end, InputStream is, RandomAccessFile raf) {

//输出该线程负责读取的字节位置

Systemoutprintln(start + "---->" + end);

thisstart = start;

thisend = end;

thisis = is;

thisraf = raf;

}

public void run() {

try {

isskip(start);

rafseek(start);

//定义读取输入流内容的的缓存数组（竹筒）

byte[] buff = new byte[BUFF_LEN];

//本线程负责读取文件的大小

long contentLen = end - start;

//定义最多需要读取几次就可以完成本线程的读取

long times = contentLen / BUFF_LEN + 4;

//实际读取的字节数

int hasRead = 0;

for (int i = 0; i < times; i++) {

hasRead = isread(buff);

//如果读取的字节数小于0，则退出循环！

if (hasRead < 0) {

break;

}

rafwrite(buff, 0, hasRead);

}

} catch (Exception ex) {

exprintStackTrace();

}

//使用finally块来关闭当前线程的输入流、输出流

finally {

try {

if (is != null) {

isclose();

}

if (raf != null) {

rafclose();

}

} catch (Exception ex) {

exprintStackTrace();

}

}

}

}

public class MutilDown {

public static void main(String[] args) {

final int DOWN_THREAD_NUM = 4;

final String OUT_FILE_NAME = "d:/copy勇敢的心rmvb";

InputStream[] isArr = new InputStream[DOWN_THREAD_NUM];

RandomAccessFile[] outArr = new RandomAccessFile[DOWN_THREAD_NUM];

try {

isArr[0] = new FileInputStream("d:/勇敢的心rmvb");

long fileLen = getFileLength(new File("d:/勇敢的心rmvb"));

Systemoutprintln("文件的大小" + fileLen);

//以输出文件名创建第一个RandomAccessFile输出流

outArr[0] = new RandomAccessFile(OUT_FILE_NAME, "rw");

//创建一个与文件相同大小的空文件

for (int i = 0; i < fileLen; i++) {

outArr[0]write(0);

}

//每线程应该读取的字节数

long numPerThred = fileLen / DOWN_THREAD_NUM;

//整个文件整除后剩下的余数

long left = fileLen % DOWN_THREAD_NUM;

for (int i = 0; i < DOWN_THREAD_NUM; i++) {

//为每个线程打开一个输入流、一个RandomAccessFile对象，

//让每个线程分别负责读取文件的不同部分。

if (i != 0) {

isArr[i] = new FileInputStream("d:/勇敢的心rmvb");

//以指定输出文件创建多个RandomAccessFile对象

outArr[i] = new RandomAccessFile(OUT_FILE_NAME, "rw");

}

if (i == DOWN_THREAD_NUM - 1) {

//最后一个线程读取指定numPerThred+left个字节

new DownThread(i numPerThred, (i + 1) numPerThred

+ left, isArr[i], outArr[i])start();

} else {

//每个线程负责读取一定的numPerThred个字节

new DownThread(i numPerThred, (i + 1) numPerThred,

isArr[i], outArr[i])start();

}

}

} catch (Exception ex) {

exprintStackTrace();

}

}

public static long getFileLength(File file) {

long length = 0;

//获取文件的长度

long size = filelength();

length = size;

return length;

}

}

这个太简单了，不过你说的是在太模糊了，首先输入流是哪个流，有没有限制，如果有限制就不知道了，没有限制就太好办了。我想你是这个意思：使用某个输入流读取固定长度的字节，然后保存到一个文件中。读取固定长度不是难题，保存到一个文件中也不是问题，关键你要知道这个输入流的API方法，例如。FileInputStream，创建一个流，创建一个字节数组，然后使用流对象调用read(byte[] arr,int off,int len),arr是你创建的字节数组，off是起始地点，len是读取的数据长度。然后把arr写入到一个文件中，就实现保存了。

以上就是关于java文件如何读取全部的内容，包括:java文件如何读取、Java读取文件问题、java读取文件内容,分多个部分,每部分40字节,现每次只发送了前40个字节的内容,请帮忙看看哪里的问题,谢谢.等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！