Changeset 7121 for trunk/gli/src/org/greenstone/gatherer/util

Timestamp:

2004-03-26T15:26:24+12:00 (20 years ago)

Author:

mdewsnip

Message:

A much improved method for sorting file nodes into alphabetical order, with directories coming first. The old version was very very slow on Windows 95 and 98 computers with a large number of files (>3000) in the directory; this version is still slow, but a great deal better than before.

File:

• trunk/gli/src/org/greenstone/gatherer/util/ArrayTools.java (modified) (1 diff)

trunk/gli/src/org/greenstone/gatherer/util/ArrayTools.java

@@ -408 +408 @@
     }
 
-    /** Sorts an array of files. */
-    static public void sort(File[] files) {
-    sort(files, false);
-    }
-
-    /** Sorts an array of files. Can also to instructed to list directories first. Case insensitive.
-     * @param files The File[] to be sorted.
-     * @param directories_first true if you want to directories to be listed first.
-     */
-    static public void sort(File[] files, boolean directories_first) {
-    if(files != null && files.length > 1) {
-        FileComparator comparator = new FileComparator(directories_first);
-        Arrays.sort(files, comparator);
-    }         
-    }
+
+    /** Sorts an array of files, putting non-files first. Case insensitive.
+     * @param files_to_sort The File[] to be sorted.
+     */
+    static public void sort(File[] files_to_sort)
+    {
+    // Return if there is nothing to sort
+    if (files_to_sort == null || files_to_sort.length <= 1) {
+        return;
+    }
+
+    FileSystemView fileSystemView = FileSystemView.getFileSystemView();
+    FileComparator comparator = new FileComparator();
+
+    // Separate the file system roots and directories from the files, and sort separately
+    ArrayList files_list = new ArrayList((files_to_sort.length * 3) / 4);
+    ArrayList non_files_list = new ArrayList((files_to_sort.length) / 4);
+    for (int i = 0; i < files_to_sort.length; i++) {
+        File file = files_to_sort[i];
+
+        // File is a system root
+        if (fileSystemView.isFileSystemRoot(file)) {
+        non_files_list.add(file);
+        }
+        // File is a directory
+        else if (file.isDirectory()) {
+        non_files_list.add(file);
+        }
+        // File is an actual file
+        else {
+        files_list.add(file);
+        }
+    }
+    System.err.println("Number of files: " + files_list.size());
+    System.err.println("Number of non-files: " + non_files_list.size());
+
+    Object[] files = files_list.toArray();
+    Object[] non_files = non_files_list.toArray();
+
+    // Sort files
+    Arrays.sort(files, comparator);
+
+    // Sort non-files
+    Arrays.sort(non_files, comparator);
+
+    // Merge the results, putting non-files before files
+    int j = 0;
+    for (int i = 0; i < non_files.length; i++) {
+        files_to_sort[j++] = (File) non_files[i];
+    }
+    for (int i = 0; i < files.length; i++) {
+        files_to_sort[j++] = (File) files[i];
+    }
+    }
+
 
     /** Comparator used to order files. */
     static private class FileComparator
     implements Comparator {
-    private boolean directories_first = false;
-
-    public FileComparator(boolean directories_first) {
-        this.directories_first = directories_first;
-    }
+
     /** Compare two files in terms of ordering of their paths.
      * @param o1 The <strong>Object</strong> that represents the first file.
      * @param o2 The other <strong>Object</strong>, also a file.
-     * @return An <i>int</i> which is <1, 0 or >1 if o1 is < o2, = o2 or > o2 respectively.
+     * @return An <i>int</i> which is <1, 0 or >1 if o1 is <o2, =o2 or >o2 respectively.
      */
-    public int compare(Object o1, Object o2) {
-        int result = 0;
+    public int compare(Object o1, Object o2)
+    {
         File f1 = (File) o1;
-        String n1 = f1.getName().toLowerCase();
         File f2 = (File) o2;
-        String n2 = f2.getName().toLowerCase();
-                // Special checks for system roots as these include removable media drives and thus we should never attempt to call isDirectory until the user explicitly attempts to map drive.
-        boolean f1_system_root = FileSystemView.getFileSystemView().isFileSystemRoot(f1);
-        boolean f2_system_root = FileSystemView.getFileSystemView().isFileSystemRoot(f2);
-        if((f1_system_root && f2_system_root) || (!f2_system_root && f1_system_root && f2.isDirectory()) || (!f1_system_root && f1.isDirectory() && f2_system_root) || (f1.isDirectory() && f2.isDirectory()) || (f1.isFile() && f2.isFile())) {
-        result = n1.compareTo(n2);
-        }
-        else if(f1_system_root || f1.isDirectory()) {
-        result = -1;
-        }
-        else {
-        result = 1;
-        }
-        return result;
-    }
-    /** Compare two files for equality, in terms of their file paths.
-     * @param obj The <strong>Object</strong> representing the file we are about to compare ourselves to.
-     * @return <i>true</i> if we equal the given file, <i>false</i> otherwise.
-     */
-    public boolean equals(Object obj) {
-        return (compare(this, obj) == 0);
+
+        return f1.getName().compareToIgnoreCase(f2.getName());
     }
     }