java读写文件操作

‘壹’ java 怎么读写文件

IO中的 FileInputStream 和 FileOutputStream 属于字节输入流和输出流，前者是用于读入文件，后者用于写出文件

FileWriter 和 FileReader 属于字符流 ，前者用于读入文件，后者用于写出文件

File file = new File("E:\\abc.txt");
try {
FileInputStream fis = new FileInputStream(file);
//此时文件已经读入

FileOutputStream fos = new FileOutputStream("D:\\a.txt");
//此时是写出文件
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

‘贰’ java读取、修改、写入txt文件

模拟：先创建一个TXT文件(内容来自控制台)；然后读取文件并在控制台输出；最后实现对新创建的TXT文件(的数据进行排序后)的复制。分别对应三个函数，调用顺序需要注意：创建、读取、复制。

效果图如下：绿色部分为控制台输入的内容(当输入end时，结束)

packagecom.;

importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.OutputStreamWriter;
importjava.util.Arrays;
importjava.util.Scanner;
importjava.util.Vector;

publicclassCreateAndReadTxt{
//文件名称
publicstaticStringfileName=".txt";
publicstaticStringnewFileName=".txt";
//文件路径
publicfinalstaticStringURL=System.getProperty("user.dir");

//CreateAndReadTxt.class.getResource("/").getPath();

//创建TXT文件
publicstaticvoidcreateTxtFile(StringfName,StringfileContent){
//创建文件
fileName=fName+fileName;
Filefile=newFile(fileName);
//可以更改
file.setWritable(true);
//判断当前路径下是否存在同名文件
booleanisExist=file.exists();
if(isExist){
//文件存在，删除
file.delete();
}
//写入文件
try{
//文件写入对象
FileOutputStreamfos=newFileOutputStream(file);
//输入流写入----默认字符为GBK
OutputStreamWriterosw=newOutputStreamWriter(fos);
//写入
osw.write(fileContent);
//写入完毕后关闭
osw.close();
System.out.println("成功创建文件: "+fileName);
}catch(IOExceptione){
System.out.println("写入文件失败: "+e.getMessage());
}
}

//阅读文件
publicstaticvoidreadFile(StringfileName){
System.out.println("开始读取文件: "+fileName);
//产生文件对象
Filefile=newFile(fileName);
//
try{
//字符读取
FileReaderfr=newFileReader(file);
//缓冲处理
BufferedReaderbr=newBufferedReader(fr);
Stringstr="";
while((str=br.readLine())!=null){
System.out.println(str);
}
//关闭
br.close();
fr.close();
}catch(FileNotFoundExceptione){
System.out.println("读取文件失败: "+e.getMessage());
}catch(IOExceptione){
System.out.println("读取文件失败: "+e.getMessage());
}
}
//文件复制
publicstaticvoidFile(StringfromFileName,StringtoFileName){
//读取文件
Filefile=newFile(fromFileName);
try{
FileReaderfr=newFileReader(file);
BufferedReaderbr=newBufferedReader(fr);
//定义接收变量
Vector<Double>vec=newVector<Double>();
Strings="";
while(null!=(s=br.readLine())){
vec.add(Double.parseDouble(s));
}
br.close();
fr.close();
//保存到数组并进行排序
Doubledou[]=newDouble[vec.size()];
vec.toArray(dou);
Arrays.sort(dou);
System.out.println("========复制文件=========");
//写入新文件
newFileName="副本"+newFileName;
FilenewFile=newFile(toFileName);
FileOutputStreamfos=newFileOutputStream(newFile,true);
OutputStreamWriterosm=newOutputStreamWriter(fos);
for(Doubled:dou){
osm.write(d.doubleValue()+" ");
}
osm.close();
fos.close();
}catch(FileNotFoundExceptione){
System.out.println("读取文件失败: "+e.getMessage());
}catch(IOExceptione){
System.out.println("读取文件失败: "+e.getMessage());
}

}
publicstaticvoidmain(String[]args){
/**
*构造数据
*/
Scannerscan=newScanner(System.in);
StringBuildersb=newStringBuilder();
Strings="";
while(!("end".equals(s=scan.next()))){//当输入end时，结束
sb.append(s);
sb.append(" ");
}
scan.close();
/**
*使用数据
*/
CreateAndReadTxt.createTxtFile("creat",sb.toString());
CreateAndReadTxt.readFile(fileName);
System.out.println(fileName);
CreateAndReadTxt.File(fileName,newFileName);
CreateAndReadTxt.readFile(newFileName);
}

}

‘叁’ 在Java 7中如何对文件进行操作

1.创建文件
2.删除文件
3.复制文件
4.文件移动/改名
这文件是以对Java7里提供的新的Path类很熟悉为前提，如果不熟悉这个类，Path 是文件系统里对位置的一个逻辑概念，例如 c: 和 ../foobar.txt 都是Path。
5.创建和删除文件
下面的代码片段展示的是用 Files.createFile(Path target) 方法创建文件的基本用法。
Path target = Paths.get("D:\Backup\MyStuff.txt"); Path file = Files.createFile(target);

很多时候，出于安全的原因，可能希望在创建的文件上设置一下属性，例如：是否可读/可写/写执行。这些属性依赖于文件系统的种类，需要使用跟文件系统相应的权限辅助类来完成这种操作。例如，PosixFilePermission和PosixFilePermissions 为 POSIX 文件系统设计的。下面的是在POSIX文件系统上的文件设置读写权限的用法。
Path target = Paths.get("D:\Backup\MyStuff.txt"); Set<PosixFilePermission> perms= PosixFilePermissions.fromString("rw-rw-rw-"); FileAttribute<Set<PosixFilePermission>> attr= PosixFilePermissions.asFileAttribute(perms); Files.createFile(target, attr);

这个 java.nio.file.attribute 包里提供了很多关于 FilePermission 的类。
警告 当创建一个带有权限属性的文件时，请注意包含这个文件的文件夹是否有权限的强制约束。例如，会发现，由于这些限制，尽管给创建的文件指定了 rw-rw-rw 权限，实际创建的结果却是 rw-r–r– 。
6.删除文件，使用 Files.delete(Path) 这个方法。
Path target = Paths.get("D:\Backup\MyStuff.txt"); Files.delete(target);

拷贝和移动文件
下面的代码向展示的是使用 Files.(Path source, Path target) 方法做文件拷贝的基本用法。
Path source = Paths.get("C:\My Documents\Stuff.txt"); Path target = Paths.get("D:\Backup\MyStuff.txt"); Files.(source, target);

经常的，在拷贝文件的过程中可能希望指定一些操作设置。在Java7里，可以通过使用 StandardCopyOption enum 来设置这些属性。下面看一个例子。
import static java.nio.file.StandardCopyOption.*;Path source = Paths.get("C:\My Documents\Stuff.txt");Path target = Paths.get("D:\Backup\MyStuff.txt");Files.(source, target, REPLACE_EXISTING);
拷贝操作时可以使用的属性还包括COPY_ATTRIBUTES (保留文件属性) 和 ATOMIC_MOVE (确保移动事务操作的成功，否则进行回滚)。
移动文件的操作跟拷贝很相似，使用 Files.move(Path source, Path target) 方法。
同样，也可以指定移动操作的属性，使用 Files.move(Path source, Path target, CopyOptions...) 方法里的参数来设置。
import static java.nio.file.StandardCopyOption.*; Path source = Paths.get("C:\My Documents\Stuff.txt"); Path target = Paths.get("D:\Backup\MyStuff.txt"); Files.move(source, target, REPLACE_EXISTING, COPY_ATTRIBUTES);

可以看出，新的用于文件操作的 NIO.2 API 非常便于使用。

‘肆’ java中关于文件读写操作

try{
String s=null;
BufferedReader reader=new BufferedReader(new FileReader("D:\\error.txt"));
FileWriter writer=new FileWriter("D:\\test.txt");
boolean serious=false;
while((s=reader.readLine())!=-1){
if(serious){
writer.write(s);
}
if(s=="serious error") serious=true;
}
}catch(Exception e){}

‘伍’ 如何在java中读写文件

FileOutputStream 的一个构造方法中有两个参数,第一个为文件路径,第二个参数为boolen值. 列如:
FileOutputStream fos=FileOutputStream("c:\\test.txt",true);
当第二个参数设为true时,则在文件末尾追加数据;
当第二个参数设为false时,则重写文件;

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

‘陆’ java 中简述使用流进行读写文本文件的步骤

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

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

简单的示例程序如下：

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

import java.io.*;

public class ReadWriteFile{
public static void main(String[] args){
try{

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

BufferedReader br = new BufferedReader(
new FileReader(read));
BufferedWriter bw = new BufferedWriter(
new FileWriter(write));
String temp = null;
temp = br.readLine();
while(temp != null){
//写文件
bw.write(temp + "\r\n"); //只适用Windows系统
//继续读文件
temp = br.readLine();
}

bw.close();
br.close();

}catch(FileNotFoundException e){ //文件未找到
System.out.println (e);
}catch(IOException e){
System.out.println (e);
}
}
}

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

二、Java IO学习笔记+代码

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

/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:10
*
* 文件对象的生成和文件的创建
*/
package study.iostudy;
import java.io.*;
public class GenerateFile
{
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir");
File fileObject1 = new File("oneFirst.txt");
File fileObject2 = new File("d:\\mydir", "firstFile.txt");
System.out.println(fileObject2);
try
{
dirObject.mkdir();
}catch(SecurityException e)
{
e.printStackTrace();
}
try
{
fileObject2.createNewFile();
fileObject1.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
}
}

文件名的处理
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:29
*
* 文件名的处理
*/
package study.iostudy;
import java.io.*;
/*
* 文件名的处理
* 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\\firstFile.txt");
File fileObject2 = new File("d:\\firstFile.txt");
boolean pathAbsolute = fileObject1.isAbsolute();
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("There are some information of fileObject1's file name:");
System.out.println("fileObject1: " + fileObject1);
System.out.println("fileObject2: " + fileObject2);
System.out.println("file name: " + fileObject1.getName());
System.out.println("file path: " + fileObject1.getPath());
System.out.println("file absolute path: " + fileObject1.getAbsolutePath());
System.out.println("file's parent directory: " + fileObject1.getParent());
System.out.println("file's absoulte path: " + pathAbsolute);
int sameName = fileObject1.compareTo(fileObject2);
System.out.println("fileObject1 compare to fileObject2: " + sameName);
fileObject1.renameTo(fileObject2);
System.out.println("file's new name: " + fileObject1.getName());
}
}

测试和设置文件属性
/*
* SetterFileAttribute.java
*
* Created on 2006年8月22日, 下午3:51
*
* 测试和设置文件属性
*/
package study.iostudy;
import java.io.*;
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\\firstFile.txt");
try
{
dirObject.mkdir();
fileObject.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("there are some information about property of file object:");
System.out.println("file object : " + fileObject);
System.out.println("file exist? " + fileObject.exists());
System.out.println("Is a file? " + fileObject.isFile());
System.out.println("Is a directory?" + fileObject.isDirectory());
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
long fileLen = fileObject.length();
System.out.println("file length: " +fileLen);
boolean fileRead = fileObject.setReadOnly();
System.out.println(fileRead);
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
}
}

文件操作方法
/*
* FileOperation.java
*
* Created on 2006年8月22日, 下午4:25
*
* 文件操作方法
*/

package study.iostudy;
import java.io.*;
/*
* 有关文件操作方面的方法有如下几种:
* boolean createNewFile(); 根据当前的文件对象创建一个新的文件。
* boolean mkdir(); 根据当前的文件对象生成一目录，也就是指定路径下的文件夹。
* boolean mkdirs(); 也是根据当前的文件对象生成一个目录，
* 不同的地方在于该方法即使创建目录失败，
* 也会成功参数中指定的所有父目录。
* boolean delete(); 删除当前的文件。
* void deleteOnExit(); 当前Java虚拟机终止时删除当前的文件。
* String list(); 列出当前目录下的文件。
*/
public class FileOperation
* 找出一个目录下所有的文件
package study.iostudy;
import java.io.*;
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");
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("list HTML files in directory: " + dirObject);
String[] filesObj1 = dirObject.list(filterObj1);
for (int i = 0; i < filesObj1.length; i++)
{
File fileObject = new File(dirObject, filesObj1[i]);
System.out.println(((fileObject.isFile())
? "HTML file: " : "sub directory: ") + fileObject);
}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
String[] filesObj2 = dirObject.list(filterObj2);
for (int i = 0; i < filesObj2.length; i++)
{
File fileObject = new File(dirObject, filesObj2[i]);
System.out.println(((fileObject.isFile())
? "htm file: " : "sub directory: ") + fileObject);
}
}
}

class Filter1 implements FilenameFilter
{
String fileExtent;
Filter1(String extentObj)
{
fileExtent = extentObj;
}

public boolean accept(File dir, String name)
{
return name.endsWith("." + fileExtent);
}
}

class Filter2 implements FilenameFilter
{
String fileName;
Filter2(String fileName)
{
this.fileName = fileName;
字符流处理
* ProcesserCharacterStream.java
* 字符流处理
*
* java.io包中加入了专门用于字符流处理的类，这些类都是Reader和Writer类的子类，
* Reader和Writer是两个抽象类，只提供了一系列用于字符流处理的接口，不能生成这
* 两个类的实例。
* java.io包中用于字符流处理的最基本的类是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"，而是系统定义的属性line.separator。
在上面的程序中，我们首先声明了FileInputStream类对象inStream和
* FileOutputStream类的对象outStream，接着声明了BufferInputStream
* 类对象bufObj、BufferedOutputStream类对象bufOutObj、
* DataInputStream类对象dataInObj以及PushbackInputStream类对象pushObj，
* 在try代码块中对上面这些对象进行初始化，程序的目的是通过BufferedInputStream
* 类对象bufInObj和BufferedOutputStream类对象bufOutObj将secondFile.txt
* 文件中内容输出到屏幕，并将该文件的内容写入thirdFile.txt文件中，值得注意的是，
* 将secondFile.txt文件中的内容输出之前，程序中使用
* "System.out.println(dataInObj.readBoolean());" 语句根据readBoolean()结果
* 输出了true，而secondFile.txt文件开始内容为“Modify”，和一个字符为M，
* 因此输出的文件内容没有“M”字符，thirdFile.txt文件中也比secondFile.txt
* 文件少第一个字符“M”。随后，通过PushbackInputStream类对象pushObj读取
* thirdFile.txt文件中的内容，输出读到的字符，当读到的不是字符，输出回车，将字符
* 数组pushByte写回到thirdFile.txt文件中，也就是“ok”写回文件中。
* 对象串行化
* 对象通过写出描述自己状态的数值来记录自己，这个过程叫做对象串行化。对象的寿命通
* 常是随着生成该对象的程序的终止而终止，在有些情况下，需要将对象的状态保存下来，然后
* 在必要的时候将对象恢复，值得注意的是，如果变量是另一个对象的引用，则引用的对象也要
* 串行化，串行化是一个递归的过程，可能会涉及到一个复杂树结构的串行化，比如包括原有对
* 象，对象的对象等。
* 在java.io包中，接口Serializable是实现对象串行化的工具,只有实现了Serializable
* 的对象才可以被串行化。Serializable接口中没有任何的方法，当一个类声明实现Seriali-
* zable接口时，只是表明该类遵循串行化协议，而不需要实现任何特殊的方法。
* 在进行对象串行化时，需要注意将串行化的对象和输入、输出流联系起来，首先通过对
* 象输出流将对象状态保存下来，然后通过对象输入流将对象状态恢复。

‘柒’ java读取文件操作

while(line != null)
{
System.out.println(line);

output.write(line);
output.newLine();
line = br.readLine();

}
output.flush();
output.close();
如果没有flush，写入的数据可能不完整。循环完以后加上这两句即可

‘捌’ java对文件读写操作，文件大小有限制么

你如果是要一次读完一个文件的话，应该会有大小限制。
一般情况下，打比方，你有个100MB的文件，你并不是一次读完，而是分块，10MB一次的读取，所以文件大小不会有限制。

‘玖’ java中如何使用缓冲区对文件进行读写操作

首先，了解下什么是缓冲区：
电脑内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

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

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

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

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

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

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

如何对缓冲区进行操作：
当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader， 它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。使用FileReader读取文件：
FileReader fr = new FileReader("ming.txt");
int ch = 0;
while((ch = fr.read())!=-1 )
{
System.out.print((char)ch);
}
其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似。
事实上在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);
}
了解了FileReader操作使用FileWriter写文件就简单了，这里不赘述。
Eg.我的综合实例：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class testFile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// file(内存)----输入流---->【程序】----输出流---->file(内存)
File file = new File("d:/temp", "addfile.txt");
try {
file.createNewFile(); // 创建文件
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

// 向文件写入内容(输出流)
String str = "亲爱的小南瓜！";
byte bt[] = new byte[1024];
bt = str.getBytes();
try {
FileOutputStream in = new FileOutputStream(file);
try {
in.write(bt, 0, bt.length);
in.close();
// boolean success=true;
// System.out.println("写入文件成功");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
// 读取文件内容 (输入流)
FileInputStream out = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(out);
int ch = 0;
while ((ch = isr.read()) != -1) {
System.out.print((char) ch);
}
} catch (Exception e) {
// TODO: handle exception
}
}
}

‘拾’ Java中对文件进行读写操作的基本类是什么

Java.io包中包括许多类提供许多有关文件的各个方面操作。
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();
pinput.connect(pOutput);
5 管道的输入与输出：
输出管道对象调用write()成员函数输出数据（即向管道的输入端发送数据）；而输入管道对象调用read()成员函数可以读起数据（即从输出管道中获得数据）。这主要是借助系统所提供的缓冲机制来实现的。
6随机文件读写：
RandomAccessFile类（它直接继承于Object类而非InputStream/OutputStream类），从而可以实现读写文件中任何位置中的数据（只需要改变文件的读写位置的指针）。
随机文件读写编程的基本过程为：
① 生成流对象并且指明读写类型；
② 移动读写位置；
③ 读写文件内容；
④ 关闭文件。

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