java io 多種檔案操作方式（位元組、字元、行、隨機）

lvzhou_MadSky發表於2013-07-09
Java字元隨機

一、多種方式讀檔案內容。【參考：http://www.ibm.com/developerworks/cn/java/j-lo-javaio/】

1、按位元組讀取檔案內容
2、按字元讀取檔案內容
3、按行讀取檔案內容
4、隨機讀取檔案內容

001 import java.io.BufferedReader;
002 import java.io.File;
003 import java.io.FileInputStream;
004 import java.io.FileReader;
005 import java.io.IOException;
006 import java.io.InputStream;
007 import java.io.InputStreamReader;
008 import java.io.RandomAccessFile;
009 import java.io.Reader;
010 public class ReadFromFile {
011 /**
012    * 以位元組為單位讀取檔案，常用於讀二進位制檔案，如圖片、聲音、影像等檔案。
013    * @param fileName 檔案的名
014    */
015 public static void readFileByBytes(String fileName){
016    File file = new File(fileName);
017    InputStream in = null;
018    try {
019     System.out.println("以位元組為單位讀取檔案內容，一次讀一個位元組：");
020     // 一次讀一個位元組
021     in = new FileInputStream(file);
022     int tempbyte;
023     while((tempbyte=in.read()) != -1){
024      System.out.write(tempbyte);
025     }
026     in.close();
027    } catch (IOException e) {
028     e.printStackTrace();
029     return;
030    }
031    try {
032     System.out.println("以位元組為單位讀取檔案內容，一次讀多個位元組：");
033     //一次讀多個位元組
034     byte[] tempbytes = new byte[100];
035     int byteread = 0;
036     in = new FileInputStream(fileName);
037     ReadFromFile.showAvailableBytes(in);
038     //讀入多個位元組到位元組陣列中，byteread為一次讀入的位元組數
039     while ((byteread = in.read(tempbytes)) != -1){
040      System.out.write(tempbytes, 0, byteread);
041     }
042    } catch (Exception e1) {
043     e1.printStackTrace();
044    } finally {
045     if (in != null){
046      try {
047       in.close();
048      } catch (IOException e1) {
049      }
050     }
051    }
052 }
053 /**
054    * 以字元為單位讀取檔案，常用於讀文字，數字等型別的檔案
055    * @param fileName 檔名
056    */
057 public static void readFileByChars(String fileName){
058    File file = new File(fileName);
059    Reader reader = null;
060    try {
061     System.out.println("以字元為單位讀取檔案內容，一次讀一個位元組：");
062     // 一次讀一個字元
063     reader = new InputStreamReader(new FileInputStream(file));
064     int tempchar;
065     while ((tempchar = reader.read()) != -1){
066      //對於windows下，/r/n這兩個字元在一起時，表示一個換行。
067      //但如果這兩個字元分開顯示時，會換兩次行。
068      //因此，遮蔽掉/r，或者遮蔽/n。否則，將會多出很多空行。
069      if (((char)tempchar) != '/r'){
070       System.out.print((char)tempchar);
071      }
072     }
073     reader.close();
074    } catch (Exception e) {
075     e.printStackTrace();
076    }
077    try {
078     System.out.println("以字元為單位讀取檔案內容，一次讀多個位元組：");
079     //一次讀多個字元
080     char[] tempchars = new char[30];
081     int charread = 0;
082     reader = new InputStreamReader(new FileInputStream(fileName));
083     //讀入多個字元到字元陣列中，charread為一次讀取字元數
084     while ((charread = reader.read(tempchars))!=-1){
085      //同樣遮蔽掉/r不顯示
086      if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != '/r')){
087       System.out.print(tempchars);
088      }else{
089       for (int i=0; i<charread; i++){
090        if(tempchars[i] == '/r'){
091         continue;
092        }else{
093         System.out.print(tempchars[i]);
094        }
095       }
096      }
097     }
098     
099    } catch (Exception e1) {
100     e1.printStackTrace();
101    }finally {
102     if (reader != null){
103      try {
104       reader.close();
105      } catch (IOException e1) {
106      }
107     }
108    }
109 }
110 /**
111    * 以行為單位讀取檔案，常用於讀面向行的格式化檔案
112    * @param fileName 檔名
113    */
114 public static void readFileByLines(String fileName){
115    File file = new File(fileName);
116    BufferedReader reader = null;
117    try {
118     System.out.println("以行為單位讀取檔案內容，一次讀一整行：");
119     reader = new BufferedReader(new FileReader(file));
120     String tempString = null;
121     int line = 1;
122     //一次讀入一行，直到讀入null為檔案結束
123     while ((tempString = reader.readLine()) != null){
124      //顯示行號
125      System.out.println("line " + line + ": " + tempString);
126      line++;
127     }
128     reader.close();
129    } catch (IOException e) {
130     e.printStackTrace();
131    } finally {
132     if (reader != null){
133      try {
134       reader.close();
135      } catch (IOException e1) {
136      }
137     }
138    }
139 }
140 /**
141    * 隨機讀取檔案內容
142    * @param fileName 檔名
143    */
144 public static void readFileByRandomAccess(String fileName){
145    RandomAccessFile randomFile = null;
146    try {
147     System.out.println("隨機讀取一段檔案內容：");
148     // 開啟一個隨機訪問檔案流，按只讀方式
149     randomFile = new RandomAccessFile(fileName, "r");
150     // 檔案長度，位元組數
151     long fileLength = randomFile.length();
152     // 讀檔案的起始位置
153     int beginIndex = (fileLength > 4) ? 4 : 0;
154     //將讀檔案的開始位置移到beginIndex位置。
155     randomFile.seek(beginIndex);
156     byte[] bytes = new byte[10];
157     int byteread = 0;
158     //一次讀10個位元組，如果檔案內容不足10個位元組，則讀剩下的位元組。
159     //將一次讀取的位元組數賦給byteread
160     while ((byteread = randomFile.read(bytes)) != -1){
161      System.out.write(bytes, 0, byteread);
162     }
163    } catch (IOException e){
164     e.printStackTrace();
165    } finally {
166     if (randomFile != null){
167      try {
168       randomFile.close();
169      } catch (IOException e1) {
170      }
171     }
172    }
173 }
174 /**
175    * 顯示輸入流中還剩的位元組數
176    * @param in
177    */
178 private static void showAvailableBytes(InputStream in){
179    try {
180     System.out.println("當前位元組輸入流中的位元組數為:" + in.available());
181    } catch (IOException e) {
182     e.printStackTrace();
183    }
184 }
185  
186 public static void main(String[] args) {
187    String fileName = "C:/temp/newTemp.txt";
188    ReadFromFile.readFileByBytes(fileName);
189    ReadFromFile.readFileByChars(fileName);
190    ReadFromFile.readFileByLines(fileName);
191    ReadFromFile.readFileByRandomAccess(fileName);
192 }
193 }

 

二、將內容追加到檔案尾部

檢視原始碼列印?
001 import java.io.FileWriter;
002 import java.io.IOException;
003 import java.io.RandomAccessFile;
004  
005 /**
006 * 將內容追加到檔案尾部
007 */
008 public class AppendToFile {
009  
010 /**
011    * A方法追加檔案：使用RandomAccessFile
012    * @param fileName 檔名
013    * @param content 追加的內容
014    */
015 public static void appendMethodA(String fileName, String content){
016    try {
017     // 開啟一個隨機訪問檔案流，按讀寫方式
018     RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
019     // 檔案長度，位元組數
020     long fileLength = randomFile.length();
021     //將寫檔案指標移到檔案尾。
022     randomFile.seek(fileLength);
023     randomFile.writeBytes(content);
024     randomFile.close();
025    } catch (IOException e){
026     e.printStackTrace();
027    }
028 }
029 /**
030    * B方法追加檔案：使用FileWriter
031    * @param fileName
032    * @param content
033    */
034 public static void appendMethodB(String fileName, String content){
035    try {
036     //開啟一個寫檔案器，建構函式中的第二個引數true表示以追加形式寫檔案
037     FileWriter writer = new FileWriter(fileName, true);
038     writer.write(content);
039     writer.close();
040    } catch (IOException e) {
041     e.printStackTrace();
042    }
043 }
044  
045 public static void main(String[] args) {
046    String fileName = "C:/temp/newTemp.txt";
047    String content = "new append!";
048    //按方法A追加檔案
049    AppendToFile.appendMethodA(fileName, content);
050    AppendToFile.appendMethodA(fileName, "append end. /n");
051    //顯示檔案內容
052    ReadFromFile.readFileByLines(fileName);
053    //按方法B追加檔案
054    AppendToFile.appendMethodB(fileName, content);
055    AppendToFile.appendMethodB(fileName, "append end. /n");
056    //顯示檔案內容
057    ReadFromFile.readFileByLines(fileName);
058 }
059 }
060  
061 三檔案的各種操作類
062  
063 import java.io.*;
064  
065 /**
066 * FileOperate.java
067 * 檔案的各種操作
068 * @author 楊彩 http://blog.sina.com.cn/m/yangcai
069 * 檔案操作 1.0
070 */
071  
072 public class FileOperate
073 {
074  
075 public FileOperate()
076 {
077 }
078 /**
079 * 新建目錄
080 */
081 public void newFolder(String folderPath)
082 {
083 try
084 {
085 String filePath = folderPath;
086 filePath = filePath.toString();
087 File myFilePath = new File(filePath);
088 if(!myFilePath.exists())
089 {
090 myFilePath.mkdir();
091 }
092 System.out.println("新建目錄操作 成功執行");
093 }
094 catch(Exception e)
095 {
096 System.out.println("新建目錄操作出錯");
097 e.printStackTrace();
098 }
099 }
100 /**
101 * 新建檔案
102 */
103 public void newFile(String filePathAndName, String fileContent)
104 {
105 try
106 {
107 String filePath = filePathAndName;
108 filePath = filePath.toString();
109 File myFilePath = new File(filePath);
110 if (!myFilePath.exists())
111 {
112 myFilePath.createNewFile();
113 }
114 FileWriter resultFile = new FileWriter(myFilePath);
115 PrintWriter myFile = new PrintWriter(resultFile);
116 String strContent = fileContent;
117 myFile.println(strContent);
118 resultFile.close();
119 System.out.println("新建檔案操作 成功執行");
120 }
121 catch (Exception e)
122 {
123 System.out.println("新建目錄操作出錯");
124 e.printStackTrace();
125 }
126 }
127 /**
128 * 刪除檔案
129 */
130 public void delFile(String filePathAndName)
131 {
132 try
133 {
134 String filePath = filePathAndName;
135 filePath = filePath.toString();
136 File myDelFile = new File(filePath);
137 myDelFile.delete();
138 System.out.println("刪除檔案操作 成功執行");
139 }
140 catch (Exception e)
141 {
142 System.out.println("刪除檔案操作出錯");
143 e.printStackTrace();
144 }
145 }
146 /**
147 * 刪除資料夾
148 */
149 public void delFolder(String folderPath)
150 {
151 try
152 {
153 delAllFile(folderPath); //刪除完裡面所有內容
154 String filePath = folderPath;
155 filePath = filePath.toString();
156 File myFilePath = new File(filePath);
157 if(myFilePath.delete()) { //刪除空資料夾
158 System.out.println("刪除資料夾" + folderPath + "操作 成功執行");
159 } else {
160 System.out.println("刪除資料夾" + folderPath + "操作 執行失敗");
161 }
162 }
163 catch (Exception e)
164 {
165 System.out.println("刪除資料夾操作出錯");
166 e.printStackTrace();
167 }
168 }
169 /**
170 * 刪除資料夾裡面的所有檔案
171 * @param path String 資料夾路徑 如 c:/fqf
172 */
173 public void delAllFile(String path)
174 {
175 File file = new File(path);
176 if(!file.exists())
177 {
178 return;
179 }
180 if(!file.isDirectory())
181 {
182 return;
183 }
184 String[] tempList = file.list();
185 File temp = null;
186 for (int i = 0; i < tempList.length; i++)
187 {
188 if(path.endsWith(File.separator))
189 {
190 temp = new File(path + tempList[i]);
191 }
192 else
193 {
194 temp = new File(path + File.separator + tempList[i]);
195 }
196 if (temp.isFile())
197 {
198 temp.delete();
199 }
200 if (temp.isDirectory())
201 {
202 //delAllFile(path+"/"+ tempList[i]);//先刪除資料夾裡面的檔案
203 delFolder(path+ File.separatorChar + tempList[i]);//再刪除空資料夾
204 }
205 }
206 System.out.println("刪除檔案操作 成功執行");
207 }
208 /**
209 * 複製單個檔案
210 * @param oldPath String 原檔案路徑 如：c:/fqf.txt
211 * @param newPath String 複製後路徑 如：f:/fqf.txt
212 */
213 public void copyFile(String oldPath, String newPath)
214 {
215 try
216 {
217 int bytesum = 0;
218 int byteread = 0;
219 File oldfile = new File(oldPath);
220 if (oldfile.exists())
221 {
222 //檔案存在時
223 InputStream inStream = new FileInputStream(oldPath); //讀入原檔案
224 FileOutputStream fs = new FileOutputStream(newPath);
225 byte[] buffer = new byte[1444];
226 while ( (byteread = inStream.read(buffer)) != -1)
227 {
228 bytesum += byteread; //位元組數 檔案大小
229 System.out.println(bytesum);
230 fs.write(buffer, 0, byteread);
231 }
232 inStream.close();
233 }
234 System.out.println("刪除資料夾操作 成功執行");
235 }
236 catch (Exception e)
237 {
238 System.out.println("複製單個檔案操作出錯");
239 e.printStackTrace();
240 }
241 }
242 /**
243 * 複製整個資料夾內容
244 * @param oldPath String 原檔案路徑 如：c:/fqf
245 * @param newPath String 複製後路徑 如：f:/fqf/ff
246 */
247 public void copyFolder(String oldPath, String newPath)
248 {
249 try
250 {
251 (new File(newPath)).mkdirs(); //如果資料夾不存在 則建立新資料夾
252 File a=new File(oldPath);
253 String[] file=a.list();
254 File temp=null;
255 for (int i = 0; i < file.length; i++)
256 {
257 if(oldPath.endsWith(File.separator))
258 {
259 temp=new File(oldPath+file[i]);
260 }
261 else
262 {
263 temp=new File(oldPath+File.separator+file[i]);
264 }
265 if(temp.isFile())
266 {
267 FileInputStream input = new FileInputStream(temp);
268 FileOutputStream output = new FileOutputStream(newPath + "/" +
269 (temp.getName()).toString());
270 byte[] b = new byte[1024 * 5];
271 int len;
272 while ( (len = input.read(b)) != -1)
273 {
274 output.write(b, 0, len);
275 }
276 output.flush();
277 output.close();
278 input.close();
279 }
280 if(temp.isDirectory())
281 {
282 //如果是子資料夾
283 copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
284 }
285 }
286 System.out.println("複製資料夾操作 成功執行");
287 }
288 catch (Exception e)
289 {
290 System.out.println("複製整個資料夾內容操作出錯");
291 e.printStackTrace();
292 }
293 }
294 /**
295 * 移動檔案到指定目錄
296 * @param oldPath String 如：c:/fqf.txt
297 * @param newPath String 如：d:/fqf.txt
298 */
299 public void moveFile(String oldPath, String newPath)
300 {
301 copyFile(oldPath, newPath);
302 delFile(oldPath);
303 }
304 /**
305 * 移動檔案到指定目錄
306 * @param oldPath String 如：c:/fqf.txt
307 * @param newPath String 如：d:/fqf.txt
308 */
309 public void moveFolder(String oldPath, String newPath)
310 {
311 copyFolder(oldPath, newPath);
312 delFolder(oldPath);
313 }
314 public static void main(String args[])
315 {
316 String aa,bb;
317 boolean exitnow=false;
318 System.out.println("使用此功能請按[1] 功能一：新建目錄");
319 System.out.println("使用此功能請按[2] 功能二：新建檔案");
320 System.out.println("使用此功能請按[3] 功能三：刪除檔案");
321 System.out.println("使用此功能請按[4] 功能四：刪除資料夾");
322 System.out.println("使用此功能請按[5] 功能五：刪除資料夾裡面的所有檔案");
323 System.out.println("使用此功能請按[6] 功能六：複製檔案");
324 System.out.println("使用此功能請按[7] 功能七：複製資料夾的所有內容");
325 System.out.println("使用此功能請按[8] 功能八：移動檔案到指定目錄");
326 System.out.println("使用此功能請按[9] 功能九：移動資料夾到指定目錄");
327 System.out.println("使用此功能請按[10] 退出程式");
328 while(!exitnow)
329 {
330 FileOperate fo=new FileOperate();
331 try
332 {
333 BufferedReader Bin=new BufferedReader(new InputStreamReader(System.in));
334 String a=Bin.readLine();
335 int b=Integer.parseInt(a);
336 switch(b)
337 {
338 case 1:System.out.println("你選擇了功能一 請輸入目錄名");
339 aa=Bin.readLine();
340 fo.newFolder(aa);
341 break;
342 case 2:System.out.println("你選擇了功能二 請輸入檔名");
343 aa=Bin.readLine();
344 System.out.println("請輸入在"+aa+"中的內容");
345 bb=Bin.readLine();
346 fo.newFile(aa,bb);
347 break;
348 case 3:System.out.println("你選擇了功能三 請輸入檔名");
349 aa=Bin.readLine();
350 fo.delFile(aa);
351 break;
352 case 4:System.out.println("你選擇了功能四 請輸入檔名");
353 aa=Bin.readLine();
354 fo.delFolder(aa);
355 break;
356 case 5:System.out.println("你選擇了功能五 請輸入檔名");
357 aa=Bin.readLine();
358 fo.delAllFile(aa);
359 break;
360 case 6:System.out.println("你選擇了功能六 請輸入檔名");
361 aa=Bin.readLine();
362 System.out.println("請輸入目標檔名");
363 bb=Bin.readLine();
364 fo.copyFile(aa,bb);
365 break;
366 case 7:System.out.println("你選擇了功能七 請輸入原始檔名");
367 aa=Bin.readLine();
368 System.out.println("請輸入目標檔名");
369 bb=Bin.readLine();
370 fo.copyFolder(aa,bb);
371 break;
372 case 8:System.out.println("你選擇了功能八 請輸入原始檔名");
373 aa=Bin.readLine();
374 System.out.println("請輸入目標檔名");
375 bb=Bin.readLine();
376 fo.moveFile(aa,bb);
377 break;
378 case 9:System.out.println("你選擇了功能九 請輸入原始檔名");
379 aa=Bin.readLine();
380 System.out.println("請輸入目標檔名");
381 bb=Bin.readLine();
382 fo.moveFolder(aa,bb);
383 break;
384 case 10:exitnow=true;
385 System.out.println("程式結束，請退出");
386 break;
387 default:System.out.println("輸入錯誤.請輸入1-10之間的數");
388 }
389 System.out.println("請重新選擇功能");
390 }
391 catch(Exception e)
392 {
393 System.out.println("輸入錯誤字元或程式出錯");
394 }
395 }
396 }
397 }

相關文章