java文件的讀寫
⑴ 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 中簡述使用流進行讀寫文本文件的步驟
一、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文件讀寫，在一個已經有內容的文件中，追加第一行，如何做到
我的想法是可以用RandomAccessFile，這個類的seek方法，想在文件的哪個位置插入敏廳內容都行。所以你的第一行就不在話下了。但是，這個會覆蓋你文件中插入位置後面的內容。相當於我們在輸入的時候，按了鍵盤的insert鍵盤。所以，像你這種情況只能用臨時文件來存儲原有的內容，然後把要插入的數據寫入文件，再把臨時文件的內容追加到文件中。x0dx0avoid insert(String filename,int pos,String insertContent){//pos是插入的位置x0dx0a File tmp = File.createTempFile("tmp",null);x0dx0a tmp.deleteOnExit();x0dx0a try{x0dx0a RandomAccessFile raf = new RandomAccessFile(filename,"rw");x0dx0a FileOutputStream tmpOut = new FileOutputStream(tmp);x0dx0a FileInputStream tmpIn = new FileInputStream(tmp);x0dx0a raf.seek(pos);//首先的棚拿喊話是0x0dx0a byte[] buf = new byte[64];x0dx0a int hasRead = 0;x0dx0a while((hasRead = raf.read(buf))>0){x0dx0a //把原有內容讀入臨時文件鏈野x0dx0a tmpOut.write(buf,0,hasRead);x0dx0a x0dx0a }x0dx0a raf.seek(pos);x0dx0a raf.write(insertContent.getBytes());x0dx0a //追加臨時文件的內容x0dx0a while((hasRead = tmpIn.read(buf))>0){x0dx0a raf.write(buf,0,hasRead);x0dx0a }x0dx0a }x0dx0a}
⑷ java中位元組級數據文件的讀寫編程
import java.util.Scanner;
import java.io.*;
class MyFile
{
MyFile(String d)
{
this.d=d;
}
void write(String path,String datafile)
{
File f=new File(this.d);
StringBuilder sb=new StringBuilder();
String savepath;
String[] strs;
BufferedOutputStream bos;
byte[] buf;
this.path=path.endsWith("\\") ? path.substring(0,path.length()-1) : path;
savepath=this.path+"\\"+datafile;
try
{
strs=f.list();
for(String str : strs)
{
sb.append(str);
sb.append("\r\n");
}
bos=new BufferedOutputStream(new FileOutputStream(savepath),MyFile.Size);
buf=sb.toString().getBytes();
bos.write(buf,0,buf.length);
//bos.flush();
bos.close();
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
void show(String datafile)
{
String fp=datafile.contains("\\") ? datafile : this.path+"\\"+datafile;
File f=new File(fp);
BufferedInputStream bis;
byte[] buf;
try
{
buf=new byte[(int)f.length()];
bis=new BufferedInputStream(new FileInputStream(f),MyFile.Size);
bis.read(buf,0,buf.length);
System.out.println(new String(buf));
bis.close();
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
private static final int Size=8*1024;
private String d,path;
}
public class P
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
MyFile f;
String d,path,datafile;
System.out.print("請輸入windows系統中某個目錄的路徑：");
d=sc.nextLine();
f=new MyFile(d);
System.out.print("請輸入保存數據的文件的路徑：");
path=sc.nextLine();
System.out.print("請輸入保存數據的文件的文件名：");
datafile=sc.nextLine();
f.write(path,datafile);
f.show(datafile);
sc.close();
}
}
⑸ Java文件讀寫
實用的模糊（通配符）文件查找程序
1 import java.io.File;
2 import java.util.regex.Matcher;
3 import java.util.regex.Pattern;
4 import java.util.ArrayList;
5
6 /** *//**
7 * <p>Title: FileService </p>
8* <p>Description: 獲取文件 </p>
9* <p>Copyright: Copyright (c) 2007</p>
10* <p>Company: </p>
11* @author not attributable
12* @version 1.0
13*/
14public class FileService {
15 public FileService() {
16 }
17
18 /** *//**
19 * 在本文件夾下查找
20 * @param s String 文件名
21 * @return File[] 找到的文件
22 */
23 public static File[] getFiles(String s)
24 {
25 return getFiles("./",s);
26 }
27
28 /** *//**
29 * 獲取文件
30 * 可以根據正則表達式查找
31 * @param dir String 文件夾名稱
32 * @param s String 查找文件名，可帶*.?進行模糊查詢
33 * @return File[] 找到的文件
34 */
35 public static File[] getFiles(String dir,String s) {
36 //開始的文件夾
37 File file = new File(dir);
38
39 s = s.replace('.', '#');
40 s = s.replaceAll("#", "\\\\.");
41 s = s.replace('*', '#');
42 s = s.replaceAll("#", ".*");
43 s = s.replace('?', '#');
44 s = s.replaceAll("#", ".?");
45 s = "^" + s + "$";
46
47 System.out.println(s);
48 Pattern p = Pattern.compile(s);
49 ArrayList list = filePattern(file, p);
50
51 File[] rtn = new File[list.size()];
52 list.toArray(rtn);
53 return rtn;
54 }
55
56 /** *//**
57 * @param file File 起始文件夾
58 * @param p Pattern 匹配類型
59 * @return ArrayList 其文件夾下的文件夾
60 */
61
62 private static ArrayList filePattern(File file, Pattern p) {
63 if (file == null) {
64 return null;
65 }
66 else if (file.isFile()) {
67 Matcher fMatcher = p.matcher(file.getName());
68 if (fMatcher.matches()) {
69 ArrayList list = new ArrayList();
70 list.add(file);
71 return list;
72 }
73 }
74 else if (file.isDirectory()) {
75 File[] files = file.listFiles();
76 if (files != null && files.length > 0) {
77 ArrayList list = new ArrayList();
78 for (int i = 0; i < files.length; i++) {
79 ArrayList rlist = filePattern(files[i], p);
80 if (rlist != null) {
81 list.addAll(rlist);
82 }
83 }
84 return list;
85 }
86 }
87 return null;
88 }
89
90 /** *//**
91 * 測試
92 * @param args String[]
93 */
94 public static void main(String[] args) {
95 }
96}
⑹ 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文件如何讀取
java讀取文件方法大全
一、多種方式讀文件內容。
1、按位元組讀取文件內容
2、按字元讀取文件內容
3、按行讀取文件內容
4、隨機讀取文件內容
Java代碼
1. import java.io.BufferedReader;
2. import java.io.File;
3. import java.io.FileInputStream;
4. import java.io.FileReader;
5. import java.io.IOException;
6. import java.io.InputStream;
7. import java.io.InputStreamReader;
8. import java.io.RandomAccessFile;
9. import java.io.Reader;
10.
11. public class ReadFromFile {
12. /**
13. * 以位元組為單位讀取文件，常用於讀二進制文件，如圖片、聲音、影像等文件。
14. *
15. * @param fileName
16. * 文件的名
17. */
18. public static void readFileByBytes(String fileName) {
19. File file = new File(fileName);
20. InputStream in = null;
21. try {
22. System.out.println("以位元組為單位讀取文件內容，一次讀一個位元組：");
23. // 一次讀一個位元組
24. in = new FileInputStream(file);
25. int tempbyte;
26. while ((tempbyte = in.read()) != -1) {
27. System.out.write(tempbyte);
28. }
29. in.close();
30. } catch (IOException e) {
31. e.printStackTrace();
32. return;
33. }
34. try {
35. System.out.println("以位元組為單位讀取文件內容，一次讀多個位元組：");
36. // 一次讀多個位元組
37. byte[] tempbytes = new byte[100];
38. int byteread = 0;
39. in = new FileInputStream(fileName);
40. ReadFromFile.showAvailableBytes(in);
41. // 讀入多個位元組到位元組數組中，byteread為一次讀入的位元組數
42. while ((byteread = in.read(tempbytes)) != -1) {
43. System.out.write(tempbytes, 0, byteread);
44. }
45. } catch (Exception e1) {
46. e1.printStackTrace();
47. } finally {
48. if (in != null) {
49. try {
50. in.close();
51. } catch (IOException e1) {
52. }
53. }
54. }
55. }
56.
57. /**
58. * 以字元為單位讀取文件，常用於讀文本，數字等類型的文件
59. *
60. * @param fileName
61. * 文件名
62. */
63. public static void readFileByChars(String fileName) {
64. File file = new File(fileName);
65. Reader reader = null;
66. try {
67. System.out.println("以字元為單位讀取文件內容，一次讀一個位元組：");
68. // 一次讀一個字元
69. reader = new InputStreamReader(new FileInputStream(file));
70. int tempchar;
71. while ((tempchar = reader.read()) != -1) {
72. // 對於windows下，\r\n這兩個字元在一起時，表示一個換行。
73. // 但如果這兩個字元分開顯示時，會換兩次行。
74. // 因此，屏蔽掉\r，或者屏蔽\n。否則，將會多出很多空行。
75. if (((char) tempchar) != '\r') {
76. System.out.print((char) tempchar);
77. }
78. }
79. reader.close();
80. } catch (Exception e) {
81. e.printStackTrace();
82. }
83. try {
84. System.out.println("以字元為單位讀取文件內容，一次讀多個位元組：");
85. // 一次讀多個字元
86. char[] tempchars = new char[30];
87. int charread = 0;
88. reader = new InputStreamReader(new FileInputStream(fileName));
89. // 讀入多個字元到字元數組中，charread為一次讀取字元數
90. while ((charread = reader.read(tempchars)) != -1) {
91. // 同樣屏蔽掉\r不顯示
92. if ((charread == tempchars.length)
93. && (tempchars[tempchars.length - 1] != '\r')) {
94. System.out.print(tempchars);
95. } else {
96. for (int i = 0; i < charread; i++) {
97. if (tempchars[i] == '\r') {
98. continue;
99. } else {
100. System.out.print(tempchars[i]);
101. }
102. }
103. }
104. }
105.
106. } catch (Exception e1) {
107. e1.printStackTrace();
108. } finally {
109. if (reader != null) {
110. try {
111. reader.close();
112. } catch (IOException e1) {
113. }
114. }
115. }
116. }
117.
118. /**
119. * 以行為單位讀取文件，常用於讀面向行的格式化文件
120. *
121. * @param fileName
122. * 文件名
123. */
124. public static void readFileByLines(String fileName) {
125. File file = new File(fileName);
126. BufferedReader reader = null;
127. try {
128. System.out.println("以行為單位讀取文件內容，一次讀一整行：");
129. reader = new BufferedReader(new FileReader(file));
130. String tempString = null;
131. int line = 1;
132. // 一次讀入一行，直到讀入null為文件結束
133. while ((tempString = reader.readLine()) != null) {
134. // 顯示行號
135. System.out.println("line " + line + ": " + tempString);
136. line++;
137. }
138. reader.close();
139. } catch (IOException e) {
140. e.printStackTrace();
141. } finally {
142. if (reader != null) {
143. try {
144. reader.close();
145. } catch (IOException e1) {
146. }
147. }
148. }
149. }
150.
151. /**
152. * 隨機讀取文件內容
153. *
154. * @param fileName
155. * 文件名
156. */
157. public static void readFileByRandomAccess(String fileName) {
158. RandomAccessFile randomFile = null;
159. try {
160. System.out.println("隨機讀取一段文件內容：");
161. // 打開一個隨機訪問文件流，按只讀方式
162. randomFile = new RandomAccessFile(fileName, "r");
163. // 文件長度，位元組數
164. long fileLength = randomFile.length();
165. // 讀文件的起始位置
166. int beginIndex = (fileLength > 4) ? 4 : 0;
167. // 將讀文件的開始位置移到beginIndex位置。
168. randomFile.seek(beginIndex);
169. byte[] bytes = new byte[10];
170. int byteread = 0;
171. // 一次讀10個位元組，如果文件內容不足10個位元組，則讀剩下的位元組。
172. // 將一次讀取的位元組數賦給byteread
173. while ((byteread = randomFile.read(bytes)) != -1) {
174. System.out.write(bytes, 0, byteread);
175. }
176. } catch (IOException e) {
177. e.printStackTrace();
178. } finally {
179. if (randomFile != null) {
180. try {
181. randomFile.close();
182. } catch (IOException e1) {
183. }
184. }
185. }
186. }
187.
188. /**
189. * 顯示輸入流中還剩的位元組數
190. *
191. * @param in
192. */
193. private static void showAvailableBytes(InputStream in) {
194. try {
195. System.out.println("當前位元組輸入流中的位元組數為:" + in.available());
196. } catch (IOException e) {
197. e.printStackTrace();
198. }
199. }
200.
201. public static void main(String[] args) {
202. String fileName = "C:/temp/newTemp.txt";
203. ReadFromFile.readFileByBytes(fileName);
204. ReadFromFile.readFileByChars(fileName);
205. ReadFromFile.readFileByLines(fileName);
206. ReadFromFile.readFileByRandomAccess(fileName);
207. }
208. }
二、將內容追加到文件尾部
1. import java.io.FileWriter;
2. import java.io.IOException;
3. import java.io.RandomAccessFile;
4.
5. /**
6. * 將內容追加到文件尾部
7. */
8. public class AppendToFile {
9.
10. /**
11. * A方法追加文件：使用RandomAccessFile
12. * @param fileName 文件名
13. * @param content 追加的內容
14. */
15. public static void appendMethodA(String fileName, String content) {
16. try {
17. // 打開一個隨機訪問文件流，按讀寫方式
18. RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
19. // 文件長度，位元組數
20. long fileLength = randomFile.length();
21. //將寫文件指針移到文件尾。
22. randomFile.seek(fileLength);
23. randomFile.writeBytes(content);
24. randomFile.close();
25. } catch (IOException e) {
26. e.printStackTrace();
27. }
28. }
29.
30. /**
31. * B方法追加文件：使用FileWriter
32. * @param fileName
33. * @param content
34. */
35. public static void appendMethodB(String fileName, String content) {
36. try {
37. //打開一個寫文件器，構造函數中的第二個參數true表示以追加形式寫文件
38. FileWriter writer = new FileWriter(fileName, true);
39. writer.write(content);
40. writer.close();
41. } catch (IOException e) {
42. e.printStackTrace();
43. }
44. }
45.
46. public static void main(String[] args) {
47. String fileName = "C:/temp/newTemp.txt";
48. String content = "new append!";
49. //按方法A追加文件
50. AppendToFile.appendMethodA(fileName, content);
51. AppendToFile.appendMethodA(fileName, "append end. \n");
52. //顯示文件內容
53. ReadFromFile.readFileByLines(fileName);
54. //按方法B追加文件
55. AppendToFile.appendMethodB(fileName, content);
56. AppendToFile.appendMethodB(fileName, "append end. \n");
57. //顯示文件內容
58. ReadFromFile.readFileByLines(fileName);
59. }
60. }
⑻ 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方法關閉，否則會一直處於打開狀態，直至程序停止，增加系統負擔。
⑼ java里往文件里讀，和讀入，意思一樣么讀，讀入，寫，寫入的區別是什麼
讀是一個位元組個讀取,讀入則可以設置一塌御個緩沖一下讀團絕岩到多個宏擾比如一下讀取1024個位元組,,這樣可以在大文件操作加快速度
寫,寫入之讀,讀入相同
⑽ Java讀取文件的幾種方式
方式一：採用ServletContext讀取，讀取配置文件的realpath，然後通過文件流讀取出來。因為是用ServletContext讀取文件路徑，所以配置文件可以放入在web-info的classes目錄中，也可以在應用層級及web-info的目錄中。文件存放位置具體在eclipse工程中的表現是：可以放在src下面，也可放在web-info及webroot下面等。因為是讀取出路徑後，用文件流進行讀取的，所以可以讀取任意的配置文件包括xml和properties。缺點：不能在servlet外面應用讀取配置信息。
方式二：採用ResourceBundle類讀取配置信息，
優點是：可以以完全限定類名的方式載入資源後，直接的讀取出來，且可以在非Web應用中讀取資源文件。缺點：只能載入類classes下面的資源文件且只能讀取.properties文件。
方式三：採用ClassLoader方式進行讀取配置信息
優點是：可以在非Web應用中讀取配置資源信息，可以讀取任意的資源文件信息
缺點：只能載入類classes下面的資源文件。
方法4 getResouceAsStream
XmlParserHandler.class.getResourceAsStream 與classloader不同