批量 多次 正则 替换 java

commons-io用于读写文件FileUtils.writeStringToFile，如果自己写可以不用该依赖

1.读取规则

2.依次执行替换

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.7</version>
        </dependency>

 

package demo.tools;


import org.apache.commons.io.FileUtils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class FileTools {

    public static final String KEY = "k";
    public static final String VALUE = "v";
    public static final String POINT = ".";
    public static final String UNDER_LINE = "_";
    public static final String CODE = "UTF-8";
    public static final String FLAG = "f";
    public static final String TIME = "t";
    public static final int DEFAULT_FLAG = Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL;
    public static final int DEFAULT_TIME = 1;


    public static void main(String[] args) throws Exception {
        String rules = "rules.properties";
        String file = "db.sql";
        replace(file, rules);

    }

    public static void replace(String file, String rules) throws Exception {
        // 读取规则
        Map<String, String> map = new HashMap<>();
        List<String> keyList = new ArrayList();
        BufferedReader reader = new BufferedReader(new FileReader(rules));
        // properties 文件有空格问题，值前后空格强制去掉，所有不用load加载
        String line = null;
        int index = 0;
        while ((line = reader.readLine()) != null) {
            if (line.trim().equals("") || line.trim().startsWith("#")) {
                continue;
            }

            index = line.indexOf("=");
            String key = line.substring(0, index);
            map.put(key, line.substring(index + 1));

            if (key.startsWith(KEY)) {
                keyList.add(key);
            }
        }
        reader.close();
        // 规则排序
        List<String> sortedList = keyList.stream().sorted((a, b)->{
            double va = Double.parseDouble(a.replaceAll(KEY, ""));
            double vb = Double.parseDouble(b.replaceAll(KEY, ""));
            if (va > vb) {
                return 1;
            } else if (va < vb) {
                return -1;
            }
            return 0;
        }).collect(Collectors.toList());

        // 替换
        File sql = new File(file);
        String s = FileUtils.readFileToString(sql, CODE);
        StringBuilder c = new StringBuilder(s);
        sortedList.forEach(k -> {
            String f = map.get(k.replace(KEY, FLAG));
            int flag = DEFAULT_FLAG;
            if (f != null && f.trim().length() > 0) {
                flag = Integer.parseInt(f.trim());
            }
            int time = DEFAULT_TIME;
            String t = map.get(k.replace(KEY, TIME));
            if (t != null && t.trim().length() > 0) {
                time = Integer.parseInt(t.trim());
            }
            // 连续替换多次
            for (int i = 0; i < time; i++) {
                String tem = Pattern.compile(map.get(k), flag)
                        .matcher(c.toString())
                        .replaceAll(map.get(k.replace(KEY, VALUE)));
                c.setLength(0);
                c.append(tem);
            }
        });

        // 写文件
        String path = sql.getAbsolutePath();
        int pos = path.lastIndexOf(POINT);
        path = path.substring(0, pos) + UNDER_LINE + path.substring(pos);
        FileUtils.writeStringToFile(new File(path), c.toString(), CODE);
        System.out.println(c);
    }
}

rules.properties

# k=regex,v=replacement,f=替换标记(2-忽略大小写|8-多行|16-字面不转义|32-.匹配换行，这些值可以下相加，默认是42)
# t=连续执行次数
k1=db_crn
v1=db_xgfe_cm

k2= VARCHAR((\r?\n)| |,|\()
v2= varchar$1
k2.1= int((\r?\n)| |,)
v2.1= int$1

k3=^ 
v3=
k4=\[|\]
v4=
k5= +
v5= 
k6=create +Table +(.*)
v6=$1
f6=10

k7= ?\. ?
v7=.
f7=

k7.1=\((.*)\)
v7.1= $1
f7.1=2


k8=\(|\)
v8=

k9=go
v9=

k9.1=^ 
v9.1=

k10=(\r?\n)+
v10=$1
f10=


k100=,
v100=
f100=

k500= +
v500=
t500=2