If you are using Java 1.7, you can use java.nio.file.Files.walkFileTree(...).

For example:

public class WalkFileTreeExample {

  public static void main(String[] args) {
    Path p = Paths.get("/usr");
    FileVisitor<Path> fv = new SimpleFileVisitor<Path>() {
      @Override
      public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
          throws IOException {
        System.out.println(file);
        return FileVisitResult.CONTINUE;
      }
    };

    try {
      Files.walkFileTree(p, fv);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

}

If you are using Java 8, you can use the stream interface with java.nio.file.Files.walk(...):

public class WalkFileTreeExample {

  public static void main(String[] args) {
    try (Stream<Path> paths = Files.walk(Paths.get("/usr"))) {
      paths.forEach(System.out::println);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

}

I guess there are so many ways to make what you want. Here's a way that I use. With the commons.io library you can iterate over the files in a directory. You must use the FileUtils.iterateFiles method and you can process each file.

You can find the information here: http://commons.apache.org/proper/commons-io/download_io.cgi

Here's an example:

Iterator it = FileUtils.iterateFiles(new File("C:/"), null, false);
        while(it.hasNext()){
            System.out.println(((File) it.next()).getName());
        }

You can change null and put a list of extentions if you wanna filter. Example: {".xml",".java"}

basically used finding children of a folder method thanks to Elliotk link. I am making the string equal to the path of the parent folder - >checking if whether if its a directory - > list its files -> get the names and while loop to write all of them to a zipped folder

here is my whole code

    package zipfolder2;

    import java.io.*;
    import java.util.*;
    import java.util.zip.ZipEntry;
    import java.util.zip.ZipOutputStream;

    public class zipfolders2 {

        public static void main(String[] args) {
            try {

                String sourceFile = "src/resources";
                FileOutputStream fos = new FileOutputStream("zippedfiles.zip");
                ZipOutputStream zipOut = new ZipOutputStream(fos);
                File fileToZip = new File(sourceFile);

                zipFile(fileToZip, fileToZip.getName(), zipOut);
                zipOut.close();
                fos.close();

            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        private static void zipFile(File fileToZip, String fileName, ZipOutputStream zipOut) throws IOException {
            if (fileToZip.isHidden()) {
                return;
            }
            if (fileToZip.isDirectory()) {
                File[] children = fileToZip.listFiles();
                for (File childFile : children) {
                    zipFile(childFile, fileName + "/" + childFile.getName(), zipOut);
                }
                return;
            }
            FileInputStream fis = new FileInputStream(fileToZip);
            ZipEntry zipEntry = new ZipEntry(fileName);
            zipOut.putNextEntry(zipEntry);
            byte[] bytes = new byte[1024];
            int length;
            while ((length = fis.read(bytes)) >= 0) {
                zipOut.write(bytes, 0, length);
            }
            fis.close();
        }

    }

Here is a quick example that may help:

private ArrayList<byte[][]> getDoubleByteArrayOfDirectory(String dirName,
    Region region) throws IOException {
       ArrayList<byte[][]> results = new ArrayList<byte[][]>();
       File directory = new File(dirName);
       if (!directory.isDirectory()) return null //or handle however you wish
       for (File file : directory.listFiles()) {
           results.add(getDoubleByteArrayOfFile(file.getName()), region);
       }  
       return results;
}

Not exactly what you asked for since it's wrapping your old method rather than re-writing it, but I find it a bit cleaner this way, and leaves you with the option of still processing a single file. Be sure to tweak the return type and how to handle the region based on your actual requirements (hard to tell from the question).

jad has support for this built-in, according to the documentation. It will expand globs for you, including ** recursive globs. So use quotes to protect them from the shell, like this example cmd copied from the docs:

jad -o -r -sjava -dsrc 'tree/**/*.class'

This command decompiles all .class files located in all subdirectories of tree and creates output files in subdirectories of src according to package names of classes. For example, if file tree/a/b/c.class contains class c from package a.b, then output file will have a name src/a/b/c.java.

This is almost certainly the best option if you like its choices of directory structure. I looks like without -r it won't turn package structure into directories. IDK if you could get it to put the .java files next to the the .class files with your directory structure.

Using find -execdir to run jad in the right directory:

# untested
find [more find options]  -name '*.class' -execdir jad {} +

This will effectively cd to every directory that contains at least one .class, and do the equivalent of running jad *.class there. (Note the + instead of \; to group multiple args into one command).

GNU find is powerful; read the man page.

Or use bash features:

Since you're using bash, you can make for dir in ./* recursive with bash's globstar feature. It's significantly slower than find for big directory trees, because it bash doesn't know to take advantage of the file-type hint returned by readdir to avoid having to lstat every dir entry to see if it's a directory. But bash recursive globs can be useful.

# untested
shopt -s globstar       # put this in your .bashrc if you want it enabled all the time

for dir in ./**/; do
    pushd "$dir"
    classfiles=( *.class )               # expand the glob into an array
    [[ -e $classfiles ]] &&              # test the first element of the array.  Will fail if *.class didn't match anything.
       jad *.class
    popd "$dir"
done

Note the use of a trailing slash to make the glob match only directories.