File length different for a copied file. Or use checksum

Question

Hi
I am making a backup of a file before doing some writes to the original.
I first check it out of source control, then make a copy using:
public static void backupFile(File f)
try{
File backup = new File(f.getPath()+"_BACKUP");
if (!backup.exists()) {
if (!backup.createNewFile()) {
Logger.getLogger().log("Could not create "+backup.getPath());
SystemTools.copyFile(f,backup);
} catch (Exception e)
Logger.getLogger().log("Error backing up "+f.getPath()+ ": "+e);
public static synchronized void copyFile(File from, File to) throws Exception
if (!from.exists() || !from.isFile())
throw new Exception ("copyFile Error: checking 'from' file!");
if (!to.exists())
if(!to.createNewFile())
throw new Exception ("copyFile Error: creating 'to' file!");
FileInputStream in=new FileInputStream(from);
FileOutputStream out=new FileOutputStream(to);
int length;
byte[] buffer=new byte[256];
while((length=in.read(buffer))!=-1) {       
out.write(buffer, 0, length);
in.close();
out.close();
After writing has finished, I need to see if the file is different to the backup..
If so, I need to check it into source control.
I wanted to use a checksum, but couldn't find an example that actually worked!!! Therefore I did a quick tool:
public static boolean isBackupIdenticalToOrig(File f) throws Exception {
File bu = new File(f.getPath()+"_BACKUP");
Logger.getLogger().log("Lengths: New/Backup"+f.length()+"/"+bu.length());
if (bu.length()!=f.length())
return false;
// Have the same lengths, so we can compare!!
BufferedInputStream f_in = null;
BufferedInputStream bu_in= null;
f_in =new BufferedInputStream (new FileInputStream (f));
bu_in =new BufferedInputStream (new FileInputStream (bu));
for (int i=0;i<f.length();i++)
int c = f_in.read();
int d = bu_in.read();
if (c!=d)
Logger.getLogger().log(""+f.getName()+" has been modified");
return false;
Logger.getLogger().log(""+f.getName()+" has not been modified");
return true;
The problem is in that the File.length() method is returning different values for the backup file, than for the original, even if identical!
For example:
10/15/2002 10:22:05: Lengths: New/Backup413/402
10/15/2002 10:22:06: Lengths: New/Backup397/386
10/15/2002 10:22:07: Lengths: New/Backup191/185
All the new files are longer that the backup, but the contents are exactly the same! Is there some WIN32 'extras' in the file that's causing a problem here???
In each of the cases, if I open the new(Longer) file in a good editor, I can see that the lengths are correct. But no extra characters existed in the new file compared to the backup!!
Any ideas would be most appreciated
Cheers
Chris

Answer 1

10 and 13 are CR(carriage return) and LF(linefeed) - this is normal for a Windows file. Use this copy routine; it works.
   // copyFile -  input: inFile -  path to source file
   //                    outFile - path to copy file to (including filename)
   //                    bRemoveSource - true removes the source files, false leaves them intact
   //             returns: void
   public static void copyFile(String inFile, String outFile,boolean bRemoveSource) throws IOException
      FileInputStream fin     = null;
      FileOutputStream fout   = null;
      boolean bCanWrite       = false;
      boolean bDeleted        = false;
      // To preserve date/time stamp
      File fTimeIn = new File(inFile);
      File fTimeOut = new File(outFile);
      long lTimeIn = fTimeIn.lastModified();
      try
        fin  = new FileInputStream(inFile);
        fout = new FileOutputStream(outFile);
        copyStream(fin, fout);
      finally
        try
          if (fin != null) fin.close();
        catch (IOException e) {}
        try
          if (fout != null) fout.close();
        catch (IOException e) {}
      fin.close();
      fout.close();
      // Set out time to in time
      fTimeOut.setLastModified(lTimeIn);
      if (bRemoveSource == true)
         bCanWrite = fTimeIn.canWrite();
         if (bCanWrite)  {
            bDeleted = fTimeIn.delete();
   // copyStream (a helper function for copyFile) -  input: in  - file stream of source file
   //                                                       out - file stream of destination file
   //                                                returns: void
   // *** NOTE: This function is thread safe ***
   public static void copyStream(InputStream in, OutputStream out)  throws IOException
      // do not allow other threads to read from the
      // input or write to the output while copying is
      // taking place
      synchronized (in)  {
         synchronized (out)  {
            byte[] buffer = new byte[256];
            while (true)  {
               int bytesRead = in.read(buffer);
               if (bytesRead == -1)
                  break;
               out.write(buffer, 0, bytesRead);
   }