Copying File Contents using Java

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

Copying File Contents using Java

Example 3-2 shows a program that copies the contents of a specified file to another file. This example uses the File class, much as Example 3-1 did, to check that the source file exists, that the destination is writable, and so on. But it also introduces the use of streams to work with the contents of files. It uses a FileInputStream to read the bytes of the source file and a FileOutputStream to copy those bytes to the destination file.

The copy( ) method implements the functionality of the program. This method is heavily commented, so that you can follow the steps it takes. First, it performs a surprisingly large number of checks to verify that the copy request is a legitimate one. If all those tests succeed, it then creates a FileInputStream to read bytes from the source and a FileOutputStream to write those bytes to the destination. Notice the use of a byte array buffer to store bytes during the copy. Pay particular attention to the short while loop that actually performs the copy. The combination of assignment and testing in the condition of the while loop is a useful idiom that occurs frequently in I/O programming. Also notice the finally statement that ensures the streams are properly closed before the program exits.

In addition to using streams to read from and write to files, this program also uses streams to read from and write to the console. Before overwriting an existing file, this example asks for user confirmation. It demonstrates how to read lines of text with a BufferedReader that reads individual characters from an InputStreamReader, which in turn reads bytes from System.in (an InputStream), which reads keystrokes from the user’s keyboard. Additionally, the program displays textual output with System.out and System.err, which are both instances ofPrintStream.

The static FileCopy.copy( ) method can be called directly by any program. The FileCopy class also provides a main( ) method, however, so that it can be used as a standalone program.

1. Example 3-2. FileCopy.java
   
2. package je3.io;
   
3. import java.io.*;
   
4. 
   
5. /**
   
6. * This class is a standalone program to copy a file, and also defines a
   
7. * static copy( ) method that other programs can use to copy files.
   
8. **/
   
9. public class FileCopy {
   
10.     /** The main( ) method of the standalone program.  Calls copy( ). */
    
11.     public static void main(String[  ] args) {
    
12.         if (args.length != 2)    // Check arguments
    
13.             System.err.println("Usage: java FileCopy <source> <destination>");
    
14.         else {
    
15.             // Call copy( ) to do the copy; display any error messages
    
16.             try { copy(args[0], args[1]); }
    
17.             catch (IOException e) { System.err.println(e.getMessage( )); }
    
18.         }
    
19.     }
    
20.    
    
21.     /**
    
22.      * The static method that actually performs the file copy.
    
23.      * Before copying the file, however, it performs a lot of tests to make
    
24.      * sure everything is as it should be.
    
25.      */
    
26.     public static void copy(String from_name, String to_name)
    
27.         throws IOException
    
28.     {
    
29.         File from_file = new File(from_name);  // Get File objects from Strings
    
30.         File to_file = new File(to_name);
    
31.         
    
32.         // First make sure the source file exists, is a file, and is readable.
    
33.         // These tests are also performed by the FileInputStream constructor,
    
34.         // which throws a FileNotFoundException if they fail.
    
35.         if (!from_file.exists( ))
    
36.             abort("no such source file: " + from_name);
    
37.         if (!from_file.isFile( ))
    
38.             abort("can't copy directory: " + from_name);
    
39.         if (!from_file.canRead( ))
    
40.             abort("source file is unreadable: " + from_name);
    
41.         
    
42.         // If the destination is a directory, use the source file name
    
43.         // as the destination file name
    
44.         if (to_file.isDirectory( ))
    
45.             to_file = new File(to_file, from_file.getName( ));
    
46.         
    
47.         // If the destination exists, make sure it is a writeable file
    
48.         // and ask before overwriting it.  If the destination doesn't
    
49.         // exist, make sure the directory exists and is writeable.
    
50.         if (to_file.exists( )) {
    
51.             if (!to_file.canWrite( ))
    
52.                 abort("destination file is unwriteable: " + to_name);
    
53.             // Ask whether to overwrite it
    
54.             System.out.print("Overwrite existing file " + to_file.getName( ) +
    
55.                              "? (Y/N): ");
    
56.             System.out.flush( );
    
57.             // Get the user's response.
    
58.             BufferedReader in=
    
59.                 new BufferedReader(new InputStreamReader(System.in));
    
60.             String response = in.readLine( );
    
61.             // Check the response.  If not a Yes, abort the copy.
    
62.             if (!response.equals("Y") && !response.equals("y"))
    
63.                 abort("existing file was not overwritten.");
    
64.         }
    
65.         else {  
    
66.             // If file doesn't exist, check if directory exists and is
    
67.             // writeable.  If getParent( ) returns null, then the directory is
    
68.             // the current dir.  so look up the user.dir system property to
    
69.             // find out what that is.
    
70.             String parent = to_file.getParent( );  // The destination directory
    
71.             if (parent ==== null)     // If none, use the current directory
    
72.                 parent = System.getProperty("user.dir");
    
73.             File dir = new File(parent);          // Convert it to a file.
    
74.             if (!dir.exists( ))
    
75.                 abort("destination directory doesn't exist: "+parent);
    
76.             if (dir.isFile( ))
    
77.                 abort("destination is not a directory: " + parent);
    
78.             if (!dir.canWrite( ))
    
79.                 abort("destination directory is unwriteable: " + parent);
    
80.         }
    
81.         
    
82.         // If we've gotten this far, then everything is okay.
    
83.         // So we copy the file, a buffer of bytes at a time.
    
84.         FileInputStream from = null;  // Stream to read from source
    
85.         FileOutputStream to = null;   // Stream to write to destination
    
86.         try {
    
87.             from = new FileInputStream(from_file);  // Create input stream
    
88.             to = new FileOutputStream(to_file);     // Create output stream
    
89.             byte[  ] buffer = new byte[4096];         // To hold file contents
    
90.             int bytes_read;                         // How many bytes in buffer
    
91. 
    
92.             // Read a chunk of bytes into the buffer, then write them out,
    
93.             // looping until we reach the end of the file (when read( ) returns
    
94.             // -1).  Note the combination of assignment and comparison in this
    
95.             // while loop.  This is a common I/O programming idiom.
    
96.             while((bytes_read = from.read(buffer)) != -1) // Read until EOF
    
97.                 to.write(buffer, 0, bytes_read);            // write
    
98.         }
    
99.         // Always close the streams, even if exceptions were thrown
    
100.         finally {
     
101.             if (from != null) try { from.close( ); } catch (IOException e) { ; }
     
102.             if (to != null) try { to.close( ); } catch (IOException e) { ; }
     
103.         }
     
104.     }
     
105. 
     
106.     /** A convenience method to throw an exception */
     
107.     private static void abort(String msg) throws IOException {
     
108.         throw new IOException("FileCopy: " + msg);
     
109.     }
     
110. }

复制代码

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：contents Content Using COPY Java specified contents another example source