正则表达式模式与目录中的文件名不匹配

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

正则表达式电路

jex.im 可视化正则表达式：

---

如果您希望简化/修改/探索表达式，在regex101.com 的右上角面板中已对此进行了说明。如果您愿意，您还可以在 this link 中观看它如何与一些示例输入匹配。

---