java多种方式读文件,追加文件内容,对文件的各种操作

一、多种方式读文件内容：

1、按字节读取文件内容

[java] view plain copy print ?

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. /** 
12.  * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。 
13.  * @param fileName 文件的名 
14.  */  
15. public static void readFileByBytes(String fileName){  
16.    File file = new File(fileName);  
17.    InputStream in = null;  
18.    try {  
19.     System.out.println("以字节为单位读取文件内容，一次读一个字节：");  
20.     // 一次读一个字节  
21.     in = new FileInputStream(file);  
22.     int tempbyte;  
23.     while((tempbyte=in.read()) != -1){  
24.      System.out.write(tempbyte);  
25.     }  
26.     in.close();  
27.    } catch (IOException e) {  
28.     e.printStackTrace();  
29.     return;  
30.    }  
31.    try {  
32.     System.out.println("以字节为单位读取文件内容，一次读多个字节：");  
33.     //一次读多个字节  
34.     byte[] tempbytes = new byte[100];  
35.     int byteread = 0;  
36.     in = new FileInputStream(fileName);  
37.     ReadFromFile.showAvailableBytes(in);  
38.     //读入多个字节到字节数组中，byteread为一次读入的字节数  
39.     while ((byteread = in.read(tempbytes)) != -1){  
40.      System.out.write(tempbytes, 0, byteread);  
41.     }  
42.    } catch (Exception e1) {  
43.     e1.printStackTrace();  
44.    } finally {  
45.     if (in != null){  
46.      try {  
47.       in.close();  
48.      } catch (IOException e1) {  
49.      }  
50.     }  
51.    }  
52. }  

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader; 

/**
 * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
 * @param fileName 文件的名
 */
public static void readFileByBytes(String fileName){
   File file = new File(fileName);
   InputStream in = null;
   try {
    System.out.println("以字节为单位读取文件内容，一次读一个字节：");
    // 一次读一个字节
    in = new FileInputStream(file);
    int tempbyte;
    while((tempbyte=in.read()) != -1){
     System.out.write(tempbyte);
    }
    in.close();
   } catch (IOException e) {
    e.printStackTrace();
    return;
   }
   try {
    System.out.println("以字节为单位读取文件内容，一次读多个字节：");
    //一次读多个字节
    byte[] tempbytes = new byte[100];
    int byteread = 0;
    in = new FileInputStream(fileName);
    ReadFromFile.showAvailableBytes(in);
    //读入多个字节到字节数组中，byteread为一次读入的字节数
    while ((byteread = in.read(tempbytes)) != -1){
     System.out.write(tempbytes, 0, byteread);
    }
   } catch (Exception e1) {
    e1.printStackTrace();
   } finally {
    if (in != null){
     try {
      in.close();
     } catch (IOException e1) {
     }
    }
   }
}

2、按字符读取文件内容

[java] view plain copy print ?

1. /** 
2.  * 以字符为单位读取文件，常用于读文本，数字等类型的文件 
3.  * @param fileName 文件名 
4.  */  
5. public static void readFileByChars(String fileName){  
6.    File file = new File(fileName);  
7.    Reader reader = null;  
8.    try {  
9.     System.out.println("以字符为单位读取文件内容，一次读一个字节：");  
10.     // 一次读一个字符  
11.     reader = new InputStreamReader(new FileInputStream(file));  
12.     int tempchar;  
13.     while ((tempchar = reader.read()) != -1){  
14.      //对于windows下，\r\n这两个字符在一起时，表示一个换行。  
15.      //但如果这两个字符分开显示时，会换两次行。  
16.      //因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。  
17.      if (((char)tempchar) != ''\r''){  
18.       System.out.print((char)tempchar);  
19.      }  
20.     }  
21.     reader.close();  
22.    } catch (Exception e) {  
23.     e.printStackTrace();  
24.    }  
25.    try {  
26.     System.out.println("以字符为单位读取文件内容，一次读多个字节：");  
27.     //一次读多个字符  
28.     char[] tempchars = new char[30];  
29.     int charread = 0;  
30.     reader = new InputStreamReader(new FileInputStream(fileName));  
31.     //读入多个字符到字符数组中，charread为一次读取字符数  
32.     while ((charread = reader.read(tempchars))!=-1){  
33.      //同样屏蔽掉\r不显示  
34.      if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != ''\r'')){  
35.       System.out.print(tempchars);  
36.      }else{  
37.       for (int i=0; i<charread; i++){  
38.        if(tempchars[i] == ''\r''){  
39.         continue;  
40.        }else{  
41.         System.out.print(tempchars[i]);  
42.        }  
43.       }  
44.      }  
45.     }  
46.      
47.    } catch (Exception e1) {  
48.     e1.printStackTrace();  
49.    }finally {  
50.     if (reader != null){  
51.      try {  
52.       reader.close();  
53.      } catch (IOException e1) {  
54.      }  
55.     }  
56.    }  
57. }  

/**
 * 以字符为单位读取文件，常用于读文本，数字等类型的文件
 * @param fileName 文件名
 */
public static void readFileByChars(String fileName){
   File file = new File(fileName);
   Reader reader = null;
   try {
    System.out.println("以字符为单位读取文件内容，一次读一个字节：");
    // 一次读一个字符
    reader = new InputStreamReader(new FileInputStream(file));
    int tempchar;
    while ((tempchar = reader.read()) != -1){
     //对于windows下，\r\n这两个字符在一起时，表示一个换行。
     //但如果这两个字符分开显示时，会换两次行。
     //因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
     if (((char)tempchar) != ''\r''){
      System.out.print((char)tempchar);
     }
    }
    reader.close();
   } catch (Exception e) {
    e.printStackTrace();
   }
   try {
    System.out.println("以字符为单位读取文件内容，一次读多个字节：");
    //一次读多个字符
    char[] tempchars = new char[30];
    int charread = 0;
    reader = new InputStreamReader(new FileInputStream(fileName));
    //读入多个字符到字符数组中，charread为一次读取字符数
    while ((charread = reader.read(tempchars))!=-1){
     //同样屏蔽掉\r不显示
     if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != ''\r'')){
      System.out.print(tempchars);
     }else{
      for (int i=0; i<charread; i++){
       if(tempchars[i] == ''\r''){
        continue;
       }else{
        System.out.print(tempchars[i]);
       }
      }
     }
    }
   
   } catch (Exception e1) {
    e1.printStackTrace();
   }finally {
    if (reader != null){
     try {
      reader.close();
     } catch (IOException e1) {
     }
    }
   }
}

3、按行读取文件内容

[java] view plain copy print ?

1. /** 
2.  * 以行为单位读取文件，常用于读面向行的格式化文件 
3.  * @param fileName 文件名 
4.  */  
5. public static void readFileByLines(String fileName){  
6.    File file = new File(fileName);  
7.    BufferedReader reader = null;  
8.    try {  
9.     System.out.println("以行为单位读取文件内容，一次读一整行：");  
10.     reader = new BufferedReader(new FileReader(file));  
11.     String tempString = null;  
12.     int line = 1;  
13.     //一次读入一行，直到读入null为文件结束  
14.     while ((tempString = reader.readLine()) != null){  
15.      //显示行号  
16.      System.out.println("line " + line + ": " + tempString);  
17.      line++;  
18.     }  
19.     reader.close();  
20.    } catch (IOException e) {  
21.     e.printStackTrace();  
22.    } finally {  
23.     if (reader != null){  
24.      try {  
25.       reader.close();  
26.      } catch (IOException e1) {  
27.      }  
28.     }  
29.    }  
30. }  

/**
 * 以行为单位读取文件，常用于读面向行的格式化文件
 * @param fileName 文件名
 */
public static void readFileByLines(String fileName){
   File file = new File(fileName);
   BufferedReader reader = null;
   try {
    System.out.println("以行为单位读取文件内容，一次读一整行：");
    reader = new BufferedReader(new FileReader(file));
    String tempString = null;
    int line = 1;
    //一次读入一行，直到读入null为文件结束
    while ((tempString = reader.readLine()) != null){
     //显示行号
     System.out.println("line " + line + ": " + tempString);
     line++;
    }
    reader.close();
   } catch (IOException e) {
    e.printStackTrace();
   } finally {
    if (reader != null){
     try {
      reader.close();
     } catch (IOException e1) {
     }
    }
   }
}

4、随机读取文件内容

[java] view plain copy print ?

1. /** 
2.  * 随机读取文件内容 
3.  * @param fileName 文件名 
4.  */  
5. public static void readFileByRandomAccess(String fileName){  
6.    RandomAccessFile randomFile = null;  
7.    try {  
8.     System.out.println("随机读取一段文件内容：");  
9.     // 打开一个随机访问文件流，按只读方式  
10.     randomFile = new RandomAccessFile(fileName, "r");  
11.     // 文件长度，字节数  
12.     long fileLength = randomFile.length();  
13.     // 读文件的起始位置  
14.     int beginIndex = (fileLength > 4) ? 4 : 0;  
15.     //将读文件的开始位置移到beginIndex位置。  
16.     randomFile.seek(beginIndex);  
17.     byte[] bytes = new byte[10];  
18.     int byteread = 0;  
19.     //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。  
20.     //将一次读取的字节数赋给byteread  
21.     while ((byteread = randomFile.read(bytes)) != -1){  
22.      System.out.write(bytes, 0, byteread);  
23.     }  
24.    } catch (IOException e){  
25.     e.printStackTrace();  
26.    } finally {  
27.     if (randomFile != null){  
28.      try {  
29.       randomFile.close();  
30.      } catch (IOException e1) {  
31.      }  
32.     }  
33.    }  
34. }  

/**
 * 随机读取文件内容
 * @param fileName 文件名
 */
public static void readFileByRandomAccess(String fileName){
   RandomAccessFile randomFile = null;
   try {
    System.out.println("随机读取一段文件内容：");
    // 打开一个随机访问文件流，按只读方式
    randomFile = new RandomAccessFile(fileName, "r");
    // 文件长度，字节数
    long fileLength = randomFile.length();
    // 读文件的起始位置
    int beginIndex = (fileLength > 4) ? 4 : 0;
    //将读文件的开始位置移到beginIndex位置。
    randomFile.seek(beginIndex);
    byte[] bytes = new byte[10];
    int byteread = 0;
    //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
    //将一次读取的字节数赋给byteread
    while ((byteread = randomFile.read(bytes)) != -1){
     System.out.write(bytes, 0, byteread);
    }
   } catch (IOException e){
    e.printStackTrace();
   } finally {
    if (randomFile != null){
     try {
      randomFile.close();
     } catch (IOException e1) {
     }
    }
   }
}

5.显示输入流中还剩的字节数

[java] view plain copy print ?

1. /** 
2.  * 显示输入流中还剩的字节数 
3.  * @param in 
4.  */  
5. private static void showAvailableBytes(InputStream in){  
6.    try {  
7.     System.out.println("当前字节输入流中的字节数为:" + in.available());  
8.    } catch (IOException e) {  
9.     e.printStackTrace();  
10.    }  
11. }  

/**
 * 显示输入流中还剩的字节数
 * @param in
 */
private static void showAvailableBytes(InputStream in){
   try {
    System.out.println("当前字节输入流中的字节数为:" + in.available());
   } catch (IOException e) {
    e.printStackTrace();
   }
}

二、将内容追加到文件尾部：

[java] view plain copy print ?

1. import java.io.FileWriter;  
2. import java.io.IOException;  
3. import java.io.RandomAccessFile;  
4.   
5. public class AppendToFile {  
6.   
7. /** 
8.  * A方法追加文件：使用RandomAccessFile 
9.  * @param fileName 文件名 
10.  * @param content 追加的内容 
11.  */  
12. public static void appendMethodA(String fileName, String content){  
13.    try {  
14.     // 打开一个随机访问文件流，按读写方式  
15.     RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");  
16.     // 文件长度，字节数  
17.     long fileLength = randomFile.length();  
18.     //将写文件指针移到文件尾。  
19.     randomFile.seek(fileLength);  
20.     randomFile.writeBytes(content);  
21.     randomFile.close();  
22.    } catch (IOException e){  
23.     e.printStackTrace();  
24.    }  
25. }  
26.   
27. /**   
28.  * B方法追加文件：使用FileWriter 
29.  * @param fileName 
30.  * @param content 
31.  */  
32. public static void appendMethodB(String fileName, String content){  
33.    try {  
34.     //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件  
35.     FileWriter writer = new FileWriter(fileName, true);  
36.     writer.write(content);  
37.     writer.close();  
38.    } catch (IOException e) {  
39.     e.printStackTrace();  
40.    }  
41. }  
42.   
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. }  

import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;

public class AppendToFile {

/**
 * A方法追加文件：使用RandomAccessFile
 * @param fileName 文件名
 * @param content 追加的内容
 */
public static void appendMethodA(String fileName, String content){
   try {
    // 打开一个随机访问文件流，按读写方式
    RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
    // 文件长度，字节数
    long fileLength = randomFile.length();
    //将写文件指针移到文件尾。
    randomFile.seek(fileLength);
    randomFile.writeBytes(content);
    randomFile.close();
   } catch (IOException e){
    e.printStackTrace();
   }
}

/**  
 * B方法追加文件：使用FileWriter
 * @param fileName
 * @param content
 */
public static void appendMethodB(String fileName, String content){
   try {
    //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
    FileWriter writer = new FileWriter(fileName, true);
    writer.write(content);
    writer.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
}

/**
 * 测试程序
 */
public static void main(String[] args) {
   String fileName = "C:/temp/newTemp.txt";
   String content = "new append!";
   //按方法A追加文件
   AppendToFile.appendMethodA(fileName, content);
   AppendToFile.appendMethodA(fileName, "append end. \n");
   //显示文件内容
   ReadFromFile.readFileByLines(fileName);
   //按方法B追加文件
   AppendToFile.appendMethodB(fileName, content);
   AppendToFile.appendMethodB(fileName, "append end. \n");
   //显示文件内容
   ReadFromFile.readFileByLines(fileName);
}

三、文件的创建、删除、移动、复制等各种操作类:

[java] view plain copy print ?

1. /** 
2. * 文件的各种操作 
3. */  
4. public class FileOperate{  
5.    /** 
6.     * 新建目录 
7.     */  
8.    public void newFolder(String folderPath) {  
9.        try {  
10.            String filePath = folderPath;  
11.            filePath = filePath.toString();  
12.            File myFilePath = new File(filePath);  
13.            if(!myFilePath.exists()) {  
14.                myFilePath.mkdir();  
15.            }  
16.            System.out.println("新建目录操作 成功执行");  
17.        } catch(Exception e) {  
18.            System.out.println("新建目录操作出错");  
19.            e.printStackTrace();  
20.        }  
21.    }  
22.   
23.    /** 
24.     * 新建文件 
25.     */  
26.    public void newFile(String filePathAndName, String fileContent){  
27.        try {  
28.            String filePath = filePathAndName;  
29.            filePath = filePath.toString();  
30.            File myFilePath = new File(filePath);  
31.            if (!myFilePath.exists()) {  
32.                myFilePath.createNewFile();  
33.            }  
34.            FileWriter resultFile = new FileWriter(myFilePath);  
35.            PrintWriter myFile = new PrintWriter(resultFile);  
36.            String strContent = fileContent;  
37.            myFile.println(strContent);  
38.            resultFile.close();  
39.            System.out.println("新建文件操作 成功执行");  
40.        } catch (Exception e) {  
41.            System.out.println("新建目录操作出错");  
42.            e.printStackTrace();  
43.        }  
44.    }  
45.   
46.    /** 
47.     * 删除文件 
48.     */  
49.    public void delFile(String filePathAndName) {  
50.        try {  
51.            String filePath = filePathAndName;  
52.            filePath = filePath.toString();  
53.            File myDelFile = new File(filePath);  
54.            myDelFile.delete();  
55.            System.out.println("删除文件操作 成功执行");  
56.        } catch (Exception e) {  
57.            System.out.println("删除文件操作出错");  
58.            e.printStackTrace();  
59.        }  
60.    }  
61.   
62.    /** 
63.     * 删除文件夹 
64.     */  
65.    public void delFolder(String folderPath) {  
66.        try {  
67.            delAllFile(folderPath); //删除完里面所有内容  
68.            String filePath = folderPath;  
69.            filePath = filePath.toString();  
70.            File myFilePath = new File(filePath);  
71.            if(myFilePath.delete()) { //删除空文件夹  
72.                System.out.println("删除文件夹" + folderPath + "操作 成功执行");  
73.            } else {  
74.                System.out.println("删除文件夹" + folderPath + "操作 执行失败");  
75.            }  
76.        } catch (Exception e) {  
77.            System.out.println("删除文件夹操作出错");  
78.            e.printStackTrace();  
79.        }  
80.    }  
81.   
82.    /** 
83.     * 删除文件夹里面的所有文件 
84.     */  
85.    public void delAllFile(String path) {  
86.        File file = new File(path);  
87.        if(!file.exists()){  
88.            return;  
89.        }  
90.   
91.        if(!file.isDirectory()) {  
92.            return;  
93.        }  
94.   
95.        String[] tempList = file.list();  
96.        File temp = null;  
97.        for (int i = 0; i < tempList.length; i++){  
98.            if(path.endsWith(File.separator)) {  
99.                temp = new File(path + tempList[i]);  
100.            } else {  
101.                temp = new File(path + File.separator + tempList[i]);  
102.            }  
103.   
104.            if (temp.isFile()) {  
105.                temp.delete();  
106.            }  
107.   
108.            if (temp.isDirectory()) {  
109.                //delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件  
110.                delFolder(path+ File.separatorChar + tempList[i]);//再删除空文件夹  
111.            }  
112.        }  
113.        System.out.println("删除文件操作 成功执行");  
114.    }  
115.   
116.    /** 
117.     * 复制单个文件 
118.     */  
119.    public void copyFile(String oldPath, String newPath) {  
120.        try {  
121.            int bytesum = 0;  
122.            int byteread = 0;  
123.            File oldfile = new File(oldPath);  
124.            if (oldfile.exists()) {  
125.                //文件存在时  
126.                InputStream inStream = new FileInputStream(oldPath); //读入原文件  
127.                FileOutputStream fs = new FileOutputStream(newPath);  
128.                byte[] buffer = new byte[1444];  
129.                while ( (byteread = inStream.read(buffer)) != -1) {  
130.                    bytesum += byteread; //字节数 文件大小  
131.                    System.out.println(bytesum);  
132.                    fs.write(buffer, 0, byteread);  
133.                }  
134.                inStream.close();  
135.            }  
136.            System.out.println("删除文件夹操作 成功执行");  
137.        } catch (Exception e) {  
138.            System.out.println("复制单个文件操作出错");  
139.            e.printStackTrace();  
140.        }  
141.    }  
142.   
143.    /** 
144.     * 复制整个文件夹内容 
145.     */  
146.    public void copyFolder(String oldPath, String newPath) {  
147.        try {  
148.            (new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹  
149.            File a=new File(oldPath);  
150.            String[] file=a.list();  
151.            File temp=null;  
152.            for (int i = 0; i < file.length; i++) {  
153.                if(oldPath.endsWith(File.separator)) {  
154.                    temp=new File(oldPath+file[i]);  
155.                } else {  
156.                    temp=new File(oldPath+File.separator+file[i]);  
157.                }  
158.   
159.                if(temp.isFile()) {  
160.                    FileInputStream input = new FileInputStream(temp);  
161.                    FileOutputStream output = new FileOutputStream(newPath + "/" +  
162.                    (temp.getName()).toString());  
163.                    byte[] b = new byte[1024 * 5];  
164.                    int len;  
165.                    while ( (len = input.read(b)) != -1) {  
166.                        output.write(b, 0, len);  
167.                    }  
168.                    output.flush();  
169.                    output.close();  
170.                    input.close();  
171.                } if(temp.isDirectory()) {  
172.                    //如果是子文件夹  
173.                    copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);  
174.                }  
175.            }  
176.            System.out.println("复制文件夹操作 成功执行");  
177.        } catch (Exception e) {  
178.            System.out.println("复制整个文件夹内容操作出错");  
179.            e.printStackTrace();  
180.        }  
181.    }  
182.   
183.    /** 
184.     * 移动文件到指定目录 
185.     */  
186.    public void moveFile(String oldPath, String newPath) {  
187.        copyFile(oldPath, newPath);  
188.        delFile(oldPath);  
189.    }  
190. }  
191.