java文件读写入门与class创建.docx

java文件读写入门与class创建.docx

《java文件读写入门与class创建.docx》由会员分享，可在线阅读，更多相关《java文件读写入门与class创建.docx（16页珍藏版）》请在冰豆网上搜索。

java文件读写入门与class创建

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

最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中write（char[]ch,intoff,intlength），flush（）和close（）方法为抽象方法，Reader中read（char[]ch,intoff,intlength）和close（）方法是抽象方法。

子类应该分别实现他们。

　　当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。

其中最重要的类是InputStreamReader，

它是字节转换为字符的桥梁。

你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。

当使用FileReader读取文件的时候。

FileReaderfr=newFileReader（"ming.txt"）;

intch=0;

while（（ch=fr.read（））!

=-1）

{

System.out.print（（char）ch）;

}

其中read（）方法返回的是读取得下个字符。

当然你也可以使用read（char[]ch,intoff,intlength）这和处理二进制文件的时候类似，不多说了。

如果使用

InputStreamReader来读取文件的时候

while（（ch=isr.read（））!

=-1）

{

System.out.print（（char）ch）;

}

这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。

read（）方法是比较好费时间的，如果为了提高效率我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine（）方法。

BufferedReaderbr=newBufferedReader（newInputStreamReader（newFileInputStream（"ming.txt"）））;

Stringdata=null;

while（（data=br.readLine（））!

=null）

{

System.out.println（data）;

}

当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。

有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先

放入缓冲区，然后写入文件。

因此有时候你需要主动调用flush（）方法。

与上面对应的写文件的方法为：

FileWriterfw=newFileWriter（"hello.txt"）;

Strings="helloworld";

fw.write（s,0,s.length（））;

fw.flush（）;

OutputStreamWriterosw=newOutputStreamWriter（newFileOutputStream（"hello2.txt"））;

osw.write（s,0,s.length（））;

osw.flush（）;

PrintWriterpw=newPrintWriter（newOutputStreamWriter（newFileOutputStream（"hello3.txt"））,true）;

pw.println（s）;

不要忘记用完后关闭流！

下面是个小例子，帮助新手理解。

其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。

importjava.io.*;

publicclassTestFile2

{

publicstaticvoidmain（String[]args）throwsIOException

{

FileReaderfr=newFileReader（"ming.txt"）;

char[]buffer=newchar[1024];

intch=0;

while（（ch=fr.read（））!

=-1）

{

System.out.print（（char）ch）;

}

　　InputStreamReaderisr=newInputStreamReader（newFileInputStream（"ming.txt"））;

while（（ch=isr.read（））!

=-1）

{

System.out.print（（char）ch）;

}

　　BufferedReaderbr=newBufferedReader（newInputStreamReader（newFileInputStream（"ming.txt"）））;

Stringdata=null;

while（（data=br.readLine（））!

=null）

{

System.out.println（data）;

}

　　FileWriterfw=newFileWriter（"hello.txt"）;

Strings="helloworld";

fw.write（s,0,s.length（））;

fw.flush（）;

　　OutputStreamWriterosw=newOutputStreamWriter（newFileOutputStream（"hello2.txt"））;

osw.write（s,0,s.length（））;

osw.flush（）;

　　PrintWriterpw=newPrintWriter（newOutputStreamWriter（newFileOutputStream（"hello3.txt"））,true）;

pw.println（s）;

　　fr.close（）;

isr.close（）;

br.close（）;

fw.close（）;

osw.close（）;

pw.close（）;

}

}

java中多种方式读文件

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

1、按字节读取文件内容

2、按字符读取文件内容

3、按行读取文件内容

4、随机读取文件内容

其中按字节读取就是按byte读取，这种方式是用于读取非文档型文件，如图片、视频等，按照字符读取就是按char读取，这种方式适用于对文档型文件的读取，如txt。

按行读取以及随机读取不常见，可稍微了解一下就行。

importjava.io.BufferedReader;

importjava.io.File;

importjava.io.FileInputStream;

importjava.io.FileReader;

importjava.io.IOException;

importjava.io.InputStream;

importjava.io.InputStreamReader;

importjava.io.RandomAccessFile;

importjava.io.Reader;

publicclassReadFromFile{

/**

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

*@paramfileName文件的名

*/

publicstaticvoidreadFileByBytes（StringfileName）{

Filefile=newFile（fileName）;

InputStreamin=null;

try{

System.out.println（"以字节为单位读取文件内容，一次读一个字节：

"）;

//一次读一个字节

in=newFileInputStream（file）;

inttempbyte;

while（（tempbyte=in.read（））!

=-1）{

System.out.write（tempbyte）;

}

in.close（）;

}catch（IOExceptione）{

e.printStackTrace（）;

return;

}

try{

System.out.println（"以字节为单位读取文件内容，一次读多个字节：

"）;

//一次读多个字节

byte[]tempbytes=newbyte[100];

intbyteread=0;

in=newFileInputStream（fileName）;

ReadFromFile.showAvailableBytes（in）;

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

while（（byteread=in.read（tempbytes））!

=-1）{

System.out.write（tempbytes,0,byteread）;

}

}catch（Exceptione1）{

e1.printStackTrace（）;

}finally{

if（in!

=null）{

try{

in.close（）;

}catch（IOExceptione1）{

}

}

}

}

/**

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

*@paramfileName文件名

*/

publicstaticvoidreadFileByChars（StringfileName）{

Filefile=newFile（fileName）;

Readerreader=null;

try{

System.out.println（"以字符为单位读取文件内容，一次读一个字节：

"）;

//一次读一个字符

reader=newInputStreamReader（newFileInputStream（file））;

inttempchar;

while（（tempchar=reader.read（））!

=-1）{

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

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

//因此，屏蔽掉r，或者屏蔽n。

否则，将会多出很多空行。

if（（（char）tempchar）!

='r'）{

System.out.print（（char）tempchar）;

}

}

reader.close（）;

}catch（Exceptione）{

e.printStackTrace（）;

}

try{

System.out.println（"以字符为单位读取文件内容，一次读多个字节：

"）;

//一次读多个字符

char[]tempchars=newchar[30];

intcharread=0;

reader=newInputStreamReader（newFileInputStream（fileName））;

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

while（（charread=reader.read（tempchars））!

=-1）{

//同样屏蔽掉r不显示

if（（charread==tempchars.length）&&（tempchars[tempchars.length-1]!

='r'））{

System.out.print（tempchars）;

}else{

for（inti=0;i

if（tempchars[i]=='r'）{

continue;

}else{

System.out.print（tempchars[i]）;

}

}

}

}

}catch（Exceptione1）{

e1.printStackTrace（）;

}finally{

if（reader!

=null）{

try{

reader.close（）;

}catch（IOExceptione1）{

}

}

}

}

/**

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

*@paramfileName文件名

*/

publicstaticvoidreadFileByLines（StringfileName）{

Filefile=newFile（fileName）;

BufferedReaderreader=null;

try{

System.out.println（"以行为单位读取文件内容，一次读一整行：

"）;

reader=newBufferedReader（newFileReader（file））;

StringtempString=null;

intline=1;

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

while（（tempString=reader.readLine（））!

=null）{

//显示行号

System.out.println（"line"+line+":

"+tempString）;

line++;

}

reader.close（）;

}catch（IOExceptione）{

e.printStackTrace（）;

}finally{

if（reader!

=null）{

try{

reader.close（）;

}catch（IOExceptione1）{

}

}

}

}

/**

*随机读取文件内容

*@paramfileName文件名

*/

publicstaticvoidreadFileByRandomAccess（StringfileName）{

RandomAccessFilerandomFile=null;

try{

System.out.println（"随机读取一段文件内容：

"）;

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

randomFile=newRandomAccessFile（fileName,"r"）;

//文件长度，字节数

longfileLength=randomFile.length（）;

//读文件的起始位置

intbeginIndex=（fileLength>4）?

4:

0;

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

randomFile.seek（beginIndex）;

byte[]bytes=newbyte[10];

intbyteread=0;

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

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

while（（byteread=randomFile.read（bytes））!

=-1）{

System.out.write（bytes,0,byteread）;

}

}catch（IOExceptione）{

e.printStackTrace（）;

}finally{

if（randomFile!

=null）{

try{

randomFile.close（）;

}catch（IOExceptione1）{

}

}

}

}

/**

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

*@paramin

*/

privatestaticvoidshowAvailableBytes（InputStreamin）{

try{

System.out.println（"当前字节输入流中的字节数为:

"+in.available（））;

}catch（IOExceptione）{

e.printStackTrace（）;

}

}

publicstaticvoidmain（String[]args）{

StringfileName="C:

/temp/newTemp.txt";

ReadFromFile.readFileByBytes（fileName）;

ReadFromFile.readFileByChars（fileName）;

ReadFromFile.readFileByLines（fileName）;

ReadFromFile.readFileByRandomAccess（fileName）;

}

}

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

importjava.io.FileWriter;

importjava.io.IOException;

importjava.io.RandomAccessFile;

/**

*将内容追加到文件尾部

*/

publicclassAppendToFile{

/**

*A方法追加文件：

使用RandomAccessFile

*@paramfileName文件名

*@paramcontent追加的内容

*/

publicstaticvoidappendMethodA（StringfileName,

Stringcontent）{

try{

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

RandomAccessFilerandomFile=newRandomAccessFile（fileName,"rw"）;

//文件长度，字节数

longfileLength=randomFile.length（）;

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

randomFile.seek（fileLength）;

randomFile.writeBytes（content）;

randomFile.close（）;

}catch（IOExceptione）{

e.printStackTrace（）;

}

}

/**

*B方法追加文件：

使用FileWriter

*@paramfileName

*@paramcontent

*/

publicstaticvoidappendMethodB（StringfileName,Stringcontent）{

try{

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

FileWriterwriter=newFileWriter（fileName,true）;

writer.write（content）;

writer.close（）;

}catch（IOExceptione）{

e.printStackTrace（）;

}

}

publicstaticvoidmain（String[]args）{

StringfileName="C:

/temp/newTemp.txt";

Stringcontent="newappend!

";

//按方法A追加文件

AppendToFile.appendMethodA（fileName,content）;

AppendToFile.appendMethodA（fileName,"appendend.n"）;

//显示文件内容

ReadFromFile.readFileByLines（fileName）;

//按方法B追加文件

AppendToFile.appendMethodB（fileName,content）;

AppendToFile.appendMethodB（fileName,"appendend.n"）;

//显示文件内容

ReadFromFile.readFileByLines（fileName）;

}

}

JAVA创建class

创建一个不可直接执行的class：

publicclassTest{

privateintage;

privateStringname;

publicintgetAge（）{

returnage;

}

publicvoidsetAge（intage）{

this.age=age;

}

publicStringgetName（）{

returnname;

}

publicvoidsetName（Stringname）{

this.name=name;

}

}

创建一个可执行的class，即包含main函数的class：

publicclassTest{

privateintage;

privateStringname;

publicintgetAge（）{

returnage;

}

publicvoidsetAge（intage）{

this.age=age;

}

publicStringgetName（）{

returnname;

}

publicvoidsetName（Stringname）{

this.name=name;

}

publicvoidmethod（）{

System.out.print（"name:

"+this.name+"age:

"+this.age）;

}

publicstaticvoidmain（String[]args）{

Testtest=newTest（）;

test.setAge（20）;

test.setName（"张三"）;

test.method（）;

}

}

该class可以直接运行，运行结果为：

name:

张三age:

20