精华内容
下载资源
问答
  • Java实现文件目录列表的自定义排序

    千次阅读 2013-07-03 15:40:45
    Java列出某个文件目录文件列表是很容易实现的,只用调用File类的list()方法即可。  String[] list()   返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中文件目录。 ...

    用Java列出某个文件目录的文件列表是很容易实现的,只用调用File类中的list()方法即可。

     String[]list() 
              返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录。

    但是此时文件的列表是按照字符串默认的排序方式进行排序的

    [html]  view plain copy
    1. package cn.uestc.fz;  
    2.   
    3. import java.io.File;  
    4.   
    5. public class Filelists {  
    6.     public static void main(String[] args) {  
    7.         File file = new File("E:\\MyDoc"); //目录路径  
    8.         if(file.isDirectory()){ //判断file是否为目录  
    9.             String[] fileNames = file.list();  
    10.             for(int i=0;i<fileNames.length;i++){  
    11.                 System.out.println(fileNames[i]);  
    12.             }  
    13.         }  
    14.     }  
    15.       
    16. }  


    运行结果:

    [html]  view plain copy
    1. 1.1.txt  
    2. 1.2.txt  
    3. 1.3.txt  
    4. 1.4.txt  
    5. 10.txt  
    6. 11.txt  
    7. 12.1.txt  
    8. 2.1.txt  
    9. 2.2.txt  
    10. 3.txt  
    11. 4.txt  
    12. 5.txt  
    13. 6.txt  
    14. 7.txt  
    15. 8.txt  
    16. 9.txt  

    显然,10号的文件排在了2号的前面,这并不是按整数的顺序排的,是按照字符的顺序排的。

    那么我们怎么实现文件名按照整数序号来排序呢,首先我想到了java中的Comparable接口,用某个类继承String类再实现Comparable接口,但是list()方法返回的是String类型的数组,而String的定义是

    public final class String

    extends  Object implements  Serializable Comparable < String >,  CharSequence

    也就是说它不能被继承。

     

    此时查文档发现了另外一个并不常用的接口,Comparator,它可以在不改变某个类代码的情况下,给它定义排序的规则。

    [html]  view plain copy
    1. package cn.uestc.fz;  
    2.   
    3. import java.io.File;  
    4. import java.util.Arrays;  
    5. import java.util.Comparator;  
    6.   
    7. public class Filelists1 {  
    8.     public static void main(String[] args) {  
    9.         File file = new File("E:\\MyDoc"); //目录路径  
    10.         if(file.isDirectory()){ //判断file是否为目录  
    11.             String[] fileNames = file.list();  
    12.             Arrays.sort(fileNames,new StringComparator());  
    13.             for(int i=0;i<fileNames.length;i++){  
    14.                 System.out.println(fileNames[i]);  
    15.         }  
    16.         }  
    17.     }  
    18. }  
    19.       
    20. //此类实现Comparable接口  
    21. class StringComparator implements Comparator<String>{  
    22.     @Override  
    23.     public int compare(String s1, String s2) {  
    24.         if(StringComparator.returnDouble(s1)<StringComparator.returnDouble(s2))  
    25.             return -1;  
    26.         else if(StringComparator.returnDouble(s1)>StringComparator.returnDouble(s2))  
    27.             return 1;  
    28.         else  
    29.             return 0;  
    30.           
    31.     }  
    32.       
    33.     public static double returnDouble(String str){  
    34.         StringBuffer sb = new StringBuffer();  
    35.         for(int i=0;i<str.length();i++){  
    36.             if(Character.isDigit(str.charAt(i)))  
    37.                 sb.append(str.charAt(i));  
    38.             else if(str.charAt(i)=='.'&&i<str.length()-1&&Character.isDigit(str.charAt(i+1)))  
    39.                 sb.append(str.charAt(i));  
    40.             else break;  
    41.         }  
    42.         if(sb.toString().isEmpty())  
    43.             return 0;  
    44.         else  
    45.             return Double.parseDouble(sb.toString());  
    46.     }  
    47.   
    48.       


    由类StringComparator实现Comparator接口就可以改变String类型的默认排序方式,其中compare是需要复写的方法,类似于Comparable接口中的compareTo方法。

    returnDouble是写的一个静态方法,用来返回某个文件名字符串前面的数字编号,如"1.1.txt"返回的就是"1.1",写的时候老是出现越界异常,后来终于改成功了,可能写得有点复杂了。

     

    这样再调用Arrays类中的sort(T[] a, Comparator<? super T> c) 方法就可以对文件名排序了。

    最后的结果符合我们的预期:

    [html]  view plain copy
    1. 1.1.txt  
    2. 1.2.txt  
    3. 1.3.txt  
    4. 1.4.txt  
    5. 2.1.txt  
    6. 2.2.txt  
    7. 3.txt  
    8. 4.txt  
    9. 5.txt  
    10. 6.txt  
    11. 7.txt  
    12. 8.txt  
    13. 9.txt  
    14. 10.txt  
    15. 11.txt  
    16. 12.1.txt  

    展开全文
  • 文件按照window 的排序规则-Java实现。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • Java文件及文件目录排序

    千次阅读 2014-07-28 17:12:56
    目录排在前面,文件排在后面。a

    目录排在前面,文件排在后面。按照字典升序排列。直接上代码

    List<File> files = Arrays.asList(new File("D:/").listFiles());
    Collections.sort(files, new Comparator<File>(){
        @Override
        public int compare(File o1, File o2) {
    	if(o1.isDirectory() && o2.isFile())
    	    return -1;
    	if(o1.isFile() && o2.isDirectory())
        	    return 1;
    	return o1.getName().compareTo(o2.getName());
        }
    });
    
    for(File f : files)
        System.out.println(f.getName());


    展开全文
  • package merge; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.text.SimpleDateFormat;
      
    
    1. package merge;   
    2.   
    3. import java.io.BufferedReader;   
    4. import java.io.BufferedWriter;   
    5. import java.io.File;   
    6. import java.io.FileReader;   
    7. import java.io.FileWriter;   
    8. import java.text.SimpleDateFormat;   
    9. import java.util.ArrayList;   
    10. import java.util.Iterator;   
    11. import java.util.LinkedHashSet;   
    12. import java.util.List;   
    13. import java.util.Set;   
    14. import java.util.SortedSet;   
    15. import java.util.TreeSet;   
    16.   
    17. /**  
    18.  *   
    19.  * 外部排序指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存,  
    20.  * 需要在内存和外部存储器之间进行多次数据交换,以达到排序整个文件的目的。  
    21.  * 外部排序最常用的算法是多路归并排序,即将原文件分解成多个能够一次性装人内存的部分,  
    22.  * 分别把每一部分调入内存完成排序。然后,对已经排序的子文件进行归并排序。  
    23.  *   
    24.  * @author jia.hej  
    25.  *  
    26.  * @version $Id: MergeSort.java, v 0.1 2009-8-7 下午03:53:51 jia.hej Exp $  
    27.  */  
    28. public class MergeSort {   
    29.   
    30.     /** 十 */  
    31.     private static long   TEN              = 10;   
    32.     /** 百 */  
    33.     private static long   HUNDRED          = 100;   
    34.     /** 千 */  
    35.     private static long   THOUSAND         = 1000;   
    36.     /** 万 */  
    37.     private static long   MILLION          = 10000;                 //1078  00:00:01 078   
    38.     /** 十万 */  
    39.     private static long   TEN_MILLION      = 100000;                //9656  00:00:09 656   
    40.     /** 百万 */  
    41.     private static long   HUNDRED_MILLION  = 1000000;               //93733  00:01:33 733   
    42.     /** 千万 */  
    43.     private static long   THOUSAND_MILLION = 10000000;              //970144  00:16:10 144   
    44.     /** 亿 */  
    45.     private static long   BILLION          = 100000000;   
    46.     /** 十亿 */  
    47.     private static long   TEN_BILLION      = 1000000000;   
    48.     /** 百亿 */  
    49.     private static long   HUNDRED_BILLION  = 10000000000l;   
    50.     /** 千亿 */  
    51.     private static long   THOUSAND_BILLION = 100000000000l;   
    52.   
    53.     private static String INPUT_FILE       = "c:\\test\\input.txt";   
    54.   
    55.     private static String OUTPUT_FILE      = "c:\\test\\output.txt";   
    56.   
    57.     /** 拆分大小 */  
    58.     private static int    SPLIT_SIZE       = 10 * 10000;   
    59.   
    60.     private static int    numSize;   
    61.   
    62.     public static void main(String[] args) throws Exception {   
    63.         createDir("c:\\test");   
    64.         createFile(INPUT_FILE);   
    65.         numSize = createRandomNum(THOUSAND_MILLION);   
    66.   
    67.         sortFile(INPUT_FILE);   
    68.   
    69.         long beginTime = System.currentTimeMillis();   
    70.         System.out.println("begin=" + beginTime);   
    71.   
    72.         //拆分文件   
    73.         splitFile(INPUT_FILE, numSize);   
    74.   
    75.         List<String> splitFilePathList = new ArrayList<String>();   
    76.         File dir = new File("c:\\test\\temp");   
    77.         File[] files = dir.listFiles();   
    78.         for (int i = 0; i < files.length; i++) {   
    79.             File file = files[i];   
    80.             splitFilePathList.add(file.getAbsolutePath());   
    81.         }   
    82.         //合并文件   
    83.         createFile(OUTPUT_FILE);   
    84.         mergeFile(splitFilePathList, OUTPUT_FILE);   
    85.   
    86.         long endTime = System.currentTimeMillis();   
    87.         System.out.println("end=" + endTime);   
    88.         System.out.println("end-begin=" + (endTime - beginTime));   
    89.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");   
    90.         System.out.println(simpleDateFormat.format(endTime - beginTime));   
    91.   
    92.         //删除拆分文件   
    93.         System.gc();   
    94.         Runtime.getRuntime().exec(new String[] { "cmd""/c""del""c:\\test\\temp\\*.txt" });   
    95.     }   
    96.   
    97.     private static void sortFile(String path) throws Exception {   
    98.         SortedSet<Integer> set = new TreeSet<Integer>();   
    99.         File file = new File(path);   
    100.         FileReader fileReader = new FileReader(file);   
    101.         BufferedReader bufferedReader = new BufferedReader(fileReader);   
    102.         String value;   
    103.         while ((value = bufferedReader.readLine()) != null) {   
    104.             set.add(Integer.parseInt(value));   
    105.         }   
    106.         bufferedReader.close();   
    107.         fileReader.close();   
    108.         createFile("c:\\test\\input排序.txt");   
    109.         writeFile("c:\\test\\input排序.txt", set, false);   
    110.     }   
    111.   
    112.     /**  
    113.      * 拆分文件  
    114.      *   
    115.      * @param inputPath  
    116.      * @param numSize  
    117.      * @throws Exception  
    118.      */  
    119.     private static void splitFile(String inputPath, int numSize) throws Exception {   
    120.         File file = new File(inputPath);   
    121.         FileReader fileReader = new FileReader(file);   
    122.         BufferedReader bufferedReader = new BufferedReader(fileReader);   
    123.         SortedSet<Integer> set = new TreeSet<Integer>();   
    124.         String str;   
    125.         createDir("c:\\test\\temp");   
    126.         if (numSize > SPLIT_SIZE) {   
    127.             int count = 1;   
    128.             int fileNum = 1;   
    129.             while ((str = bufferedReader.readLine()) != null) {   
    130.                 set.add(Integer.parseInt(str));   
    131.                 //超过拆分数,写入子文件   
    132.                 if (count >= SPLIT_SIZE) {   
    133.                     createFile("c:\\test\\temp\\" + fileNum + ".txt");   
    134.                     writeFile("c:\\test\\temp\\" + fileNum + ".txt", set, false);   
    135.                     set.clear();   
    136.                     count = 0;   
    137.                     fileNum++;   
    138.                 }   
    139.                 count++;//读取文件当前行数   
    140.             }   
    141.         }   
    142.         //总量未达到拆分数,写入子文件   
    143.         else {   
    144.             while ((str = bufferedReader.readLine()) != null) {   
    145.                 set.add(Integer.parseInt(str));   
    146.             }   
    147.             createFile("c:\\test\\temp\\1.txt");   
    148.             writeFile("c:\\test\\temp\\1.txt", set, false);   
    149.         }   
    150.         if (bufferedReader != null) {   
    151.             bufferedReader.close();   
    152.         }   
    153.         if (fileReader != null) {   
    154.             fileReader.close();   
    155.         }   
    156.     }   
    157.   
    158.     /**  
    159.      * 合并文件  
    160.      *   
    161.      * <p>  
    162.      *    1.txt(1、3、5、7、9)和2.txt(6、8、9)<br/>  
    163.      *    首先1和6进入treeset。 <br/>  
    164.      *    输出1,发现是来自于1.txt的,再读入3,此时set中的元素是6和3。<br/>   
    165.      *    输出3,发现还是来自于1.txt的,再读入5,此时set中的元素是6和5。 <br/>  
    166.      *    输出5,发现还是来自于1.txt的,再读入7,此时set中的元素是6和7。 <br/>  
    167.      *    输出6,发现来自于2.txt的,读入8,此时set中的元素是8和7。 <br/>  
    168.      *    输出7,发现来自于1.txt的,读入9,此时set中的元素是8和9。 <br/>  
    169.      *    输出8,发现来自于2.txt的,读入9,此时set中的元素是9和9。  
    170.      * </p>  
    171.      *   
    172.      * @param splitFilePathList  
    173.      * @param outputPath  
    174.      * @throws Exception  
    175.      */  
    176.     private static void mergeFile(List<String> splitFilePathList, String outputPath)   
    177.                                                                                     throws Exception {   
    178.         //fileInfo添加到set   
    179.         SortedSet<FileInfo> fileInfoSet = new TreeSet<FileInfo>(new FileInfoComparator());   
    180.         if (fileInfoSet.isEmpty()) {   
    181.             for (int i = 0; i < splitFilePathList.size(); i++) {   
    182.                 File file = new File(splitFilePathList.get(i));   
    183.                 FileReader fileReader = new FileReader(file);   
    184.                 BufferedReader bufferedReader = new BufferedReader(fileReader);   
    185.   
    186.                 FileInfo fileInfo = new FileInfo();   
    187.                 String splitFilePath = splitFilePathList.get(i);   
    188.                 fileInfo.setFileNum(Integer.parseInt(splitFilePath.substring(splitFilePath   
    189.                     .lastIndexOf("\\") + 1, splitFilePath.indexOf(".txt"))));//文件号   
    190.                 fileInfo.setReader(bufferedReader);//reader引用   
    191.                 String value = bufferedReader.readLine();   
    192.                 if (value != null) {   
    193.                     fileInfo.setValue(value);//当前值   
    194.                     fileInfo.setLineNum(fileInfo.getLineNum() + 1);//当前行号   
    195.                     fileInfoSet.add(fileInfo);   
    196.                 }   
    197.             }   
    198.         }   
    199.   
    200.         Set<Integer> valueSet = new LinkedHashSet<Integer>();   
    201.         boolean isSplit = false;   
    202.         int count = 1;   
    203.         //输出set元素   
    204.         while (!fileInfoSet.isEmpty()) {   
    205.             FileInfo currentFileInfo = fileInfoSet.first();   
    206.             valueSet.add(Integer.parseInt(currentFileInfo.getValue()));   
    207.             //拆分批量写入文件   
    208.             if (valueSet.size() >= SPLIT_SIZE) {   
    209.                 writeFile(outputPath, valueSet, true);   
    210.                 valueSet.clear();   
    211.                 isSplit = true;   
    212.             }   
    213.   
    214.             //clone fileInfo   
    215.             FileInfo nextFileInfo = new FileInfo();   
    216.             nextFileInfo.setFileNum(currentFileInfo.getFileNum());   
    217.             nextFileInfo.setLineNum(currentFileInfo.getLineNum());   
    218.             nextFileInfo.setValue(currentFileInfo.getValue());   
    219.             nextFileInfo.setReader(currentFileInfo.getReader());   
    220.   
    221.             boolean isSuccess = nextFileInfo.readNextValue();   
    222.   
    223.             //未到文件末尾,set中fileInfo重新排序   
    224.             if (isSuccess) {   
    225.                 if (fileInfoSet.remove(currentFileInfo)) {   
    226.                     fileInfoSet.add(nextFileInfo);   
    227.                 }   
    228.             }   
    229.             //已到文件末尾,从set中移除该fileInfo   
    230.             else {   
    231.                 fileInfoSet.remove(currentFileInfo);   
    232.             }   
    233.   
    234.             System.out.println("----- MergeFile:" + count++ + " -----");   
    235.             System.out.println("fileNum=" + currentFileInfo.getFileNum());   
    236.             System.out.println("lineNum=" + currentFileInfo.getLineNum());   
    237.             System.out.println("value=" + currentFileInfo.getValue());   
    238.             System.out.println("----------------------------");   
    239.         }   
    240.   
    241.         //从未拆分过则一次性写入文件   
    242.         if (valueSet.size() > 0 && valueSet.size() < SPLIT_SIZE && !isSplit) {   
    243.             writeFile(outputPath, valueSet, false);   
    244.         }   
    245.         //曾拆分过剩余部分写入文件   
    246.         else if (valueSet.size() > 0 && valueSet.size() < SPLIT_SIZE && isSplit) {   
    247.             writeFile(outputPath, valueSet, true);   
    248.         }   
    249.     }   
    250.   
    251.     /**  
    252.      * 生成随机数  
    253.      *   
    254.      * @param numSize  
    255.      * @return  
    256.      * @throws Exception  
    257.      */  
    258.     private static int createRandomNum(long numSize) throws Exception {   
    259.         Set<Integer> set = new LinkedHashSet<Integer>();   
    260.         int count = 0;   
    261.         boolean isSplit = false;   
    262.         while (count < numSize) {   
    263.             int num = (int) (Math.random() * numSize + 1);   
    264.             if (set.add(num)) {   
    265.                 count++;   
    266.             }   
    267.             //拆分批量写入文件   
    268.             if (set.size() >= SPLIT_SIZE) {   
    269.                 writeFile(INPUT_FILE, set, true);   
    270.                 set.clear();   
    271.                 isSplit = true;   
    272.             }   
    273.         }   
    274.   
    275.         //从未拆分过则一次写入文件   
    276.         if (set.size() > 0 && set.size() < SPLIT_SIZE && !isSplit) {   
    277.             writeFile(INPUT_FILE, set, false);   
    278.         }   
    279.         //曾拆分过剩余部分写入文件   
    280.         else if (set.size() > 0 && set.size() < SPLIT_SIZE && isSplit) {   
    281.             writeFile(INPUT_FILE, set, true);   
    282.         }   
    283.         return count;   
    284.     }   
    285.   
    286.     private static void createDir(String dirPath) {   
    287.         File dir = new File(dirPath);   
    288.         if (!dir.exists()) {   
    289.             if (dir.mkdir()) {   
    290.                 System.out.println(dir.getName() + " is create.");   
    291.             }   
    292.         }   
    293.     }   
    294.   
    295.     private static void createFile(String path) throws Exception {   
    296.         File file = new File(path);   
    297.         if (!file.exists()) {   
    298.             if (file.createNewFile()) {   
    299.                 System.out.println(file.getName() + " is create.");   
    300.             }   
    301.         }   
    302.     }   
    303.   
    304.     private static void writeFile(String path, Set<Integer> set, boolean isAppend) throws Exception {   
    305.         File file = new File(path);   
    306.         FileWriter fileWriter = new FileWriter(file, isAppend);// 第二个参数表示:是否为追加模   
    307.         BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);   
    308.         Iterator<Integer> iterator = set.iterator();   
    309.         while (iterator.hasNext()) {   
    310.             bufferedWriter.write(iterator.next().toString());   
    311.             bufferedWriter.newLine();   
    312.         }   
    313.         bufferedWriter.flush();   
    314.         if (bufferedWriter != null) {   
    315.             bufferedWriter.close();   
    316.         }   
    317.         if (fileWriter != null) {   
    318.             fileWriter.close();   
    319.         }   
    320.     }   
    321. }  
    1. package merge;   
    2.   
    3. import java.io.BufferedReader;   
    4.   
    5. /**  
    6.  *   
    7.  * 文件信息  
    8.  *   
    9.  * @author jia.hej  
    10.  *  
    11.  * @version $Id: FileInfo.java, v 0.1 2009-8-1 上午02:11:30 jia.hej Exp $  
    12.  */  
    13. public class FileInfo {   
    14.   
    15.     /**  
    16.      * 文件号  
    17.      */  
    18.     private int            fileNum;   
    19.   
    20.     /**  
    21.      * 当前行号  
    22.      */  
    23.     private int            lineNum = 0;   
    24.   
    25.     /**  
    26.      * 当前值  
    27.      */  
    28.     private String         value;   
    29.   
    30.     /**  
    31.      * BufferedReader引用  
    32.      */  
    33.     private BufferedReader reader;   
    34.   
    35.     public boolean readNextValue() throws Exception {   
    36.         String value;   
    37.         if ((value = this.reader.readLine()) != null) {   
    38.             this.value = value;   
    39.             this.lineNum++;   
    40.             return true;   
    41.         } else {   
    42.             this.reader.close();   
    43.             return false;   
    44.         }   
    45.     }   
    46.   
    47.     public int getFileNum() {   
    48.         return fileNum;   
    49.     }   
    50.   
    51.     public void setFileNum(int fileNum) {   
    52.         this.fileNum = fileNum;   
    53.     }   
    54.   
    55.     public int getLineNum() {   
    56.         return lineNum;   
    57.     }   
    58.   
    59.     public void setLineNum(int lineNum) {   
    60.         this.lineNum = lineNum;   
    61.     }   
    62.   
    63.     public String getValue() {   
    64.         return value;   
    65.     }   
    66.   
    67.     public void setValue(String value) {   
    68.         this.value = value;   
    69.     }   
    70.   
    71.     public BufferedReader getReader() {   
    72.         return reader;   
    73.     }   
    74.   
    75.     public void setReader(BufferedReader reader) {   
    76.         this.reader = reader;   
    77.     }   
    78. }  

     

    1. package merge;   
    2.   
    3. import java.util.Comparator;   
    4.   
    5. /**  
    6.  *   
    7.  * 文件比较器  
    8.  *   
    9.  * @author jia.hej  
    10.  *  
    11.  * @version $Id: FileInfoComparator.java, v 0.1 2009-8-7 下午01:42:05 jia.hej Exp $  
    12.  */  
    13. public class FileInfoComparator implements Comparator<FileInfo> {   
    14.   
    15.     public int compare(FileInfo o1, FileInfo o2) {   
    16.         if (Integer.parseInt(o1.getValue()) != Integer.parseInt(o2.getValue())) {   
    17.             return Integer.parseInt(o1.getValue()) - Integer.parseInt(o2.getValue());   
    18.         }   
    19.         //如果存在重复值则使用文件号比较   
    20.         else {   
    21.             return o1.getFileNum() - o2.getFileNum();   
    22.         }   
    23.     }   
    24.   
    25. }  

     

     

    展开全文
  • import java.io.File; import java.util.Collections; import java.util.Comparator; import java.util.List; public class Demo13 {  public static void main(String[] args) {  List&lt;File&gt; li.....
    
    import java.io.File;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class Demo13 {
        public static void main(String[] args) {
            List<File> list = FileUtils.getAllFiles("D:/IOTest/");
            // 按文件夹先显示的顺序:
            Collections.sort(list, new Comparator<File>() {
                @Override
                public int compare(File o1, File o2) {
                    return (o1.isDirectory() ? 1 : -1)-(o2.isDirectory() ? 1 : -1);
                }
    
            });
            // 按文件名称显示的顺序:
            Collections.sort(list, new Comparator<File>() {
                @Override
                public int compare(File o1, File o2) {
                    return (o1.getName()).compareTo(o2.getName());
                }
            });
    
            // 按文件大小的顺序:
            Collections.sort(list, new Comparator<File>() {
                @Override
                public int compare(File o1, File o2) {
                    return (int) (o1.length() - o2.length());
                }
            });
    
            for (File file : list) {
                System.out.println(file.getName());
            }
    
        }
    }
    

     

    展开全文
  • * java编程题:用Java实现一个快速排序算法 * * 快速排序是对冒泡排序的一种改进。 * * 快速排序的基本思想: * 通过一趟排序将要排序的数据分成独立的两部分,其中一部分的所有数据(左边的数据)都比 *...
  • java遍历文件目录排序

    千次阅读 2016-05-04 14:52:38
    List<File> files = Arrays.asList(new File("文件目录").listFiles()); Collections.sort(files, new Comparator(){ public int compare(File o1, File o2) { if(o1.isDirectory() && o2.isFile()) ...
  • java目录文件按日期排序

    千次阅读 2013-07-12 16:58:48
    java 的jdk里的File类没有提供按日期或大小排序来取的目录文件列表的功能. 所以只能自己写一个了.简单实现. 以下是代码: import java.io.File; import java.util.Arrays; import java.util.Comparator; ...
  • public int compare(Object o1, Object o2) { File file1 = (File)o1; File file2 = (File)o2; long diff = file1.lastModified() - file2.lastModified(); if (diff > 0)
  • Java实现按中文名称排序

    千次阅读 2018-07-26 13:53:44
    //定义排序函数 public static String[] getSortOfChinese(String[] a) { // Collator 类是用来... Comparator cmp = Collator.getInstance(java.util.Locale.CHINA); // JDKz自带对数组进行排序。 Arrays.sort(a...
  • 在日常的工作,经常遇到对文件的批量读取,如果批量文件的读取顺序对最后的结果又影响,就涉及到如何排列...在文件的排列,如何保证key不重复是一个难点, Long tempLong = new Long(subFile[i].lastModified());
  • package test;/** * Created by mff on 2017/10/26. */import java.io.File; import java.util.ArrayList; public class ListAllFile ... //用于判断目录文件所在的层次 public static int time; //递归方法 p
  • 做这个java小程序1: (1)有1000多个文件,十六亿行,每行一个字符串 (2)字符串字典排序,重复的行要去掉 (3)输出一个排序好的大文件
  • java文件大小、名称、日期排序方法 //按照文件大小排序 public static void orderByLength(String fliePath) { List files = Arrays.asList(new File(fliePath).listFiles()); Collections.sort(files, new ...
  • Java实现插入排序

    万次阅读 多人点赞 2019-07-20 21:37:26
    要求在这个已经排好的数据序列插入一个数,但要求插入后此数据序列仍然有序,这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据,从而得到一个新的...
  • 一个程序,分析一个文本文件(英文文本)各个词出现的频率,并且把频率最高的10个词打印出来。 解决步骤: 1. 读取 txt 文本文件; 2. 统计文本每个词出现的次数; 3. 进行排序,打印频率最高的10个...
  • JAVA里怎样对指定目录文件按文件名排序一个简单的例子说明怎样对指定目录文件按文件名排序。 <br />代码 FileUtil.javapublic class FileUtil {  //for test  public static void main...
  • java实现日期排序问题

    千次阅读 2017-09-28 15:19:29
    一个文件中记录着一个2008年一个日期或一段日期: 6月3日 5月9日 9月6日 3月2日-4月8日 …… 设计一个算法使得让这些数据按时间数序排序,并且统计总天数(可以用C、Java或文字描述)方法: 把每个...
  • java实现文件的重命名

    千次阅读 2019-01-17 14:15:58
    使用java i/o流读取文件夹的所有的文件,并实现按照指定的规则进行重命名 1.直接建一个util类,来进行创建两个重命名的方法: package reName; import java.io.File; public class util { /** * 用于将文件名...
  • Java实现十大排序算法

    千次阅读 多人点赞 2019-12-04 16:35:23
    上篇博文我们用C++实现了十大排序算法 ...冒泡排序无疑是最为出名的排序算法之,从序列的一端开始往另一端冒泡(你可以从左往右冒泡,也可以从右往左冒泡,看心情),依次比较相邻的两数的大小(到...
  • 有时候别人要找我们要什么资源,我们一个个看好麻烦呀,我那天找同学要电子书,然后他就编程遍历之后发了个书单给我,我觉得这技能很实用,今天就小试牛刀,班门弄斧啦!! package test; import java.io.File; ...
  • Flink使用java实现读取csv文件简单实例首先我们来看官方文档给出的几种方法: 首先我们来看官方文档给出的几种方法: 第种: DataSet<Tuple3<Integer, String, Double>> csvInput = env.readCsv...
  • Java实现希尔排序

    千次阅读 2013-02-17 23:00:15
    为了做实验,生成一个长度为 0x400000(该数字为16进制)随机的整形数组,存放于硬盘上的文本文件内。每次排序均将此数组读入内存后,再排序,再将排序结果写入硬盘文件。只对排序操作计时,读文件和写文件不计时。...
  • 文件1test.txt: 2013-01-03 c 2013-01-03 c 2013-01-03 a 2013-01-04 b 2013-01-05 e 2013-01-06 f 文件2insert.txt: 2013-01-02 a 2013-01-03 a 2013-01-03 c 2013-01-04 b 2013-01-05 d 2013-01-04
  • 十大经典排序算法总结(Java实现+动画)

    万次阅读 多人点赞 2019-06-19 16:26:29
    最近在梳理《数据结构与算法》的内容,在网上看了几篇不错的文章,现在根据自己的理解重新整理一下十大经典排序算法。实际生产,最好的算法一定是结合数据集本身的特点(大小,长度,是否已经基本有序等等)来选择...
  • 一个文本文件中的字符串排序后输出到另一个文本文件中 * 已知s.txt文件中有这样的一个字符串:“hcexfgijkamdnoqrzstuvwybpl” * 请编写程序读取数据内容,把数据排序后写入ss.txt。 * * 分析: * A:把s.txt...
  • Java: 文件排序

    千次阅读 2011-06-16 18:52:00
    文件夹放前面,文件放后面,文件夹及文件之间根据名字排序:  Collections.sort(list, new Comparator>() { public int compare(Map object1, Map object2) { File file1 = new File((String

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 267,741
精华内容 107,096
关键字:

java实现一个文件目录中文件排序

java 订阅