在Java中IO操作也是有相应步骤的，以文件操作为例，主要的操作流程如下：回
1。使用File类打开一个答文件
2。通过字节流或字符流的子类，指定输出的位置
3。进行读/写操作
4。关闭输入/输出
5。IO操作属于资源操作，一定要记得关闭
『贰』 java文件如何读取
有几种方法读取吧
File file = new File("d:\\a.txt");//把D盘目录下的a.txt读取出来，
InputStream is = new FileInputStream(file);//把文件以字节流读回到内存中
第二种是类加答载
Demo1.class.getClassLoader().getResourceAsStream("a.txt");//Demo1为当前类名，a.txt在与Demo1.class在同一目录下。
还有其它的就不说了
『叁』 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怎么读取某个文本文件的内容写入到另一个文本文件
/** * 读出写出 * @param oldFileName 源文件 * @param newFileName 新文件 * @throws IOException */public static void testRead(String oldFileName,String newFileName) throws IOException{ FileOutputStream fos=new FileOutputStream(new File(newFileName)); RandomAccessFile raf=new RandomAccessFile(new File(oldFileName), "rw"); fos.write(raf.read(new byte[8])); fos.flush(); fos.close(); raf.close();} public static void fileWrite() throws FileNotFoundException, IOException { testRead("G:/森云/测试文件1。txt","G:/newFile.txt");}
『伍』 java怎样实现读写TXT文件
主要有用到java原生态的Io类，没有第三个包。直接上代码：
importjava.io.*;
publicclasswrite{
publicstaticvoidmain(String[]args){
write("E://123.txt","hello");
}
publicstaticvoidwrite(Stringpath,Stringcontent){
try{
Filef=newFile(path);
if(f.exists()){
System.out.println("文件存在");
}else{
System.out.println("文件不存在，正在创建...");
if(f.createNewFile()){
System.out.println("文件创建成功！");
}else{
System.out.println("文件创建失败！");
}
}
BufferedWriteroutput=newBufferedWriter(newFileWriter(f));
output.write(content);
output.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}
『陆』 java文件读写
在网上查了很多关于修改文件的方法，不得其要领。自己想了两个取巧的办法，来解决对文件的修改。一：读取一个文件file1（FileReader and BufferedReader），进行操作后写入file2(FileWriter and BufferedWriter)，然后删除file1，更改file2文件名为file1(Rename()方法)。二：创建字符缓冲流（StringBuffer），读取文件内容赋给字符缓冲流，再将字符缓冲流中的内容写入到读取的文件中。例如： test.txt 这里是放在d盘的根目录下，内容如下 able adj 有才干的，能干的 active adj 主动的，活跃的 adaptable adj 适应性强的 adroit adj 灵巧的，机敏的 运行结果生成在同目录的 test1.txt中 able #adj*有才干的，能干的 active #adj*主动的，活跃的 adaptable #adj*适应性强的 adroit #adj*灵巧的，机敏的 代码： public class Test { public static void main(String[] args) throws Exception{ BufferedReader br = new BufferedReader(new FileReader("D:\\test.txt")); StringBuffer sb = new StringBuffer(); String lineContent = null ;while( (lineContent = br.readLine()) != null){ String[] sp = lineContent.split(" ");sp[0] = sp[0].concat(" *");sp[1] = sp[1].concat("# ");for(int i=0;i sb.append(sp[i]);}sb.append("\r\n");}FileWriter fw = new FileWriter("D:\\test2.txt"); fw.write(sb.toString()); br.close(); fw.close(); }}
『柒』 java读取、修改、写入txt文件
Java IO系统里读写文件使用和Writer两个抽象类，Reader中read()和close()方法都是抽象方法。Writer中 write()，flush()和close()方法为抽象方法。子类应该分别实现他们。
Java IO已经为我们提供了三个方便的Reader的实现类，FileReader,InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader， 它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。
FileReader读txt文件例子
FileReader fr = new FileReader("D:/Test.txt");
int ch = 0;
while((ch = fr.read())!=-1 ){
System.out.print( (char)ch );
}
其中read()方法返回的是读取得下个字符。
InputStreamReader读txt文件例子
InputStream is = new FileInputStream(new File("D:/Test.txt"));
InputStreamReader fr = new InputStreamReader(is);
int ch = 0;
while((ch = fr.read())!=-1 ){
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。 read()方法是比较好费时间的，如果为了提高效率，我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用 readLine()方法。
BufferedReader br = new BufferedReader(new FileReader("Test.txt")));
String data = br.readLine();//一次读入一行，直到读入null为文件结束
while( data!=null){
System.out.println(data);
data = br.readLine(); //接着读下一行
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。
有读就有写，写文本文件可以使用PrintWriter，FileWriter，BufferedWriter。
FileWriter fw = new FileWriter("D:/Test.txt");
String s = "hello world";
fw.write(s,0,s.length());
fw.flush();
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:/Test1.txt"));
osw.write(s,0,s.length());
osw.flush();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("D:/Test2.txt")),true);
pw.println(s);
fw.close();
osw.close();
pw.close();
如果想接着写入某个文件。 声明时FileWriter fw = new FileWriter("log.txt",true);加个true就可以了。
File file = new File("D:/Test.txt");
File dest = new File("D:/new.txt");
try {
BufferedReader reader = new BufferedReader(new FileReader(file));
BufferedWriter writer = new BufferedWriter(new FileWriter(dest));
String line = reader.readLine();
while(line!=null){
writer.write(line);
line = reader.readLine();
}
writer.flush();
reader.close();
writer.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
『捌』 java中读入和输出文本文件
/**
*测试3：从文本文件中读取数据
*/
staticvoidtestExample03(){
//1、在内存中打开要读取文件的字符流对象
try{
Readerreader=newFileReader("e:/ReadMe.log");
//2、从字符流中读取数据
//一次读取一个字符（麻烦）
/*intnum=reader.read();
System.out.println((char)num);
num=reader.read();
System.out.println((char)num);*/
//一次读取一个数组（必须确定数组的长度）
/*char[]cbuf=newchar[10];
reader.read(cbuf);
System.out.println(newString(cbuf));*/
//循环读取，一次就读一个
intch=reader.read();
StringBufferbuffer=newStringBuffer();
while(ch!=-1){//读取成功
buffer.append((char)ch);
ch=reader.read();
}
System.out.println(buffer.toString());
//3、关闭流
reader.close();
}catch(FileNotFoundExceptione){
System.out.println("要读取的文件不存在："+e.getMessage());
}catch(IOExceptione){
System.out.println("文件读取错误："+e.getMessage());
}
}
/**
*测试4：向文本文件中写入数据
*/
staticvoidtestExample04(){
System.out.println("请输入内容：");
Stringtext=input.next();
try{
//1、打开流
Writerw=newFileWriter("e:/测试.txt",true);
//2、写入内容
w.write(text);
//3、关闭流
w.close();
}catch(IOExceptione){
System.out.println("文件写入错误："+e.getMessage());
}
}
/**
*测试5：使用效率高的字符流读写数据
*/
staticvoidtestExample05(){
try{
//1、创建流对象
Readerreader=newFileReader("e:/ReadMe.log");
//构建高效流对象
BufferedReaderbuffReader=newBufferedReader(reader);
//2、读取一行字符串
Stringline=buffReader.readLine();
StringBufferbuffer=newStringBuffer();
while(line!=null){
buffer.append(line+" ");
line=buffReader.readLine();
}
System.out.println(buffer.toString());;
//3、关闭流
buffReader.close();
reader.close();
Writerw=newFileWriter("e:/NewReadMe.txt");
BufferedWriterbuffWriter=newBufferedWriter(w);
buffWriter.write(buffer.toString());
buffWriter.close();
w.close();
System.out.println("写入成功！");
}catch(FileNotFoundExceptione){
System.out.println("要读取的文件不存在："+e.getMessage());
}catch(IOExceptione){
System.out.println("文件读取错误："+e.getMessage());
}
}
『玖』 java 中简述使用流进行读写文本文件的步骤
读写是两个不同的分支，通常都是分开单独使用的。
可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流
while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环
{
System.out.println(str);//原样输出读到的内容
}；
备注： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行存储，举例：
OutputStreamWriter pw = null;//定义一个流
pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例
pw.write("我是要写入到记事本文件的内容");//将要写入文件的内容，可以多次write
pw.close();//关闭流
备注：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。