कैसे वर्णानुक्रम में File.listFiles करने के लिए?

Question

मुझे नीचे जैसा कोड मिला है:

class ListPageXMLFiles implements FileFilter {

        @Override
        public boolean accept(File pathname) {
                DebugLog.i("ListPageXMLFiles", "pathname is " + pathname);

                String regex = ".*page_\\d{2}\\.xml";
                if(pathname.getAbsolutePath().matches(regex)) {
                        return true;
                }
                return false;
        }
}

public void loadPageTrees(String xml_dir_path) {
        ListPageXMLFiles filter_xml_files = new ListPageXMLFiles();
        File XMLDirectory = new File(xml_dir_path);
        for(File _xml_file : XMLDirectory.listFiles(filter_xml_files)) {
                loadPageTree(_xml_file);
        }
}

यह FileFilterअच्छी तरह से काम कर रहा है, लेकिन listFiles()रिवर्स वर्णमाला क्रम में फ़ाइलों को सूचीबद्ध करता प्रतीत होता है। क्या listFile()वर्णमाला क्रम में फ़ाइलों को सूचीबद्ध करने के लिए कहने का कुछ त्वरित तरीका है ?

Comments

रेगेक्स का उपयोग करने के .endsWith(".xml")बजाय , उपयोग करें ।

— फ्रेड

Answer 1

listFilesविधि के साथ या एक फिल्टर के बिना किसी भी आदेश की गारंटी नहीं है।

हालाँकि, यह एक सरणी लौटाता है, जिसे आप क्रमबद्ध कर सकते हैं Arrays.sort()।

File[] files = XMLDirectory.listFiles(filter_xml_files);
Arrays.sort(files);
for(File _xml_file : files) {
    ...
}

यह काम करता है क्योंकि Fileएक तुलनीय वर्ग है, जो डिफ़ॉल्ट रूप से लेक्सिकोग्राफिक रूप से पथप्रदर्शन करता है। यदि आप उन्हें अलग तरह से क्रमबद्ध करना चाहते हैं, तो आप अपने स्वयं के तुलनित्र को परिभाषित कर सकते हैं।

यदि आप धाराओं का उपयोग करना पसंद करते हैं:

अधिक आधुनिक दृष्टिकोण निम्नलिखित है। किसी दिए गए निर्देशिका में सभी फाइलों के नामों को मुद्रित करने के लिए, वर्णमाला क्रम में, करें:

Files.list(Paths.get(dirName)).sorted().forEach(System.out::println)

System.out::printlnफ़ाइल नामों के साथ आप जो कुछ भी करना चाहते हैं उसे बदलें । यदि आप केवल फ़ाइल नाम चाहते हैं, जो कि "xml"केवल करते हैं:

Files.list(Paths.get(dirName))
    .filter(s -> s.toString().endsWith(".xml"))
    .sorted()
    .forEach(System.out::println)

फिर से, मुद्रण को जो भी आप चाहते हैं प्रसंस्करण प्रक्रिया के साथ बदलें।

Comments

यह कोड की एक सुंदर रेखा है, लेकिन एक Iterable के बजाय Arrays.sort () शून्य लौटती है। मैं थोड़ा इधर-उधर करूँगा।

— थंडर रैबिट

@ तूफ़ान खरगोश, मेरी माफ़ी !! क्षमा करें, आप सही हैं। मुझे इसका परीक्षण करना चाहिए था। मैंने अपना उत्तर संपादित किया।

— रे तोल

यह विंडोज में ठीक काम कर रहा है, लेकिन उबंटू फ़ोल्डरों में बड़े अक्षरों के साथ बाकी की तुलना में पहले दिखाई देते हैं।

— jmhostalet

इस तरह से मुझे उम्मीद है कि यह काम करेगा। यूनिकोड में कम अक्षरों से पहले कैपिटल लेटर आते हैं। यूनिक्स में केस-संवेदी फ़ाइलनाम हैं, इसलिए पहले बड़े अक्षर आते हैं। यदि आप विंडोज पर केस-इनसेंसिटिव फाइलनाम का उपयोग कर रहे हैं, तो राजधानियों और लोअरकेस नामों को एक साथ मिलाया जाएगा। यह पूरी तरह से उम्मीद के मुताबिक है। यदि आप एक यूनिक्स पर विंडोज तरीका चाहते हैं, तो एक तुलनित्र को आपूर्ति करें sort।

— रे टोल

Answer 2

मुझे लगता है कि पिछला जवाब यह करने का सबसे अच्छा तरीका है कि यहां एक और सरल तरीका है। बस हल किए गए परिणामों को प्रिंट करने के लिए।

 String path="/tmp";
 String[] dirListing = null;
 File dir = new File(path);
 dirListing = dir.list();
 Arrays.sort(dirListing);
 System.out.println(Arrays.deepToString(dirListing));

Comments

क्या आप कृपया टिप्पणी प्रदान करेंगे कि आपको क्यों लगता है कि यह एक सही उत्तर नहीं है। इसलिए, मैं इसे अपने अनुसार संशोधित कर सकता हूं।

— grepit

-1 मैं फ़ाइल सरणी को स्ट्रिंग सरणी में बदलने के लाभ को वास्तव में नहीं समझता और फिर फ़ाइल सरणी को केवल सॉर्ट करने के बजाय सॉर्ट करता हूं जैसा कि स्वीकृत उत्तर करता है।

— zelanix

@zelanix प्रतिक्रिया प्रदान करने के लिए धन्यवाद। मेरे पास सभी उत्तर नहीं हैं और मैं कभी-कभी प्रश्नों का उत्तर देने में गलती करता हूं। मैंने जवाब अपडेट कर दिया है, क्या आप इसकी समीक्षा करेंगे और देखेंगे कि क्या यह एक बेहतर समाधान है। यदि आप अपने वोट पर पुनर्विचार कर सकते हैं तो मैं इसकी सराहना करूंगा। अग्रिम में धन्यवाद।

— grepit

ठीक है, अब आप सही ठहराते हैं कि यह सरल क्यों है यदि आप केवल परिणाम प्रिंट करना चाहते हैं तो मैं अपने डाउनवोट को हटा दूंगा।

— zelanix

@ CPU100 का मानना ​​है कि listFiles () के बजाय लिस्ट () का उपयोग करने से पैरेंट डायरेक्टरी पाथ्स के बिना केवल फाइल के नाम होने का फायदा मिलता है, जिसके परिणामस्वरूप कम स्ट्रिंग्स और कम सीपीयू समय सॉर्ट / तुलना करने के लिए होता है।

— दिलजीत

Answer 3

जावा 8 में:

Arrays.sort(files, (a, b) -> a.getName().compareTo(b.getName()));

उल्टे क्रम:

Arrays.sort(files, (a, b) -> -a.getName().compareTo(b.getName()));

Comments

आप इस कोड का भी उपयोग कर सकते हैं:Arrays.sort(fList, Comparator.comparing(File::getName));

— plaidshirt

इससे सावधान रहें। यह कोड गैर-निर्धारक है और इसका उपयोग नहीं किया जाना चाहिए।

— टोनी श्वार्ट्ज

Answer 4

यह मेरा कोड है:

        try {
            String folderPath = "../" + filePath.trim() + "/";
            logger.info("Path: " + folderPath);
            File folder = new File(folderPath);
            File[] listOfFiles = folder.listFiles();
            int length = listOfFiles.length;
            logger.info("So luong files: " + length);
            ArrayList<CdrFileBO> lstFile = new ArrayList< CdrFileBO>();

            if (listOfFiles != null && length > 0) {
                int count = 0;
                for (int i = 0; i < length; i++) {
                    if (listOfFiles[i].isFile()) {
                        lstFile.add(new CdrFileBO(listOfFiles[i]));
                    }
                }
                Collections.sort(lstFile);
                for (CdrFileBO bo : lstFile) {
                    //String newName = START_NAME + "_" + getSeq(SEQ_START) + "_" + DateSTR + ".s";
                    String newName = START_NAME + DateSTR + getSeq(SEQ_START) + ".DAT";
                    SEQ_START = SEQ_START + 1;
                    bo.getFile().renameTo(new File(folderPath + newName));
                    logger.info("newName: " + newName);
                    logger.info("Next file: " + getSeq(SEQ_START));
                }

            }
        } catch (Exception ex) {
            logger.error(ex);
            ex.printStackTrace();
        }