Шаблон регулярного выражения не совпадает с именами файлов внутри каталогов

Question

Я разрабатываю этот код для того, чтобы проанализировать имя файла изображений внутри каталога, есть два типа файлов, фотографий и изображений, поэтому у каждого был свой шаблон имени файла, поэтому я предложил этот подход, заглянув внутрь папок и получивсписок всех изображений (фотографий и изображений) и затем сопоставьте правильный шаблон, чтобы получить значения.

Проблема в том, что шаблоны регулярных выражений не соответствуют именам файлов, я уже проверяю синтаксис и шаблон, используя эту ссылку https://regex101.com/r/cvuEfR/3, чтобы проверить их.

Так что яЯ думаю, что проблема в другом, но я не понимаю.

Структура файла и файлы выглядят следующим образом

resource_files
  |_Photos
    |_1
      RD1500-0001-1-P.JPG
      RD1500-0001-2-P.JPG
    |_2
      RD1500-0002-1-P.JPG
      RD1500-0002-2-P.JPG
  |_Images
    |_1
      |_extL       
        R0001A+01.01B+01-extL.JPG
        R0001A+01.10B+82-extL.JPG
    |_1
      |_extR       
        R0002A+10.10B+23-extL.JPG
        R0002A+01.10B+06-extL.JPG

Я анализирую значения для фотографий следующим образом

RD1500-0001-1-P.JPG
1500
0001
1
P

и для изображений:

R0002A+10.10B+23-extL.JPG
0002
10.10
23
extL

public class ImageNameParser implements IImageNameProcessor {

    private static final String PHOTO_PATTERN="([A-Za-z0-9]+)-(\\d\\d\\d\\d)-(\\d)-([A-Za-z]+)";
    private Pattern photoPattern = Pattern.compile(PHOTO_PATTERN);

    private static final String IMAGE_PATTERN="([A-Za-z0-9]+)(\\d\\d\\d\\d)([A-Za-z0-9]+)[\\+](\\d\\d.\\d\\d)([A-Za-z0-9]+)[\\+](\\d\\d)-([A-Za-z0-9]+)";
    private Pattern imagePattern = Pattern.compile(IMAGE_PATTERN);

    private ImageHierarchy extractType1Info(File imageFile,String tag,String group) throws Exception {

        if (imageFile!=null && imageFile.isFile()) {
            Matcher m = imagePattern.matcher(imageFile.getName());
            if (m.find()) {

                /*    m.group(1) - 
                      m.group(2) - SubGroup
                          m.group(3) - 
                      m.group(4) - ValueA
                      m.group(5) -                    
                                      m.group(6) - ValueB
                      m.group(7) - SubType  
                 */
                ImageHierarchy imageData = new ImageHierarchy(imageFile.getName(), imageFile.getAbsolutePath(), m.group(2), tag, group);
                imageData.addImageParameters(m.group(4), m.group(6),m.group(7), null, null);
                return imageData;

            } else {
                return null;
            }

        } else {
            return null;
        }
    }

    private ImageHierarchy extractType2Info(File imageFile,String tag,String group) {

        if (imageFile!=null && imageFile.isFile()) {

            Matcher patternMatcher = photoPattern.matcher(imageFile.getName());

            if (patternMatcher.find()) {
                /*
                     patternMatcher.group(1) - Group
                     patternMatcher.group(2) - SubGroup
                     patternMatcher.group(3) - SequenceNumber
                     patternMatcher.group(4) - PhotoAtribute
                 */

                ImageHierarchy imageData = new ImageHierarchy(imageFile.getName(), imageFile.getAbsolutePath(), patternMatcher.group(2), tag, patternMatcher.group(1));
                imageData.addImageParameters(null, null,null, patternMatcher.group(3), patternMatcher.group(4));
                return imageData;
            } 
        } 
        return null;
    }

    private File[] getFiles(File folder ,String group, String tag){

        ArrayList<File> fileList= new ArrayList<File>();

        if(folder!=null)
        {
            ArrayList<File> directories = new ArrayList<File>();
            directories.add(folder);

            while(!directories.isEmpty() && (folder = directories.remove(0))!=null) {
                File[] listOfFiles = folder.listFiles();
                if(listOfFiles!=null)
                {
                    for ( File file : listOfFiles) {
                        if(file.isFile()){

                            if((group!=null && file.getName().contains(group)) || (tag!=null && file.getName().contains(tag))){
                                System.out.println(file.getName());
                                fileList.add(file);
                            }

                        } else if(file.isDirectory()){
                            directories.add(file);                   
                        }
                    }
                }

            }
        }
        return fileList.toArray(new File[]{});

    }

    public ProcessedImages process(File folder ,String group,String tag) throws Exception{

        ImageHierarchy imageInfo = null;

        ProcessedImages collection = new ProcessedImages();
        File[] imageFiles = getFiles(folder, group, tag);
        for (File imageFile : imageFiles) {
            imageInfo = extractType1Info(imageFile, tag, group);
            if(imageInfo!=null)
            {
                collection.AddImage(imageInfo);
            }
            else
            {
                imageInfo = extractType2Info(imageFile,tag, group);
                if(imageInfo!=null)
                {
                    collection.AddImage(imageInfo);
                }
            }

        }
        return collection;
    }


}

Answer 1

Я предполагаю, что, возможно, вы пытаетесь написать какое-то выражение с опциями, например:

^[A-Za-z]{1,2}(\d{4})[A-Z]?([+-]\d{2}\.?\d{2})[A-Z]?([+-][0-9]+)-([A-Za-z]+)

или, возможно, нет, я не уверен.

Тест

import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class re{

    public static void main(String[] args){

        final String regex = "^[A-Za-z]{1,2}(\\d{4})[A-Z]?([+-]\\d{2}\\.?\\d{2})[A-Z]?([+-][0-9]+)-([A-Za-z]+)";
        final String string = "A0001L+23.20K+01-Red.JPG\n"
             + "R0002A+10.10B+23-extL.JPG\n"
             + "RD1500-0001-1-P.JPG";

        final Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE);
        final Matcher matcher = pattern.matcher(string);

        while (matcher.find()) {
            System.out.println("Full match: " + matcher.group(0));
            for (int i = 1; i <= matcher.groupCount(); i++) {
                System.out.println("Group " + i + ": " + matcher.group(i));
            }
        }


    }
}

Выход

Full match: A0001L+23.20K+01-Red
Group 1: 0001
Group 2: +23.20
Group 3: +01
Group 4: Red
Full match: R0002A+10.10B+23-extL
Group 1: 0002
Group 2: +10.10
Group 3: +23
Group 4: extL
Full match: RD1500-0001-1-P
Group 1: 1500
Group 2: -0001
Group 3: -1
Group 4: P

Схема RegEx

jex.im визуализирует регулярные выражения:

---

Если вы хотите упростить / изменить / изучить выражение, это объяснено на верхней правой панели regex101.com .Если хотите, вы также можете посмотреть в этой ссылке , как она будет сопоставляться с некоторыми примерами ввода.

---