Java文件读写
转自： Here
使用Java操作文本文件的方法详解
摘要: 最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类
最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int
摘要: 最初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读取文件
的时候。
java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
1
. FileReader fr
=
new
FileReader(
"
ming.txt
"
);
2
.
int
ch
=
0
;
3
.
while
((ch
=
fr.read())
!=-
1
)
4
. {
5
. System.
out
.print((
char
)ch);
6
. }
其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用
InputStreamReader来读取文件的时候
while((ch = isr.read())!=-1)
{
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率
{
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率
我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先
放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先
1
. FileWriter fw
=
new
FileWriter(
"
hello.txt
"
);
2
. String s
=
"
hello world
"
;
3
. fw.write(s,
0
,s.length());
4
. fw.flush();
5
. OutputStreamWriter osw
=
new
OutputStreamWriter(
new
FileOutputStream(
"
hello2.txt
"
));
6
. osw.write(s,
0
,s.length());
7
. osw.flush();
8
. PrintWriter pw
=
new
PrintWriter(
new
OutputStreamWriter(
new
FileOutputStream(
"
hello3.txt
"
)),
true
);
9
. pw.println(s);
不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。
1
.
import
java.io.
*
;
2
.
public
class
TestFile2
3
. {
4
.
public
static
void
main(String[] args)
throws
IOException
5
. {
6
. FileReader fr
=
new
FileReader(
"
ming.txt
"
);
7
.
char
[] buffer
=
new
char
[
1024
];
8
.
int
ch
=
0
;
9
.
while
((ch
=
fr.read())
!=-
1
)
10
. {
11
. System.out.print((
char
)ch);
12
. }
13
. InputStreamReader isr
=
new
InputStreamReader(
new
FileInputStream(
"
ming.txt
"
));
14
.
while
((ch
=
isr.read())
!=-
1
)
15
. {
16
. System.out.print((
char
)ch);
17
. }
18
. BufferedReader br
=
new
BufferedReader(
new
InputStreamReader(
new
FileInputStream(
"
ming.txt
"
)));
19
. String data
=
null
;
20
.
while
((data
=
br.readLine())
!=
null
)
21
. {
22
. System.out.println(data);
23
. }
24
. FileWriter fw
=
new
FileWriter(
"
hello.txt
"
);
25
. String s
=
"
hello world
"
;
26
. fw.write(s,
0
,s.length());
27
. fw.flush();
28
. OutputStreamWriter osw
=
new
OutputStreamWriter(
new
FileOutputStream(
"
hello2.txt
"
));
29
. osw.write(s,
0
,s.length());
30
. osw.flush();
31
. PrintWriter pw
=
new
PrintWriter(
new
OutputStreamWriter(
new
FileOutputStream(
"
hello3.txt
"
)),
true
);
32
. pw.println(s);
33
. fr.close();
34
. isr.close();
35
. br.close();
36
. fw.close();
37
. osw.close();
38
. pw.close();
39
. }
40
. }
java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
import
java.io.BufferedReader;
import
java.io.File;
import
java.io.FileInputStream;
import
java.io.FileReader;
import
java.io.IOException;
import
java.io.InputStream;
import
java.io.InputStreamReader;
import
java.io.RandomAccessFile;
import
java.io.Reader;
public
class
ReadFromFile {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*
@param
fileName 文件的名
*/
public
static
void
readFileByBytes(String fileName){
File file
=
new
File(fileName);
InputStream in
=
null
;
try
{
System.out.println(
"
以字节为单位读取文件内容，一次读一个字节：
"
);
//
一次读一个字节
in
=
new
FileInputStream(file);
int
tempbyte;
while
((tempbyte
=
in.read())
!=
-
1
){
System.out.write(tempbyte);
}
in.close();
}
catch
(IOException e) {
e.printStackTrace();
return
;
}
try
{
System.out.println(
"
以字节为单位读取文件内容，一次读多个字节：
"
);
//
一次读多个字节
byte
[] tempbytes
=
new
byte
[
100
];
int
byteread
=
0
;
in
=
new
FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//
读入多个字节到字节数组中，byteread为一次读入的字节数
while
((byteread
=
in.read(tempbytes))
!=
-
1
){
System.out.write(tempbytes,
0
, byteread);
}
}
catch
(Exception e1) {
e1.printStackTrace();
}
finally
{
if
(in
!=
null
){
try
{
in.close();
}
catch
(IOException e1) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
*
@param
fileName 文件名
*/
public
static
void
readFileByChars(String fileName){
File file
=
new
File(fileName);
Reader reader
=
null
;
try
{
System.out.println(
"
以字符为单位读取文件内容，一次读一个字节：
"
);
//
一次读一个字符
reader
=
new
InputStreamReader(
new
FileInputStream(file));
int
tempchar;
while
((tempchar
=
reader.read())
!=
-
1
){
//
对于windows下，rn这两个字符在一起时，表示一个换行。
//
但如果这两个字符分开显示时，会换两次行。
//
因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
if
(((
char
)tempchar)
!=
'
r
'
){
System.out.print((
char
)tempchar);
}
}
reader.close();
}
catch
(Exception e) {
e.printStackTrace();
}
try
{
System.out.println(
"
以字符为单位读取文件内容，一次读多个字节：
"
);
//
一次读多个字符
char
[] tempchars
=
new
char
[
30
];
int
charread
=
0
;
reader
=
new
InputStreamReader(
new
FileInputStream(fileName));
//
读入多个字符到字符数组中，charread为一次读取字符数
while
((charread
=
reader.read(tempchars))
!=-
1
){
//
同样屏蔽掉r不显示
if
((charread
==
tempchars.length)
&&
(tempchars[tempchars.length
-
1
]
!=
'
r
'
)){
System.out.print(tempchars);
}
else
{
for
(
int
i
=
0
; i
<
charread; i
++
){
if
(tempchars[i]
==
'
r
'
){
continue
;
}
else
{
System.out.print(tempchars[i]);
}
}
}
}
}
catch
(Exception e1) {
e1.printStackTrace();
}
finally
{
if
(reader
!=
null
){
try
{
reader.close();
}
catch
(IOException e1) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
*
@param
fileName 文件名
*/
public
static
void
readFileByLines(String fileName){
File file
=
new
File(fileName);
BufferedReader reader
=
null
;
try
{
System.out.println(
"
以行为单位读取文件内容，一次读一整行：
"
);
reader
=
new
BufferedReader(
new
FileReader(file));
String tempString
=
null
;
int
line
=
1
;
//
一次读入一行，直到读入null为文件结束
while
((tempString
=
reader.readLine())
!=
null
){
//
显示行号
System.out.println(
"
line
"
+
line
+
"
:
"
+
tempString);
line
++
;
}
reader.close();
}
catch
(IOException e) {
e.printStackTrace();
}
finally
{
if
(reader
!=
null
){
try
{
reader.close();
}
catch
(IOException e1) {
}
}
}
}
/**
* 随机读取文件内容
*
@param
fileName 文件名
*/
public
static
void
readFileByRandomAccess(String fileName){
RandomAccessFile randomFile
=
null
;
try
{
System.out.println(
"
随机读取一段文件内容：
"
);
//
打开一个随机访问文件流，按只读方式
randomFile
=
new
RandomAccessFile(fileName,
"
r
"
);
//
文件长度，字节数
long
fileLength
=
randomFile.length();
//
读文件的起始位置
int
beginIndex
=
(fileLength
>
4
)
?
4
:
0
;
//
将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte
[] bytes
=
new
byte
[
10
];
int
byteread
=
0
;
//
一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//
将一次读取的字节数赋给byteread
while
((byteread
=
randomFile.read(bytes))
!=
-
1
){
System.out.write(bytes,
0
, byteread);
}
}
catch
(IOException e){
e.printStackTrace();
}
finally
{
if
(randomFile
!=
null
){
try
{
randomFile.close();
}
catch
(IOException e1) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
*
@param
in
*/
private
static
void
showAvailableBytes(InputStream in){
try
{
System.out.println(
"
当前字节输入流中的字节数为:
"
+
in.available());
}
catch
(IOException e) {
e.printStackTrace();
}
}
public
static
void
main(String[] args) {
String fileName
=
"
C:/temp/newTemp.txt
"
;
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
二、将内容追加到文件尾部
import
java.io.FileWriter;
import
java.io.IOException;
import
java.io.RandomAccessFile;
/**
* 将内容追加到文件尾部
*/
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
=
randomFile.length();
//
将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
}
catch
(IOException e){
e.printStackTrace();
}
}
/**
* B方法追加文件：使用FileWriter
*
@param
fileName
*
@param
content
*/
public
static
void
appendMethodB(String fileName, String content){
try
{
//
打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer
=
new
FileWriter(fileName,
true
);
writer.write(content);
writer.close();
}
catch
(IOException e) {
e.printStackTrace();
}
}
public
static
void
main(String[] args) {
String fileName
=
"
C:/temp/newTemp.txt
"
;
String content
=
"
new append!
"
;
//
按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName,
"
append end. n
"
);
//
显示文件内容
ReadFromFile.readFileByLines(fileName);
//
按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName,
"
append end. n
"
);
//
显示文件内容
ReadFromFile.readFileByLines(fileName);
}
}