java小工具：通过方法体内变更代码向上找方法调用链【完善中】

package com.test.springboot.springboot_first.sec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import ch.qos.logback.core.net.SyslogOutputStream;

public class GetApiTest implements GetUrl {
    List list = new ArrayList();
    List list_filter = new ArrayList();
    List list_matched = new ArrayList();
    Integer ct = 0;
    String pth = "";

    @Override
    public void getUrl() {

    }

    
    public void getJavas(File dir) {
        File[] files = dir.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                getJavas(file);
            } else {
                if ((file + "").contains(".java")) {
                    list.add(file + "");
                }
            }
        }
    }

    
    
    public List getList(File dir) {
        getJavas(dir);
        return list;
    }

    public String txt2String(String path) {
        String fileContent = "";
        try {
            final File f = new File(path);
            if (f.isFile() && f.exists()) {
                final InputStreamReader read = new InputStreamReader(new FileInputStream(f), "utf-8");
                final BufferedReader reader = new BufferedReader(read);
                String line;
                while ((line = reader.readLine()) != null) {
                    fileContent += line;
                }
                read.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return fileContent;
    }

    
    public List getKeyWordMatchJavs(String kd) {
        if (!kd.contains("|")) {
            kd = kd + "|";
        }
        String[] st = kd.split("\|");
        for (String pa : list) {
            String mm = txt2String(pa);
            if (st.length == 1 && mm.contains(st[0].toString())) {
                // System.out.println(pa);
                list_filter.add(pa);
            }

        }
        return list_filter;

    }

    
    
    
    public List getKeyWordMatchJavs2(String kd, List lig) {
        if (!kd.contains("|")) {
            kd = kd + "|";
        }
        String[] st = kd.split("\|");
        for (String pa : list) {
            String mm = txt2String(pa);
            if (st.length == 1 && mm.contains(st[0].toString())) {
                lig.add(pa);
            }

        }
        return lig;

    }

    
    public List delLastElem(List lt) {
        List ltr = new ArrayList();
        for (int i = 0; i < lt.size() - 1; i++) {
            ltr.add(lt.get(i));
        }
        return ltr;
    }

    
    public List transFormA2L(String[] sg) {
        List li = new ArrayList();
        for (String s : sg) {
            li.add(s);
        }
        return li;
    }

    
    public String mergeList2String(List lsg, String sep) {
        String ms = "";
        for (String s : lsg) {
            ms = ms + s + sep;
        }

        return ms.substring(0, ms.length() - 1);
    }

    public List getIndexOf(String inputStr, String pattern, Integer total, Integer delta) {
        Matcher matcher = Pattern.compile(pattern).matcher(inputStr);
        if (matcher.find()) {
            list_matched.add((matcher.start() + delta) + "|" + (matcher.end() + delta));
            ct = matcher.end() + delta;
            if (ct < total) {
                inputStr = inputStr.substring(ct - delta, total - delta);
                getIndexOf(inputStr, pattern, total, (matcher.end() + delta));
            }
        }
        return list_matched;
    }

    public String remAllCtrls(String mstr) {
        return mstr.replaceAll("t", " ").replace("n", " ").replaceAll("r", " ").replaceAll(" +", " ").trim();
    }

    
    public List getNearestPs(List mt, List source) {
        HashMap hp = new HashMap<>();
        for (String s : mt) {
            Integer container = 1000000000;
            for (String t : source) {
                Integer dt = Integer.parseInt(s.split("\|")[0]) - Integer.parseInt(t.split("\|")[0]);
                if (dt > 0 && dt < container) {
                    container = dt;
                }

            }
            hp.put(s, "" + container);
        }
        Iterator> nt = hp.entrySet().iterator();
        List st = new ArrayList();
        while (nt.hasNext()) {
            Map.Entry entry = nt.next();
            st.add(entry.getKey() + "=" + entry.getValue());
        }
        return st;
    }

    
    public static String watchMathedParts(String ct, List lt) {

        return null;
    }

    
    public String getClassName(String pth) {
        return pth.split("\\")[pth.split("\\").length - 1].split("\.")[0];
    }

    
    public void handleMap(HashMap> kk, String pa) {
        HashMap> hp = new HashMap>();
        for (String key : kk.keySet()) {
            List list4 = new ArrayList();
            for (String s : kk.get(key)) {
                String cts = new GetApiTest().remAllCtrls(new GetApiTest().txt2String(s));
                String pdns = "(new){0,}[\s]{0,}" + key.split("\|")[3]
                        + "[\s]{0,}((\()[\s]{0,}[^)]{0,}[\s]{0,}(\))[\s]{0,}){0,1}.[\s]{0,}"
                        + key.split("\|")[0] + "[\s]{0,}(\()[\s]{0,}[^)]{0,}[\s]{0,}(\))";
                System.out.println("mmmm"+pdns);
                Integer totals = cts.length();
                List strss = new GetApiTest().getIndexOf(cts, pdns, cts.length(), 0);
                List strss_ft = new ArrayList();
                for (String ss : strss) {
                    String rString = cts.substring(Integer.parseInt(ss.split("\|")[0]),
                            Integer.parseInt(ss.split("\|")[1]));
                    String tpString = key.split("\|")[1];
                    if (Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(tpString).find() == true
                            && Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(rString).find() == true) {
                        strss_ft.add(ss);

                    }
                    if (tpString.split(",").length == rString.split(",").length
                            && Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(tpString).find() == false
                            && Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(rString).find() == false) {
                        strss_ft.add(ss);
                    }
                    String tps_match = "new[\s]{0,}" + key.split("\|")[3]
                            + "[\s]{0,}((\()[\s]{0,}[^)]{0,}[\s]{0,}(\))[\s]{0,}){0,1}.[\s]{0,}"
                            + key.split("\|")[0] + "[\s]{0,}(\()[\s]{0,}[^)]{0,}[\s]{0,}(\))";
                    Matcher tps = Pattern.compile(tps_match).matcher(rString);

                    if (tps.find() == true) {
//                        System.out.println("new: "+cts);
                        String after_p = tps.group().split("\." + key.split("\|")[0])[1];

                        if (Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(tpString).find() == true
                                && Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(after_p).find() == true) {
                            strss_ft.add(ss);

                        }
                        if (tpString.split(",").length == after_p.split(",").length

                                && Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(tpString).find() == false
                                && Pattern.compile("\s{0,}(\()\s{0,}(\))\s{0,}").matcher(after_p)
                                        .find() == false) {
                            strss_ft.add(ss);
                        }
                    }
                    if(cts.contains("test_8888")){
                    System.out.println("rstring is: "+rString);
                    System.out.println("ppp: "+"ma(\.)"+ key.split("\|")[0]+ "[\s]{0,}(\()[\s]{0,}[^)]{0,}[\s]{0,}(\))");}
                    if(Pattern.compile("ma(\.)"+ key.split("\|")[0]+ "[\s]{0,}(\()[\s]{0,}[^)]{0,}[\s]{0,}(\))").matcher(rString).find()){
                        System.out.println("mmm: "+cts);
                        System.out.println("zhengzebiaodashi: "+"(\.)"+ key.split("\|")[0]+ "[\s]{0,}(\()[\s]{0,}[^)]{0,}[\s]{0,}(\))");
//                        System.out.println("matched: "+Pattern.compile("(\.)"+ key.split("\|")[0]+ "[\s]{0,}(\()[\s]{0,}[^)]{0,}[\s]{0,}(\))").matcher(rString).group());
                        strss_ft.add(ss);
                    }

                }
                List pss = new GetApiTest().getIndexOf(cts,
                        "[\s]{0,}(\()[\s\S]*?(\))[\s]{0,}(\{)[\s\S]*?(\})", cts.length(), 0);
                List lgg = new GetApiTest().getNearestPs(strss_ft, pss);
                if (strss_ft.size() != 0) {

                    List