如何在java中读写文件

FileOutputStream 的一个构造方法中有两个参数,第一个为文件路径,第二个参数为boolen值 列如:

FileOutputStream fos=FileOutputStream("c:\\testtxt",true);

当第二个参数设为true时,则在文件末尾追加数据;

当第二个参数设为false时,则重写文件;

注意:第二个参数可以不写,缺省值为false

首先，了解下什么是缓冲区：

电脑内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

栈——就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

堆——就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete如果程序员没有释放掉，那么在程序结束后， *** 作系统会自动回收。

自由存储区——就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

全局/静态存储区——全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）

电脑缓冲区就是预留下来的做为急用的那一部分，为暂时置放输出或输入资料的内存。

如何对缓冲区进行 *** 作：

当我们读写文本文件的时候，采用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)这和处理二进制文件的时候类似。

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

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

String data = null;

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

{

Systemoutprintln(data);

}

了解了FileReader *** 作使用FileWriter写文件就简单了，这里不赘述。

Eg我的综合实例：

import javaioFile;

import javaioFileInputStream;

import javaioFileNotFoundException;

import javaioFileOutputStream;

import javaioIOException;

import javaioInputStreamReader;

public class testFile {

/

@param args

/

public static void main(String[] args) {

// TODO Auto-generated method stub

// file(内存)----输入流---->程序----输出流---->file(内存)

File file = new File("d:/temp", "addfiletxt");

try {

filecreateNewFile(); // 创建文件

} catch (IOException e) {

// TODO Auto-generated catch block

eprintStackTrace();

}

// 向文件写入内容(输出流)

String str = "亲爱的小南瓜！";

byte bt[] = new byte[1024];

bt = strgetBytes();

try {

FileOutputStream in = new FileOutputStream(file);

try {

inwrite(bt, 0, btlength);

inclose();

// boolean success=true;

// Systemoutprintln("写入文件成功");

} catch (IOException e) {

// TODO Auto-generated catch block

eprintStackTrace();

}

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

eprintStackTrace();

}

try {

// 读取文件内容 (输入流)

FileInputStream out = new FileInputStream(file);

InputStreamReader isr = new InputStreamReader(out);

int ch = 0;

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

Systemoutprint((char) ch);

}

} catch (Exception e) {

// TODO: handle exception

}

}

}

主要有用到java原生态的Io类，没有第三个包。直接上代码：

public class write {

    public static void main(String[] args) {

        write("E://123txt", "hello");

    }

    public static void write(String path, String content) {

        try {

            File f = new File(path);

            if (fexists()) {

                Systemoutprintln("文件存在");

            } else {

                Systemoutprintln("文件不存在，正在创建");

                if (fcreateNewFile()) {

                    Systemoutprintln("文件创建成功！");

                } else {

                    Systemoutprintln("文件创建失败！");

                }

            }

            BufferedWriter output = new BufferedWriter(new FileWriter(f));

            outputwrite(content);

            outputclose();

        } catch (Exception e) {

            eprintStackTrace();

        }

    }

}

import javaioBufferedReader;

import javaioFile;

import javaioFileReader;

import javaioFileWriter;

import javaioIOException;

public class IOTest {

public static void main(String[] args) {

String str = "123\r\n456";

writeFile(str);//写

String str1 = readFile();//读

Systemoutprintln(str1);

}

/

传递写的内容

@param str

/

static void writeFile(String str) {

try {

File file = new File("d:\\filetxt");

if(fileexists()){//存在

filedelete();//删除再建

filecreateNewFile();

}else{

filecreateNewFile();//不存在直接创建

}

FileWriter fw = new FileWriter(file);//文件写IO

fwwrite(str);

fwflush();

fwclose();

} catch (IOException e) {

eprintStackTrace();

}

}

/

返回读取的内容

@return

/

static String readFile() {

String str = "", temp = null;

try {

File file = new File("d:\\filetxt");

FileReader fr = new FileReader(file);

BufferedReader br = new BufferedReader(fr);//文件读IO

while((temp = brreadLine())!=null){//读到结束为止

str += (temp+"\n");

}

brclose();

frclose();

} catch (IOException e) {

eprintStackTrace();

}

return str;

}

}

刚写的，够朋友好好学习一下啦，呵呵

多多看API，多多练习

思路写一下：

追加内容的方法

boolean addInfo(String str,Integer ints){

//讲传入的字符串与数字组织成一个字符串，例如str+" "+ints;

//创建文件IO流，讲改字符串写入到文件中，最后加上换行，建议使用字符流来写，方便些

//出现异常return false

return true;

}

查找 *** 作

Integer getIntByString(String str){

//使用字符流从文件中一行一行的读取内容

//从末尾查找第一个" "，可以得到它的索引，假定为idx

//查找到后，下面的 *** 作分两种

//1该 *** 作只使用1次

//使用readLine()方法去读取内容，要循环的啊

//11使用取子串方法，取出读取的字符串从0开始到idx结束的所有内容getStr

//12使用你传入的参数与getStr进行equals，如果false就continue

//13如果true就使用取子串方法substring从idx+1取到末尾得到getInt

//14IntegerpaseInt(getInt)就是你要的东西了，然后break;

//2该查找 *** 作使用多次

//创建一个HashMap的对象hm，该对象是一个类变量（你文件中不会有相同的字符串吧，如果有我就先汗一个）

//进行循环，如上 *** 作，取出的字符串假定为s1，数字假定的s2（最好设计成Integer类型的），不需要判断直接讲其使用HashMap的put(s1,s2)放入到集合中

//需要查找什么直接使用hmget(str)就可以得到值了

第二种方式就是传说中的桌面级汉译英字典的制作方式

}

java当中读和写是可以同时进行的，但限于同一个程序，相当于复制功能，你可以建立一个BufferedReader和BufferedWrite缓冲区，把读到的内容先放在缓冲区里，再进行 *** 作，这样可以提高读写效率。

当java 文件读写时 另一程序正在读写，很有可能会发生程序运行冲突，终止。可以把这种情况当异常处理，直接抛出。

Javaio包中包括许多类提供许多有关文件的各个方面 *** 作。

1 输入输出抽象基类InputStream/OutputStream ，实现文件内容 *** 作的基本功能函数read()、 write()、close()、skip()等；一般都是创建出其派生类对象（完成指定的特殊功能）来实现文件读写。在文件读写的编程过程中主要应该注意异常处理的技术。

2 FileInputStream/FileOutputStream：

用于本地文件读写（二进制格式读写并且是顺序读写，读和写要分别创建出不同的文件流对象）；

本地文件读写编程的基本过程为：

① 生成文件流对象（对文件读 *** 作时应该为FileInputStream类，而文件写应该为FileOutputStream类）；

② 调用FileInputStream或FileOutputStream类中的功能函数如read()、write(int b)等）读写文件内容；

③ 关闭文件（close()）。

3 PipedInputStream/PipedOutputStream：

用于管道输入输出（将一个程序或一个线程的输出结果直接连接到另一个程序或一个线程的输入端口，实现两者数据直接传送。 *** 作时需要连结）；

4管道的连接：

方法之一是通过构造函数直接将某一个程序的输出作为另一个程序的输入，在定义对象时指明目标管道对象

PipedInputStream pInput=new PipedInputStream();

PipedOutputStream pOutput= new PipedOutputStream(pInput);

方法之二是利用双方类中的任一个成员函数 connect()相连接

PipedInputStream pInput=new PipedInputStream();

PipedOutputStream pOutput= new PipedOutputStream();

pinputconnect(pOutput);

5 管道的输入与输出：

输出管道对象调用write()成员函数输出数据（即向管道的输入端发送数据）；而输入管道对象调用read()成员函数可以读起数据（即从输出管道中获得数据）。这主要是借助系统所提供的缓冲机制来实现的。

6随机文件读写：

RandomAccessFile类（它直接继承于Object类而非InputStream/OutputStream类），从而可以实现读写文件中任何位置中的数据（只需要改变文件的读写位置的指针）。

随机文件读写编程的基本过程为：

① 生成流对象并且指明读写类型；

② 移动读写位置；

③ 读写文件内容；

④ 关闭文件。

七里河团队答疑助人,希望我的回答对你有所帮助

一、Java IO学习基础之读写文本文件

Java的IO *** 作都是基于流进行 *** 作的，为了提高读写效率一般需要进行缓冲。

简单的示例程序如下：

/

读出1txt中的内容，写入2txt中

/

import javaio;

public class ReadWriteFile{

public static void main(String[] args){

try{

File read = new File("c:\\1txt");

File write = new File("c:\\2txt");

BufferedReader br = new BufferedReader(

new FileReader(read));

BufferedWriter bw = new BufferedWriter(

new FileWriter(write));

String temp = null;

temp = brreadLine();

while(temp != null){

//写文件

bwwrite(temp + "\r\n"); //只适用Windows系统

//继续读文件

temp = brreadLine();

}

bwclose();

brclose();

}catch(FileNotFoundException e){ //文件未找到

Systemoutprintln (e);

}catch(IOException e){

Systemoutprintln (e);

}

}

}

以上是一个比较简单的基础示例。本文上下两部分都是从网上摘抄，合并在一起，方便下自己以后查找。

二、Java IO学习笔记+代码

文件对象的生成和文件的创建

/

ProcessFileNamejava

Created on 2006年8月22日, 下午3:10

文件对象的生成和文件的创建

/

package studyiostudy;

import javaio;

public class GenerateFile

{

public static void main(String[] args)

{

File dirObject = new File("d:\\mydir");

File fileObject1 = new File("oneFirsttxt");

File fileObject2 = new File("d:\\mydir", "firstFiletxt");

Systemoutprintln(fileObject2);

try

{

dirObjectmkdir();

}catch(SecurityException e)

{

eprintStackTrace();

}

try

{

fileObject2createNewFile();

fileObject1createNewFile();

}catch(IOException e)

{

eprintStackTrace();

}

}

}

文件名的处理

/

ProcessFileNamejava

Created on 2006年8月22日, 下午3:29

文件名的处理

/

package studyiostudy;

import javaio;

/

文件名的处理

String getName(); 获得文件的名称，不包含文件所在的路径。

String getPath(); 获得文件的路径。

String getAbsolutePath(); 获得文件的绝对路径。

String getParent(); 获得文件的上一级目录的名称。

String renameTo(File newName); 按参数中给定的完整路径更改当前的文件名。

int compareTo(File pathName); 按照字典顺序比较两个文件对象的路径。

boolean isAbsolute(); 测试文件对象的路径是不是绝对路径。

/

public class ProcesserFileName

{

public static void main(String[] args)

{

File fileObject1 = new File("d:\\mydir\\firstFiletxt");

File fileObject2 = new File("d:\\firstFiletxt");

boolean pathAbsolute = fileObject1isAbsolute();

Systemoutprintln(" ");

Systemoutprintln("There are some information of fileObject1's file name:");

Systemoutprintln("fileObject1: " + fileObject1);

Systemoutprintln("fileObject2: " + fileObject2);

Systemoutprintln("file name: " + fileObject1getName());

Systemoutprintln("file path: " + fileObject1getPath());

Systemoutprintln("file absolute path: " + fileObject1getAbsolutePath());

Systemoutprintln("file's parent directory: " + fileObject1getParent());

Systemoutprintln("file's absoulte path: " + pathAbsolute);

int sameName = fileObject1compareTo(fileObject2);

Systemoutprintln("fileObject1 compare to fileObject2: " + sameName);

fileObject1renameTo(fileObject2);

Systemoutprintln("file's new name: " + fileObject1getName());

}

}

测试和设置文件属性

/

SetterFileAttributejava

Created on 2006年8月22日, 下午3:51

测试和设置文件属性

/

package studyiostudy;

import javaio;

public class SetterFileAttribute

{

/

File类中提供的有关文件属性测试方面的方法有以下几种：

boolean exists(); 测试当前文件对象指示的文件是否存在。

boolean isFile(); 测试当前文件对象是不是文件。

boolean isDirectory(); 测试当前文件对象是不是目录。

boolean canRead(); 测试当前文件对象是否可读。

boolean canWrite(); 测试当前文件对象是否可写。

boolean setReadOnly(); 将当前文件对象设置为只读。

long length(); 获得当前文件对象的长度。

/

public static void main(String[] args)

{

File dirObject = new File("d:\\mydir");

File fileObject = new File("d:\\mydir\\firstFiletxt");

try

{

dirObjectmkdir();

fileObjectcreateNewFile();

}catch(IOException e)

{

eprintStackTrace();

}

Systemoutprintln(" ");

Systemoutprintln("there are some information about property of file object:");

Systemoutprintln("file object : " + fileObject);

Systemoutprintln("file exist " + fileObjectexists());

Systemoutprintln("Is a file " + fileObjectisFile());

Systemoutprintln("Is a directory" + fileObjectisDirectory());

Systemoutprintln("Can read this file " + fileObjectcanRead());

Systemoutprintln("Can write this fie " + fileObjectcanWrite());

long fileLen = fileObjectlength();

Systemoutprintln("file length: " +fileLen);

boolean fileRead = fileObjectsetReadOnly();

Systemoutprintln(fileRead);

Systemoutprintln("Can read this file " + fileObjectcanRead());

Systemoutprintln("Can write this fie " + fileObjectcanWrite());

Systemoutprintln(" ");

}

}

文件 *** 作方法

/

FileOperationjava

Created on 2006年8月22日, 下午4:25

文件 *** 作方法

/

package studyiostudy;

import javaio;

/

有关文件 *** 作方面的方法有如下几种:

boolean createNewFile(); 根据当前的文件对象创建一个新的文件。

boolean mkdir(); 根据当前的文件对象生成一目录，也就是指定路径下的文件夹。

boolean mkdirs(); 也是根据当前的文件对象生成一个目录，

不同的地方在于该方法即使创建目录失败，

也会成功参数中指定的所有父目录。

boolean delete(); 删除当前的文件。

void deleteOnExit(); 当前Java虚拟机终止时删除当前的文件。

String list(); 列出当前目录下的文件。

/

public class FileOperation

找出一个目录下所有的文件

package studyiostudy;

import javaio;

public class SearchFile

{

public static void main(String[] args)

{

File dirObject = new File("D:\\aa");

Filter1 filterObj1 = new Filter1("HTML");

Filter2 filterObj2 = new Filter2("Applet");

Systemoutprintln("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

Systemoutprintln("list HTML files in directory: " + dirObject);

String[] filesObj1 = dirObjectlist(filterObj1);

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

{

File fileObject = new File(dirObject, filesObj1[i]);

Systemoutprintln(((fileObjectisFile())

"HTML file: " : "sub directory: ") + fileObject);

}

Systemoutprintln("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

String[] filesObj2 = dirObjectlist(filterObj2);

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

{

File fileObject = new File(dirObject, filesObj2[i]);

Systemoutprintln(((fileObjectisFile())

"htm file: " : "sub directory: ") + fileObject);

}

}

}

class Filter1 implements FilenameFilter

{

String fileExtent;

Filter1(String extentObj)

{

fileExtent = extentObj;

}

public boolean accept(File dir, String name)

{

return nameendsWith("" + fileExtent);

}

}

class Filter2 implements FilenameFilter

{

String fileName;

Filter2(String fileName)

{

thisfileName = fileName;

字符流处理

ProcesserCharacterStreamjava

字符流处理

javaio包中加入了专门用于字符流处理的类，这些类都是Reader和Writer类的子类，

Reader和Writer是两个抽象类，只提供了一系列用于字符流处理的接口，不能生成这

两个类的实例。

javaio包中用于字符流处理的最基本的类是InputStreamReader和OutputStreamWriter，

用来在字节流和字符流之间作为中介。

下面是InputStreamReader类和OutputStreamWriter类的常用方法：

public InputStreamReader(InputStream in)

根据当前平台缺省的编码规范，基于字节流in生成一个输入字符流。

public InputStreamReader(InputStream in, String sysCode)throws UnSupportedEncodingException

按照参数sysCode指定的编码规范，基于字节流in构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。

public OutputStreamWriter(OutputStream out)

根据当前平台缺省的编码规范，基于字节流out生成一个输入字符流。

public OutputStreamWriter(OutputStream out, String sysCode) throws UnsupportedEncodingException

按照参数sysCode指定的编码规范，基于字节流out构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。

public String getEncoding()

获得当前字符流使用的编码方式。

public void close() throws IOException

用于关闭流。

public int read() throws IOException

用于读取一个字符。

public int read(char[] cbuf, int off, int len)

用于读取len个字符到数组cbuf的索引off处。

public void write(char[] cbuf, int off, int len) throws IOException

将字符数组cbuf中从索引off处开始的len个字符写入输出流。

public void write(int c) throws IOException

将单个字符写入输入流。

public void write(String str, int off, int len) throws IOException

将字符串str中从索引off位置开始的ltn个字符写入输出流。

此外，为了提高字符流处理的效率，在Java语言中，引入了BufferedReader和BufferWriter类，这两个类对字符流进行块处理。

两个类的常用方法如下：

public BufferedReader(Reader in)

用于基于普通字符输入流in生成相应的缓冲流。

public BufferedReader(Reader in, int bufSize)

用于基于普通字符输入流in生成相应的缓冲流，缓冲区大小为参数bufSize指定。

public BufferedWriter(Writer out)

用于基于普通字符输入流out生成相应的缓冲流。

public BufferedWriter(Writer out, int bufSize)

用于基于普通字符输入流out生在相应缓冲流，缓冲流大小为参数bufSize指定。

public String readLine() throws IOException

用于从输入流中读取一行字符。

public void newLine() throws IOException

用于向字符输入流中写入一行结束标记，值得注意的是，该标记不是简单的换行符"\n"，而是系统定义的属性lineseparator。

在上面的程序中，我们首先声明了FileInputStream类对象inStream和

FileOutputStream类的对象outStream，接着声明了BufferInputStream

类对象bufObj、BufferedOutputStream类对象bufOutObj、

DataInputStream类对象dataInObj以及PushbackInputStream类对象pushObj，

在try代码块中对上面这些对象进行初始化，程序的目的是通过BufferedInputStream

类对象bufInObj和BufferedOutputStream类对象bufOutObj将secondFiletxt

文件中内容输出到屏幕，并将该文件的内容写入thirdFiletxt文件中，值得注意的是，

将secondFiletxt文件中的内容输出之前，程序中使用

"Systemoutprintln(dataInObjreadBoolean());" 语句根据readBoolean()结果

输出了true，而secondFiletxt文件开始内容为“Modify”，和一个字符为M，

因此输出的文件内容没有“M”字符，thirdFiletxt文件中也比secondFiletxt

文件少第一个字符“M”。随后，通过PushbackInputStream类对象pushObj读取

thirdFiletxt文件中的内容，输出读到的字符，当读到的不是字符，输出回车，将字符

数组pushByte写回到thirdFiletxt文件中，也就是“ok”写回文件中。

对象串行化

对象通过写出描述自己状态的数值来记录自己，这个过程叫做对象串行化。对象的寿命通

常是随着生成该对象的程序的终止而终止，在有些情况下，需要将对象的状态保存下来，然后

在必要的时候将对象恢复，值得注意的是，如果变量是另一个对象的引用，则引用的对象也要

串行化，串行化是一个递归的过程，可能会涉及到一个复杂树结构的串行化，比如包括原有对

象，对象的对象等。

在javaio包中，接口Serializable是实现对象串行化的工具,只有实现了Serializable

的对象才可以被串行化。Serializable接口中没有任何的方法，当一个类声明实现Seriali-

zable接口时，只是表明该类遵循串行化协议，而不需要实现任何特殊的方法。

在进行对象串行化时，需要注意将串行化的对象和输入、输出流联系起来，首先通过对

象输出流将对象状态保存下来，然后通过对象输入流将对象状态恢复。

以上就是关于如何在java中读写文件全部的内容，包括:如何在java中读写文件、java中如何使用缓冲区对文件进行读写 *** 作、java怎样实现读写TXT文件等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！