在java中对字符串中的数字进行排序时删除重复项

我需要对包含数字的字符串进行排序

例如：

我无法删除重复项。有人能帮我吗

下面是我用来排序的代码

public static String[] Sort(String[] list) {
    Comparator<String> comp = new Comparator<String>() {
        public int compare(String str1, String str2) {
            try {
                int num1 = Integer.parseInt(str1);
                int num2 = Integer.parseInt(str2);
                return Integer.compare(num1, num2);
            }
            catch (NumberFormatException e) {
                return str1.compareTo(str2);
            }
        }
    };
    Arrays.sort(list, comp);
    return list;
}

公共静态字符串[]排序（字符串[]列表）{
比较器comp=新比较器（）{
公共整数比较（字符串str1、字符串str2）{
试一试{
int num1=Integer.parseInt（str1）；
int num2=Integer.parseInt（str2）；
返回整数。比较（num1，num2）；
}
捕获（数字格式）{
返回str1.compareTo（str2）；
}
}
};
数组。排序（列表、组件）；
退货清单；
}

---

提前感谢

解决此问题的最简单方法是使用流。 这样我们就可以用一行代码来解决这个问题

String[] sorted = Arrays.stream(list).distinct().sorted((s1,s2)->compare(s1,s2)).toArray(String[]::new);

编辑：添加了对给定比较器的使用，以完全支持数字字符串和其他字符串

此外，比较器应在应用

toLowerCase（）

后比较字符串。导致

catch (NumberFormatException e) {
            return str1.toLowerCase().compareTo(str2.toLowerCase());
}

---

集合可用于删除副本

public static Set<String> sort(String[] list) {
    Comparator<String> comp = new Comparator<String>() {
        public int compare(String str1, String str2) {
            try {
                int num1 = Integer.parseInt(str1);
                int num2 = Integer.parseInt(str2);
                return Integer.compare(num1, num2);
            }
            catch (NumberFormatException e) {
                return str1.compareTo(str2);
            }
        }
    };
    Set<String> set = new TreeSet<String>(comp);
    set.addAll(Arrays.asList(list));
    System.out.println(set);
    return set;
}

公共静态集排序（字符串[]列表）{
比较器comp=新比较器（）{
公共整数比较（字符串str1、字符串str2）{
试一试{
int num1=Integer.parseInt（str1）；
int num2=Integer.parseInt（str2）；
返回整数。比较（num1，num2）；
}
捕获（数字格式）{
返回str1.compareTo（str2）；
}
}
};
集合=新树集合（comp）；
set.addAll（Arrays.asList（list））；
系统输出打印项次（套）；
返回集；
}

您希望排序并删除重复项。这意味着comparator很难同时完成这两个过程，您需要在数组中获取不同的字符串，所以排序，然后只获取不同的字符串，有很多方法，但我做到了，这很容易理解：

public static String[] Sort(String[] list) {
        Comparator<String> comp = new Comparator<String>() {
            public int compare(String str1, String str2) {
                try {
                    int num1 = Integer.parseInt(str1);
                    int num2 = Integer.parseInt(str2);
                    return Integer.compare(num1, num2);
                }
                catch (NumberFormatException e) {
                    return str1.compareTo(str2);
                }
            }
        };
        Arrays.sort(list, comp);
        ArrayList<String> new_list = new ArrayList<String>;
        if(list.length()>0){ 
          new_list.add(list[0]);
        }
        for(String s : list){
         //comparing with the last added string in list, if not same then add
          if(!new_list.get(new_list.size()-1).equals(s)){
             new_list.add(s);
           }
        }
        return new_list.toArray(new String[new_list.size()]);
    }

公共静态字符串[]排序（字符串[]列表）{
比较器comp=新比较器（）{
公共整数比较（字符串str1、字符串str2）{
试一试{
int num1=Integer.parseInt（str1）；
int num2=Integer.parseInt（str2）；
返回整数。比较（num1，num2）；
}
捕获（数字格式）{
返回str1.compareTo（str2）；
}
}
};
数组。排序（列表、组件）；
ArrayList new_list=新建ArrayList；
如果（list.length（）>0）{
新建_list.add（list[0]）；
}
用于（字符串s:列表）{
//与列表中最后添加的字符串进行比较，如果不相同，则添加
如果（！new_list.get（new_list.size（）-1）.equals）{
新列表。添加；
}
}
返回new_list.toArray（新字符串[new_list.size（）]）；
}

试试这个。我包括了一个更复杂的相同元素数组来验证

String[] vals = {"1","ABC","12","a", "1", "2", "12","2","ABC", "a", "ABC","a"};


Comparator<String> comp = ((a,b)-> {
   if (a.matches("\\d+") && b.matches("\\d+")) {
       return Integer.compare(Integer.valueOf(a), Integer.valueOf(b));
   } else {
            return a.toLowerCase().compareTo(b.toLowerCase());
   }
});

String[] result = Arrays.stream(vals).distinct().sorted(comp).toArray(String[]::new);
            
System.out.println(Arrays.toString(result));

---

你问了两个不同的问题！ 要向第一个解释：

Comparator<String> comparator = new Comparator<String>() {
        
        public int compare(String str1, String str2) {
            return isInteger(str1) && isInteger(str2)
                   ? Integer.compare(num1, num2)
                   : isInteger(str1) 
                   ? -1
                   : isInteger(str2)
                   ? 1
                   : str1.compareTo(str2);
        }
    };

private boolean isInteger(String value) {
    try {
        Integer.parseInt(value);
        return true;
    }
    catch (NumberFormatException e) {
        return false;
    }

比较器比较器=新比较器（）{ 公共整数比较（字符串str1、字符串str2）{ 返回isInteger（str1）和isInteger（str2） ？整数。比较（num1，num2） ：isInteger（str1） ? -1 ：iInteger（str2） 1. ：str1.比较（str2）； } }; 专用布尔值isInteger（字符串值）{ 试一试{ 整数.parseInt（值）； 返回true； } 捕获（数字格式）{ 返回false； }

---

看看是什么让你认为你的代码删除了重复项？你编写的代码定义了排序顺序，然后你的代码进行排序。排序不是删除重复项。我认为这是正确的，但它不会给出所需的输出，这可能是内置函数无法实现的…添加了

toLowerCase（）

在比较器中，这是有效的，因此是最正确的答案。我正准备编辑我的答案，因为我将数字字符串和字母字符串分开处理，但这比这个更优雅的方法复杂得多。我将删除它，以避免误导可能检查此问题的人以后将启用。上面的内容不会编译。@WJS谢谢，我修复了代码中的语法错误。请确保在处理流时导入所需的库（都在java.util.*下）不客气。但我主要指的是

排序

方法中的

比较器

。

比较

需要限定。Set不保留顺序！！但最终结果需要排序，不需要顺序

[1, 2, 12, a, ABC]

Comparator<String> comparator = new Comparator<String>() {
        
        public int compare(String str1, String str2) {
            return isInteger(str1) && isInteger(str2)
                   ? Integer.compare(num1, num2)
                   : isInteger(str1) 
                   ? -1
                   : isInteger(str2)
                   ? 1
                   : str1.compareTo(str2);
        }
    };

private boolean isInteger(String value) {
    try {
        Integer.parseInt(value);
        return true;
    }
    catch (NumberFormatException e) {
        return false;
    }