`

java io 多种文件操作方式（字节、字符、行、随机）

 
阅读更多

一、多种方式读文件内容。【参考：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 }
分享到：
| Java Web开发Tomcat中三种部署项目的方法
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java io读取文件

    Java IO API提供了一系列类和接口，使得开发者能够高效地读取、写入和操作文件。下面我们将深入探讨Java IO读取文件的技术及其在大数据场景下的应用。 1. **基础概念** - **流（Stream）**：Java IO基于流的概念，...

    JAVA IO文件操作

    Java IO文件操作是Java编程中不可或缺的一部分，它允许开发者与外部设备进行数据交换，包括文件、网络、内存等。在Java中，IO流是实现这一功能的核心机制。 首先，流是一个按照顺序组织的数据集合，从起点（源）...

    java_IO操作

    Java IO 操作是Java编程中不可或缺的一部分，它涵盖了文件的读写、追加、删除、移动和复制等多种功能。在Java中，IO流（Input/Output Stream）是处理输入输出的主要方式，它允许数据从一个源（如硬盘或网络）传输到...

    Java IO 编程集合

    总的来说，Java IO编程集合涵盖了从基础的文件操作到复杂的流处理，通过实例学习，可以更好地理解和掌握Java在处理文件输入输出方面的强大功能。在实践中，我们需要根据具体需求选择合适的IO类，合理地组织代码，...

    Java IO 使用例

    在“JavaIODemo”这个示例中，可能会包含以上提到的一些或全部Java IO操作的代码实例，通过这些实例，我们可以学习如何在实际项目中应用Java IO API。实践是掌握Java IO的最佳方式，通过对这些示例的分析和运行，...

    java io 系列操作代码练习 Java学习资料

    Java IO（Input/Output）是Java编程语言中用于处理输入输出操作的重要部分，它提供了丰富的类库来实现数据的读写、文件操作、网络通信等功能。在这个“java io 系列操作代码练习”中，我们可以深入理解并掌握Java IO...

    Java IO处理类的汇总

    Java IO提供了多种流类型，包括字节流和字符流。字节流处理单个字节的数据，如InputStream和OutputStream家族；字符流处理Unicode字符，如Reader和Writer家族。此外，还有对象流如ObjectInputStream和...

    Java IO 工具类大全

    Java IO体系主要由流（Stream）组成，分为字节流和字符流两大类，分别处理字节数据和字符数据。字节流包括InputStream和OutputStream家族，字符流则包括Reader和Writer家族。这些基类都有许多子类，如...

    java-IO操作-(读写、追加、删除、移动、复制、修改).doc

    1. 文件操作权限：需要确保程序有足够的权限来操作文件。 2. 文件路径：需要正确指定文件路径。 3. 文件编码：需要正确指定文件编码，以避免乱码问题。 4. 输入/输出流关闭：需要正确关闭输入/输出流，以避免资源...

    Java,彻底明白Java语言中的IO系统

    Java提供了一套完整的IO系统来处理各种数据流的读写操作，包括字符流、字节流以及随机访问文件等。本文将深入探讨Java IO系统的各个组成部分及其应用场景。 #### 1. Java IO系统概述 Java IO系统主要由`java.io`包...

    java 读取文件 文件读取操作

    本文将详细介绍Java中四种不同的文件读取方法：按字节读取、按字符读取、按行读取以及随机读取。 1. **按字节读取文件内容** Java中`java.io.FileInputStream`类提供了按字节读取文件的功能。这种方法适用于读取二...

    JavaIO大部分类

    Java IO（Input/Output）是Java编程语言中用于处理输入和输出...通过理解并熟练运用这些Java IO类和概念，开发者能够构建出高效的数据读写系统，无论是简单的文件操作还是复杂的网络通信，Java IO都能提供强大的支持。

    javaio实际代码

    在Java中，I/O操作由java.io包提供支持，包含了多种流类，用于读取、写入、处理数据。下面将深入探讨Java I/O的相关知识点，并结合“IOUtil”这个文件名，推测这是一个包含实用I/O工具方法的类。 1. **流的概念**：...

    java io 操作总结

    在这篇总结中，我们将探讨Java IO操作的各个方面，包括File类、RandomAccessFile类、字节流与字符流的基本操作，以及具体实现文件读写的技术细节。 首先，File类在Java IO操作中扮演着重要角色。它提供了关于文件和...

    java io最简java io

    Java IO（Input/Output）是Java编程语言中用于处理输入和输出操作的重要组成部分。它提供了丰富的类库，允许程序员在各种设备、文件、网络连接之间进行数据传输。在这个主题中，我们将深入探讨Java IO的基本概念、...

    深入分析JavaIO的工作机制.doc

    Java IO系统是进行文件读写、网络通信等基本操作的核心组件。在Java中，IO操作主要通过`java.io`包中的类实现。根据不同的数据处理需求，这些类可以大致分为四组： 1. **基于字节操作的IO接口**：`InputStream`和`...

    java IO 类层次图

    Java IO系统提供了丰富的类来支持不同类型的输入输出操作，包括但不限于文件读写、网络通信等。本文将通过分析一张清晰明了的Java IO类层次图，详细介绍Java IO体系中的主要类及其关系。 #### 二、Java IO 类层次...

    Java IO合集

    Java IO包括了文件I/O、套接字通信、对象序列化等多种功能。例如，FileInputStream和FileOutputStream用于读写文件，BufferedReader和PrintWriter用于文本数据的读写，而ObjectInputStream和ObjectOutputStream则...

    java IO流读写

    在Java中，IO流分为两大类：字节流（Byte Stream）和字符流（Character Stream）。字节流处理单个字节的数据，而字符流则处理Unicode编码的16位字符。 1. **字节流**： - `InputStream` 和 `OutputStream` 是所有...

Magicbox
Global site tag (gtag.js) - Google Analytics