Java File Replication

Summary

Although Java provides an IO operation class that can handle files. However, there is no way to copy a file. Copying files is an important operation when your program has to handle a lot of files related to the time. There are several ways to copy Java files, however, and here are some of the most popular ways to do this in 4. 1. Copying using file Streams

This is the most classic way to copy the contents of a file to another file. Use FileInputStream to read the bytes of file a, using FileOutputStream to write to file B. This is the code for the first method:

public static void Copyfileusingfilestreams (File source,file dest)
Throws ioexception{
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream (source);
Output = new FileOutputStream (dest);
byte[] buf = new byte[1024];
int bytesread;
while ((Bytesread = Input.read (buf)) > 0) {
Output.write (Buf,0,bytesread);
}
}finally {
Input.close ();
Output.close ();
}

}

As you can see, we perform several read and write operations to try the data, so this should be a inefficient one, and the next method we will see is the new way.

2. Copy using FileChannel

Java NiO includes the Transferfrom method, which should be faster to copy than file stream according to the document. Here is the code for the second method:

2. private static void copyfileusingfilechannels(file source, File Dest) throws IOException {
4. FileChannel inputchannel = null;
6. FileChannel outputchannel = null;
8. try {
10. Inputchannel = new FileInputStream (source). Getchannel ();
12. Outputchannel = new FileOutputStream (dest). Getchannel ();
14. Outputchannel.transferfrom (Inputchannel, 0, Inputchannel.size ());
16. } finally {
18. Inputchannel.close ();
20. Outputchannel.close ();
22. }
24. }

3. Using commons IO Replication

Apache Commons IO provides a copy file method in its Fileutils class, which can be used to copy a file to another place. It is very handy when you use the Apache Commons Fileutils class when you have used your project. Basically, this class uses Java NIO filechannel inside. This is the code for the third method:

1. private static void copyfileusingapachecommonsio(file source, file dest)
2. throws IOException {
3. Fileutils.copyfile (source, dest);
4. }

4. Copying files class using Java7

If you have some experience in Java 7 You might know that you can use the Copy method of the files class file to copy from one file to another. This is the code for the fourth method:

1. private static void copyfileusingjava7files(file source, File dest)
2. throws IOException {
3. Files.copy (Source.topath (), Dest.topath ());
4. }

5. Testing

Now see which of these methods is more efficient, we will copy a large file using each one in a simple program. From cache to avoid any performance obviously we will use four different source files and four different target files. Let's take a look at the code:

2. import Java.io.File;
4. import Java.io.FileInputStream;
6. import Java.io.FileOutputStream;
8. import java.io.IOException;
10. import Java.io.InputStream;
12. import Java.io.OutputStream;
14. import Java.nio.channels.FileChannel;
16. import java.nio.file.Files;
18. import org.apache.commons.io.FileUtils;
22. public class copyfilesexample {
26. Public static void main(string[] args) throws Interruptedexception,
28. IOException {
32. File Source = New File ("C:\\users\\nikos7\\desktop\\files\\sourcefile1.txt");
34. File Dest = new File ("C:\\users\\nikos7\\desktop\\files\\destfile1.txt");
38. //Copy file using FileStreamslong start = System.nanotime ();
40. long end;
42. Copyfileusingfilestreams (source, dest);
44. System.out.println ("Time taken by filestreams Copy ="
46. + (System.nanotime ()-start));
50. //Copy files using Java.nio.FileChannelsource = new File("C:\\users\\nikos7\\desktop \\files\\sourcefile2.txt ");
52. Dest = New File ("C:\\users\\nikos7\\desktop\\files\\destfile2.txt");
54. Start = System.nanotime ();
56. Copyfileusingfilechannels (source, dest);
58. End = System.nanotime ();
60. System.out.println ("Time taken by filechannels Copy =" + (End-start));
64. //Copy file using Java 7 Files classSource = new file("c:\\users\\nikos7\\desktop\\ Files\\sourcefile3.txt ");
66. Dest = New File ("C:\\users\\nikos7\\desktop\\files\\destfile3.txt");
68. Start = System.nanotime ();
70. Copyfileusingjava7files (source, dest);
72. End = System.nanotime ();
74. System.out.println ("Time taken by Java7 Files Copy =" + (End-start));
78. //Copy files using Apache commons iosource = new File("c:\\users\\nikos7\\desktop\\ Files\\sourcefile4.txt ");
80. Dest = New File ("C:\\users\\nikos7\\desktop\\files\\destfile4.txt");
82. Start = System.nanotime ();
84. Copyfileusingapachecommonsio (source, dest);
86. End = System.nanotime ();
88. System.out.println ("Time taken by Apache Commons IO Copy ="
90. + (End-start));
94. }
98. private static void copyfileusingfilestreams(file source, File dest)
100. throws IOException {
102. InputStream input = null;
104. OutputStream output = null;
106. try {
108. input = new FileInputStream (source);
110. Output = new FileOutputStream (dest);
112. byte[] buf = new byte[1024x768];
114. int bytesread;
116. While ((bytesread = Input.read (buf)) > 0) {
118. Output.write (buf, 0, bytesread);
120. }
122. } finally {
124. Input.close ();
126. Output.close ();
128. }
130. }
134. private static void copyfileusingfilechannels(file source, File dest)
136. throws IOException {
138. FileChannel inputchannel = null;
140. FileChannel outputchannel = null;
142. try {
144. Inputchannel = new FileInputStream (source). Getchannel ();
146. Outputchannel = new FileOutputStream (dest). Getchannel ();
148. Outputchannel.transferfrom (Inputchannel, 0, Inputchannel.size ());
150. } finally {
152. Inputchannel.close ();
154. Outputchannel.close ();
156. }
158. }
162. private static void copyfileusingjava7files(file source, File dest)
164. throws IOException {
166. Files.copy (Source.topath (), Dest.topath ());
168. }
172. private static void copyfileusingapachecommonsio(file source, file dest)
174. throws IOException {
176. Fileutils.copyfile (source, dest);
178. }
182. }

Output:

1. Time taken by filestreams Copy = 127572360
2. Time taken by filechannels Copy = 10449963
3. Time taken by Java7 Files Copy = 10808333
4. Time taken by Apache Commons IO Copy = 17971677

As you can see, filechannels copying large files is the best method. If you deal with larger files, you will notice a greater speed difference. This is an example that shows four different ways in Java that you can copy a file.

Java File Replication