编写小逻辑程序实现hosts文件的清理

说明：

在开发过程中，经常会写很多如下的域名绑定到hosts上

192.168.0.1 sit.myweb.cn
192.168.0.1 uat.myweb.cn
192.168.0.2 uat.myweb.cn

但有些系统比较复杂，涉及很多域名地址，导致重复添加的时候，host文件会变得很乱

其实，豆包AI已经能自动帮我们过滤重复的域名配置，或者覆盖保留最新的

自己头铁，写了一个小程序实现

上代码和上图：

package com.zx.app.work.uni.enums.common.tool;


import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zx.app.ba.tool.util.JsonUtil;
import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * 
资源类型
 * @author SH.YE
 */
@AllArgsConstructor
@Getter
public enum HostClearActionEnum {

    LIST_ALL("list-all", "列出所有"),
    LIST_ONE("list-one", "列出单条的"),
    LIST_MORE("list-more", "列出重复的"),
    SAVE_FIRST("save-first", "保存第一条"),
    SAVE_LAST("save-last", "保存最后一条"),
    UNKNOWN("unknown", ""),
    ;



    private final String code;
    /**
     * 描述
     */
    private final String desc;


    public static HostClearActionEnum getItem(String pCode, HostClearActionEnum defaultValue) {
        if (pCode == null || pCode.isEmpty()) {
            return defaultValue;
        }
        for (HostClearActionEnum item : HostClearActionEnum.values()) {
            if (pCode.equals(item.getCode())) {
                return item;
            }
        }
        return defaultValue;
    }


    /**
     * 获得枚举的数据源Key-Value
     *
     * @return
     */
    public static Map getList() {
        Map result = new LinkedHashMap();

        for (HostClearActionEnum item : HostClearActionEnum.values()) {
            result.put(item.getCode(), item.getDesc());
        }

        return result;
    }


    protected static String toJson() {
        JSONArray dataList = new JSONArray();
        JSONObject item = null;
        for (HostClearActionEnum em : HostClearActionEnum.values()) {
            item = new JSONObject();
            dataList.add(item);
            item.put("id", em.getCode());
            item.put("name", em.getDesc());
        }

        return dataList.toJSONString();
    }

    public static void main(String[] args) {

        String str = toJson();
        System.out.println(str);

    }
}

package com.zx.app.work.uni.item.co.common.tool;

import lombok.Data;

import java.util.List;

@Data
public class HostClearContainer {
    private List list;
}

package com.zx.app.work.uni.item.co.common.tool;

import lombok.Data;

import java.util.List;

@Data
public class HostClearCo {
    private String comment;
    private String data;
    private List ipList;
}

package com.zx.app.work.uni.item.cp.common.tool;

import lombok.Data;

@Data
public class HostClearCp {
    /**
     * 
list-all
     * 
save-last
     * 
save-first
     * 
HostClearActionEnum
     */
    private String action;
    private Integer outCommentFlag;
    private String input;
}

package com.zx.app.work.uni.bs.common.tool;


import com.zx.app.ba.tool.enums.BooleanEnum;
import com.zx.app.ba.tool.item.common.StrLeftRightItem;
import com.zx.app.ba.tool.util.StrUniUtil;
import com.zx.app.work.uni.enums.common.action.MybatisConvertActionEnum;
import com.zx.app.work.uni.enums.common.tool.HostClearActionEnum;
import com.zx.app.work.uni.item.co.common.tool.HostClearCo;
import com.zx.app.work.uni.item.co.common.tool.HostClearContainer;
import com.zx.app.work.uni.item.cp.common.tool.HostClearCp;
import com.zx.app.work.uni.item.cp.common.tool.MybatisConvertToolCp;

import java.util.ArrayList;
import java.util.List;

/**
 * @author SH.YE
 */
public class HostClearBs {

    protected HostClearCo findHostClearCo(List hostList, String data) {
        for (HostClearCo each : hostList) {
            if (data.equalsIgnoreCase(each.getData())) {
                return each;
            }
        }

        return null;
    }

    public HostClearContainer convertResultForList(HostClearContainer hcc, boolean moreFlag) {
        HostClearContainer result = new HostClearContainer();
        List list = new ArrayList<>();
        result.setList(list);
        if (moreFlag) {
            for (HostClearCo each : hcc.getList()) {
                if (each.getIpList().size() > 1) {
                    list.add(each);
                }
            }

            return result;

        }
        for (HostClearCo each : hcc.getList()) {
            if (each.getIpList().size() == 1) {
                list.add(each);
            }

        }
        return result;
    }


    public String convertResultForSave(HostClearContainer hcc, boolean lastFlag, boolean outCommentFlag) {
        StringBuilder result = new StringBuilder();

        if (lastFlag) {
            for (HostClearCo each : hcc.getList()) {
                if (each.getIpList().isEmpty()) {
                    continue;
                }

                if (outCommentFlag) {
                    if (StrUniUtil.strIsNotTrimEmpty(each.getComment())) {
                        result.append(each.getComment());
                    }
                }

                result.append(each.getIpList().get(each.getIpList().size() - 1) + " " + each.getData() + '\n');
            }

            return result.toString();
        }

        for (HostClearCo each : hcc.getList()) {
            if (each.getIpList().isEmpty()) {
                continue;
            }

            if (outCommentFlag) {
                if (StrUniUtil.strIsNotTrimEmpty(each.getComment())) {
                    result.append(each.getComment());
                }
            }

            result.append(each.getIpList().get(0) + " " + each.getData() + '\n');
        }

        return result.toString();
    }

    public Object convertResult(HostClearContainer hcc, HostClearActionEnum actionEnum, boolean outCommentFlag) {
        switch (actionEnum) {
            case LIST_MORE:
                return convertResultForList(hcc, true);
            case LIST_ONE:
                return convertResultForList(hcc, false);
            case SAVE_FIRST:
                return convertResultForSave(hcc, false, outCommentFlag);
            case SAVE_LAST:
                return convertResultForSave(hcc, true, outCommentFlag);
            case LIST_ALL:
            case UNKNOWN:
            default:
                return hcc;
        }
    }

    public Object toResult(HostClearCp cp) {
        HostClearActionEnum actionEnum = HostClearActionEnum.getItem(cp.getAction(), HostClearActionEnum.UNKNOWN);

        switch (actionEnum) {
            case LIST_ALL:
            case LIST_ONE:
            case LIST_MORE:
            case SAVE_LAST:
            case SAVE_FIRST:
                break;
            case UNKNOWN:
            default:
                return "未知逻辑";
        }

        HostClearContainer hcc = new HostClearContainer();
        List hcList = new ArrayList<>();
        hcc.setList(hcList);

        StringBuilder commentSb = null;
        String strComment = null;
        StrLeftRightItem lrItem = null;
        HostClearCo co = null;
        List hostList = StrUniUtil.strSplitRnToArray(cp.getInput(), true, false);
        for (String each : hostList) {
            if (StrUniUtil.strIsTrimEmpty(each)) {
                continue;
            }

            if (each.startsWith("#")) {
                if (commentSb == null) {
                    commentSb = new StringBuilder();
                }
                commentSb.append(each + '\n');
                continue;
            }

            lrItem = StrUniUtil.toStrLeftRightItem(each, " ", true);
            if (StrUniUtil.strIsTrimEmpty(lrItem.getRightData())) {
                continue;
            }

            strComment = (commentSb == null) ? "" : commentSb.toString();
            commentSb = null;
            co = findHostClearCo(hcList, lrItem.getRightData());
            if (co == null) {
                co = new HostClearCo();
                co.setIpList(new ArrayList<>());
                hcList.add(co);

                co.setData(lrItem.getRightData());
                co.setComment(strComment);
                co.getIpList().add(lrItem.getLeftData());

                continue;
            }

            co.getIpList().add(lrItem.getLeftData());
            co.setComment(co.getComment() + strComment);
        }

        return convertResult(hcc, actionEnum, BooleanEnum.dataIsTrue(cp.getOutCommentFlag()));
    }
}

// region 字符串是否过滤空格后为空

/**
 * 字符串是否过滤空格后为空
 *
 * @param str
 * @return
 */
public static boolean strIsTrimEmpty(String str) {
    return (str == null || str.trim().isEmpty());
}

// endregion 字符串是否过滤空格后为空

// region 字符串是否过滤空格后非空

/**
 * 字符串是否过滤空格后非空
 *
 * @param str
 * @return
 */
public static boolean strIsNotTrimEmpty(String str) {
    return !strIsTrimEmpty(str);
}

// endregion 字符串是否过滤空格后非空

public static List strSplitRnToArray(String str, boolean trimFlag) {
    return strSplitToArray(str, "" + '\n', trimFlag, false);
}

public static List strSplitRnToArray(String str, boolean trimFlag, boolean removeRepeaterFlag) {
    return strSplitToArray(str, "" + '\n', trimFlag, removeRepeaterFlag);
}

public static List strSplitRnToArrayByParams(String str, boolean trimFlag, boolean lowerFlag, boolean removeRepeaterFlag) {
    List result = new ArrayList<>();
    if (str == null || str.isEmpty()) {
        return result;
    }

    String splitChar = "" + '\n';
    String[] sA = str.split(splitChar);
    String strAdd = null;
    for (String each : sA) {
        if (each == null) {
            continue;
        }

        if (trimFlag) {
            strAdd = each.trim();
        } else {
            strAdd = each;
        }

        if (strAdd.isEmpty()) {
            continue;
        }

        if (lowerFlag) {
            strAdd = strAdd.toLowerCase();
        }

        if (removeRepeaterFlag && result.contains(strAdd)) {
            continue;
        }

        result.add(strAdd);
    }

    return result;
}

界面效果：