包含数字的字符串排序

一, Idea的起因

由于日志采集项目有种叫做轮转文件的东西, 大致解释就是有一个 a.log, 系统不停的往这个文件里面写内容, 当这个文件超过50M的时候, 就会把这个文件重命名为 a.log.1, 然后再生成一个新的 a.log

当我采集的时候, 会发现, 某个目录地下有如下图的东西

这时候, 我需要对这些日志进行一个排序, 那么, 如何做到, 排序的合法性?

二, 方案设计

起初, 前面有个仙人设计了一段代码. 我不想贴出来怕会误导大家. 大致的逻辑是根据文件名的长度来排序. 貌似是很不错的建议.Good Idea. 然而, 如果这个目录里面布置这一种类型的日志, 比如还有client.1, clinet.2, clinet.3, 那么排序出来的肯定是master和client乱成一锅粥.

三, 功能完成

我的方案是: 先比较两个字符串, 然后就是挖数字比较.但是要注意必须是同一位置上的数字才能有效比较.

四, 小翠, 上代码

/*
                           _ooOoo_
                          o8888888o
                          88" . "88
                          (| -_- |)
                          O\  =  /O
                       ____/`---'\____
                     .'  \\|     |//  `.
                    /  \\|||  :  |||//  \
                   /  _||||| -:- |||||-  \
                   |   | \\\  -  /// |   |
                   | \_|  ''\---/''  |   |
                   \  .-\__  `-`  ___/-. /
                 ___`. .'  /--.--\  `. . __
              ."" '<  `.___\_<|>_/___.'  >'"".
             | | :  `- \`.;`\ _ /`;.`/ - ` : | |
             \  \ `-.   \_ __\ /__ _/   .-` /  /
        ======`-.____`-.___\_____/___.-`____.-'======
                           `=---='
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                 佛祖保佑       永无BUG
*/

import org.junit.Test;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/**
 * @description: 工具类
 * @author: Wonder
 * @create: 2018-04-18 16:23
 **/
public class WonderUtil {

    public int getNum(String sb){
        if(sb == null){
            return 0;
        }
        if("".equals(sb)){
            return 0;
        }
        return Integer.valueOf(sb);
    }

    public boolean isNum(char c){
        boolean b = false;
        if(c >= '0' && c <= '9'){
            b = true;
        }
        return b;
    }

    public boolean isChar(char c){
        boolean b = false;
        if((c >= 'a' && c <= 'z' )|| ( c >= 'A' && c <= 'Z')){
            b = true;
        }
        return b;
    }

    /**
     * 比较两个包含数字的字符串
     * @param s1 字符串1
     * @param s2 字符串2
     * @return 返回比较结果
     */
    public int compareTo(String s1, String s2) {
        int len1 = s1.length();
        int len2 = s2.length();
        int lim = Math.min(len1, len2);
        char v1[] = s1.toCharArray();
        char v2[] = s2.toCharArray();
        char int1[] = null;
        char int2[] = null;

        int k = 0;
        // 外层循环用于遍历两个字符串
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            // 如果遍历到两个字符串相同位置都是数字, 那么就要去把这个数字后面连续的数字都挖出来
            if(isNum(c1) && isNum(c2)){
                int1 = new char[len1 - k];
                int2 = new char[len2 - k];
                int count1 = 0;
                int count2 = 0;
                int n1,n2;

                //此循环用于挖出 s1 数字, 依次放到预先的int1[] 数组中
                for (int i=k;i<len1;i++){
                    if(isNum(v1[i])){
                        int1[count1] = v1[i];
                    }else {
                        break;
                    }
                    count1++;
                }

                //此循环用于挖出 s2 的数字, 依次放到预先的int2[] 数组中
                for (int i=k;i<len2;i++){
                    if(isNum(v2[i])){
                        int2[count2] = v2[i];
                    }else {
                        break;
                    }
                    count2++;
                }

                n1 =getNum(String.valueOf(int1).trim());
                n2 =getNum(String.valueOf(int2).trim());

                // 需要判断n1 和 n2 是否相等, 如果相等, 则先把 k 移位, 然后continue
                if(n1 == n2){
                    k += int1.length;
                    continue;
                }

                //如果不相等, 那么就成功得到了想要的结果
                return n1 - n2;
            }

            // 如果遍历的两个字符不是全为数字的话, 就直接比较, 得出结果
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

    @Test
    public void test(){
        String s1 = "abc.txt.1000";
        String s2 = "abc.txt.1";
        String s3 = "abc.txt.2";
        String s4 = "abc.txt.3";
        String s5 = "shit.txt.2";
        String s6 = "shit.txt.20";
        String s7 = "shit.txt.3";
        Set<String> set = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return compareTo(o1, o2);   //设计的功能方法
                //return o1.compareTo(o2);  //可以忽略的方法
            }
        });
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        set.add(s6);
        set.add(s7);
        System.out.println(set);
    }
}

好了, 贴出输出吧:

=============== 装逼分界线 ===============

由于本人属于刚入行的菜鸟一枚, 代码难免有难以启齿的问题.望大佬们多提意见,欢迎嘲讽, 毕竟嘲讽才是前进的动力

包含数字的字符串排序

猜你喜欢