Use find:

find . -mtime +45 -exec /bin/rm {} \;

or

find . -mtime +45 -print0 | xargs -0 /bin/rm

/gordon

--

It's not a memory problem, it's a bug in the way you wrote the program.

Plus, multi-threaded programs are harder to get correct.  Get the
single-threaded one right first.

Start with the little things - class names really should start with an
upper-case letter, by widespread convention.  You really should indent your
code appropriately.  Violation of those two conventions made it very difficult
to read the listing.

A good way to name a class is in two parts representing a noun phrase, e.g.,
FileDeleter.

Now the reason for your bug.  The class is doing too much work in the
constructor - the constructor should only construct, nothing more.  You have
it placing an incomplete object as the FileFilter for the listFiles() call.
No wonder you have trouble.

Build the FileFilter in the constructor, but use it from another method; I
suggest deleteFiles() (which you could rename to, say, run()).  That would let
you take the variable 'fileArray' and 'dirPath' out of the member attributes
and make them local variables only.  ('dirPath' would be local to the
constructor, and 'fileArray' to the method.)

Speaking of deleteFiles(), variables should not have underscores in their
names, "no_of_files".  Use camelCase, where each word part except the first is
capitalized, "noOfFiles".

public class FileDeleter implements Runnable
{
  // members should be private!
 private final File file;
 private final int daysKeep;

 // notice the 'public' visibility of the constructor
 public FileDeleter( String path, int days )
 {
   file = new File( path );
   if ( file == null || ! file.isDirectory() )
   {
     String err = dirPath +" not a directory.";
     System.err.println( err );
     throw new IllegalArgumentException( err );
   }
   daysKeep = days;
 }

 @Override public void run()
 {
   File [] files = file.listFiles( new FileFilter()
     {
      @Override public boolean accept( File p )
      {
        return ( ! f.isDirectory() && daysSince( f ) > daysKeep );
      }
     } );
   if ( files != null && files.length > 0 )
   {
     delete( files );
   }
 }

 private void delete( File [] files )
 {
   for ( File f : files )
   {
     f.delete();
   }
 }

 private static final int PERDIEM = 86400000;

 private int daysSince( File f )
 {
   return (int) ( (new Date().getTime() - f.lastModified()) / PERDIEM);
 }
}

Throw in some imports and a test client and Bob's your uncle.