Java 把一个文本文档的内容复制到另一个文本文档

src.txt放在工程目录下，dest.txt可创建，也可不创建。一旦运行程序，如果dest.txt不存在，将自行创建这个文本文档，再将src.txt中的内容复制到dest.txt

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;

 public class IOTest04 {

     public static void main(String[] args) {
         copy("src.txt", "dest.txt");
     }

     public static void copy(String srcPath, String destPath) {
         File src = new File(srcPath);
         File dest = new File(destPath);
         InputStream is = null;
         OutputStream os = null;

         try {
             is = new FileInputStream(src);
             os = new FileOutputStream(dest, false);

             byte[] buffer = new byte[1024 * 1];                    // 1k bytes
             int length = -1;
             while ((length = is.read(buffer)) != -1) {
                 os.write(buffer, 0, length);
                 os.flush();
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if (os != null) {
                     os.close();
                     System.out.println("OutputStream Closed.");
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
             try {
                 if (is != null) {
                     is.close();
                     System.out.println("InputStream Closed.");
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }

----    ----    ----    ----    ----    ----    ----    ----

读取文本文档A中的内容，先进行“加密”，将加密的内容写入到另一个文本文档B；完成加密和写入之后，再将文本文档B中（已加密）的内容复制、并覆盖文本文档A中原本的内容，删除文本文档B。

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;

 public class Encrypt {

     public static void main(String[] args) {
         encrypt("src.txt", 1);
     }

     public static void encrypt(String srcPath, int password) {
         File src = new File(srcPath);
         File dest = new File(src.getParent(), ("temp" + src.getName()));
         InputStream is = null;
         OutputStream os = null;

         try {
             is = new FileInputStream(src);
             os = new FileOutputStream(dest);

             byte[] buffer = new byte[1024 * 1];                    // 1k bytes
             int length = -1;
             while ((length = is.read(buffer)) != -1) {
                 for (int i = 0; i < length; ++i) {
                     buffer[i] = (byte) (buffer[i] + password);
                 }
                 os.write(buffer, 0, length);
                 os.flush();
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if (os != null) {
                     os.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
             try {
                 if (is != null) {
                     is.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

         try {
             is = new FileInputStream(dest);
             os = new FileOutputStream(src);

             byte[] buffer = new byte[1024 * 1];                    // 1k bytes
             int length = -1;
             while ((length = is.read(buffer)) != -1) {
                 os.write(buffer, 0, length);
                 os.flush();
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if (os != null) {
                     os.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
             try {
                 if (is != null) {
                     is.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

         dest.delete();
     }
 }

文本文档A中的内容：

对每一个字符执行+1（实际就是将字符所对应的编码进行+1）的操作，之后变成：

----    ----    ----    ----    ----    ----    ----    ----

分解一

16         File src = new File(srcPath);
17         File dest = new File(src.getParent(), ("temp" + src.getName()));

getParent() - 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。

getName() - 返回由此抽象路径名表示的文件或目录的名称。

绝对路径名的定义与系统有关。在 UNIX 系统上，如果路径名的前缀是 "/"，那么该路径名是绝对路径名。在 Microsoft Windows 系统上，如果路径名的前缀是后跟 "\\" 的盘符，或者是 "\\\\"，那么该路径名是绝对路径名。

 import java.io.File;

 public class IO_Test01 {

     public static void main(String[] args) {
         File src = null;
         File dest = null;

         // Relative path
         src = new File("src.txt");
         dest = new File(src.getParent(), ("temp" + src.getName()));

         System.out.println("Is absolute path: " + src.isAbsolute());
         System.out.println("src's parent: " + src.getParent());
         System.out.println("src's name: " + src.getName());

         System.out.println("dest's parent: " + dest.getParent());
         System.out.println("dest's name: " + dest.getName());
         System.out.println("--------");

         // Absolute path
         src = new File("E:/Java/workspace/IO_Study02/src.txt");
         dest = new File(src.getParent(), ("temp" + src.getName()));

         System.out.println("Is absolute path: " + src.isAbsolute());
         System.out.println("src's parent: " + src.getParent());
         System.out.println("src's name: " + src.getName());

         System.out.println("dest's parent: " + dest.getParent());
         System.out.println("dest's name: " + dest.getName());
     }
 }

输出结果：

Is absolute path: false
src's parent: null
src's name: src.txt
dest's parent: null
dest's name: tempsrc.txt
--------
Is absolute path: true
src's parent: E:\Java\workspace\IO_Study02
src's name: src.txt
dest's parent: E:\Java\workspace\IO_Study02
dest's name: tempsrc.txt

----    ----    ----    ----    ----    ----    ----    ----

分解二

25             byte[] buffer = new byte[1024 * 1];                    // 1k bytes
26             int length = -1;
27             while ((length = is.read(buffer)) != -1) {
28                 for (int i = 0; i < length; ++i) {
29                     buffer[i] = (byte) (buffer[i] + password);
30                 }
31                 os.write(buffer, 0, length);
32                 os.flush();
33             }

其中的28~30行很好理解，这里不解释。

关键在于方法read(byte[] b)、write(byte[] b, int off, int len)。

public int read(byte[] b) - 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。在某些输入可用之前，此方法将阻塞。返回：读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;

 public class IO_Test01 {

     public static void main(String[] args) {
         File src = new File("E:/Java/workspace/IO_Study02/src.txt");
         InputStream is = null;

         try {
             is = new FileInputStream(src);

             byte[] buffer = new byte[1024 * 1];                    // 1k bytes
             int length = -1;
             int times = 0;
             while ((length = is.read(buffer)) != -1) {
                 ++times;
                 System.out.println("length: " + length);
                 System.out.println("times: " + times);
             }
             System.out.println("length: " + length);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if (is != null) {
                     is.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }

输出结果：

length: 47
times: 1
length: -1

length = 47，代表从src.txt中读取到的字节数，也就是有read()返回的。

times = 1，表示while()循环只执行了一次。

length = -1，是while()执行第二次判断，因为src.txt中的内容已经读取完毕了，所以read()返回-1。

public void write(byte[] b, int off, int len) - 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。参数：b - 数据。 off - 数据中的起始偏移量。 len - 要写入的字节数。

----    ----    ----    ----    ----    ----    ----    ----

分解三

功力不够深厚，理解不了，写不出！！！

----    ----    ----    ----    ----    ----    ----    ----

分解X

86         dest.delete();

public boolean delete() - 删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录必须为空才能删除。返回： 当且仅当成功删除文件或目录时，返回 true；否则返回 false

----    ----    ----    ----    ----    ----    ----    ----

总结：待完善、纠错。