在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方法關閉，否則會一直處於打開狀態，直至程序停止，增加系統負擔。