在Java中，是否有一种更优雅的方法可以从字符串和数组列表中删除重复字符串？

因此，长话短说，我有一个Java家庭作业，要求以各种方式操作字符串的长ArrayList（我们正在做一些事情，比如显示单词的组合，在ArrayList中添加和删除，没有什么特别的）。我注意到提供的一些ArrayList有重复的条目（并且重复的条目对于这个作业来说不是必需的），所以我得到了老师的同意，可以通过删除重复条目来清理数据。 以下是我的想法：

private static ArrayList<String> KillDups(ArrayList<String> ListOfStrings) {  

    for (int i = 0 ; i < ListOfStrings.size(); i++) {
        for (int j = i + 1; j < ListOfStrings.size(); j++) {
            //don't start on the same word or you'll eliminate it.
            if ( ListOfStrings.get(i).toString().equalsIgnoreCase( ListOfStrings.get(j).toString() )  ) {
                ListOfStrings.remove(j);//if they are the same, DITCH ONE.
                j = j -1; //removing the word basically changes the index, so swing down one.
            }                                
        }
    }
    return ListOfStrings;
}

private static ArrayList KillDups（ArrayList listofstring）{
对于（int i=0；i

---

这对我的任务来说很好，但我怀疑它在现实世界中是否有用。有没有一种方法可以在比较过程中忽略空白和特殊字符？通常有没有更干净的方法来处理这个问题（可能没有嵌套的For循环）？还有什么我不知道该问的问题吗？

是的。只需一行（优雅）即可完成：

另外，请将该方法设置为泛型，以便它可以与任何类型的

列表

：

private static <T> List<T> killDups(List<T> list) {
    return new ArrayList<T>(new LinkedHashSet<T>(list));
}

private static ArrayList<String> KillDups(ArrayList<String> ListOfStrings) {
    ArrayList<String> newList = new ArrayList<String>();
    for(String s : ListOfStrings) {
        if(!newList.contains(s)) {
            newList.add(s);
        }
    }
    return newList
}

然后

列表；
列表noDupList=killDups（列表）；

您可以使用而不是ArrayList。它是一个自动丢弃重复项的容器。无论集合有多大，确定插入的项是否为重复项都是一个固定时间操作。因此，将ArrayList转换为哈希集并返回将删除所有重复项

---

缺点是哈希集的顺序是不可预测的，因此，当维护顺序很重要时，请改用a（速度稍慢）。

考虑使用

Set

对于最简单的情况，即字符串的直接比较，您需要使用

Hashset

：

Set<String> mySet = new HashSet<String>();

mySet.addAll(aListWithDuplciatedStrings);

Set mySet=new HashSet（）；
mySet.addAll（aListWithDuplciatedStrings）；

然后，

mySet

中的内容将是唯一的字符串集

---

对于忽略案例比较，这是我留给你的作业。查看

TreeSet

和

Comparator

首先，您可以使用

集合在一个漂亮的单行程序中完成它：

private static ArrayList<String> KillDups(ArrayList<String> ListOfStrings) {
    return new ArrayList(new LinkedHashSet(ListOfStrings));
}

至于自定义比较。我相信有一个集合可以让您提供一个比较器，但是我现在记不起来了。
import java.awt.Toolkit；
import java.awt.Toolkit;
import java.util.Scanner;

class duplicate {

 public static void main(String[] args) {  

    Scanner kb = new Scanner(System. in );
    System.out.println("Entre String");
    String string = kb.nextLine();


    int length = string.length();
    if(length < 2) {
        System.out.println(string);
        return;
    }

    System.out.print(string.charAt(0));
    for (int i = 1; i < length; i++) {
        if (string.charAt(i) != string.charAt(i - 1)) {
            System.out.print(string.charAt(i));
          } 
    }
}
}

导入java.util.Scanner；
类副本{
公共静态void main（字符串[]args）{
扫描仪kb=新扫描仪（System.in）；
System.out.println（“Entre字符串”）；
String String=kb.nextLine（）；
int length=string.length（）；
如果（长度<2）{
System.out.println（字符串）；
返回；
}
系统输出打印（string.charAt（0））；
for（int i=1；i
公共静态无效删除重复字符串（字符串输入）{
字符串值1=马尼坎丹；
字符串值2=马尼坎丹；
字符串finalValue=“”；
整数计数=0；
char-char1；
char2=0；
对于（int i=0；i1）{
最终价值=最终价值+字符1；
i=i+（计数-1）；
}否则{
最终价值=最终价值+字符1；
}
计数=0；
}
System.out.println（最终值）；
}

}
首先：您不需要到处都使用
字符串，因为它们已经是字符串了。对于您的问题：我相信有很好的内置方法可以做到这一点。如果您想编写自己的列表，只需对列表进行排序，然后只比较相邻的条目，看看它们是否相等。这将给你一个O（N）的时间复杂度（不包括排序的O（NlogN））。因为相当多的答案似乎集中在你没有提到的东西上，如果OP能澄清一下，那将是非常好的：1）在删除重复之后，你需要保持列表的顺序吗？2） 当您通过忽略大小写比较来删除duplicate时，是否要保留第一个或最后一个字符串（或者您根本不在乎？）？事实上，在这种情况下，顺序并不重要。但是，由于我希望最终结果更有用，因此最好保持原始顺序。
LinkedHashSet
将保持
列表中包含的
字符串的顺序。
是的，但我相信这不是OP要求的。感谢您提供的一行解决方案，还有额外的建议！我将尽我最大的努力在将来赢得一些布朗尼积分D
Set<String> mySet = new HashSet<String>();

mySet.addAll(aListWithDuplciatedStrings);

private static ArrayList<String> KillDups(ArrayList<String> ListOfStrings) {
    return new ArrayList(new LinkedHashSet(ListOfStrings));
}

private static ArrayList<String> KillDups(ArrayList<String> ListOfStrings) {
    ArrayList<String> newList = new ArrayList<String>();
    for(String s : ListOfStrings) {
        if(!newList.contains(s)) {
            newList.add(s);
        }
    }
    return newList
}

import java.awt.Toolkit;
import java.util.Scanner;

class duplicate {

 public static void main(String[] args) {  

    Scanner kb = new Scanner(System. in );
    System.out.println("Entre String");
    String string = kb.nextLine();


    int length = string.length();
    if(length < 2) {
        System.out.println(string);
        return;
    }

    System.out.print(string.charAt(0));
    for (int i = 1; i < length; i++) {
        if (string.charAt(i) != string.charAt(i - 1)) {
            System.out.print(string.charAt(i));
          } 
    }
}
}

public static void removeDuplicateString(String input) {
    String value1 = manikandan;
    String value2 = manikandan;
    String finalValue = "";
    int count = 0;
    char char1;
    char char2 = 0;
    for (int i = 0; i < value1.length(); i++) {
        flag = 0;
        char1 = value1.charAt(i);
        for (int j = 0; j < value2.length(); j++) {
            char2 = value2.charAt(j);
            if (char1 == char2) {
                count++;
            }
        }

        if (count > 1) {
            finalValue=finalValue+char1;
            i=i+(count-1);
        } else {
            finalValue = finalValue + char1;
        }
        count = 0;
    }
    System.out.println(finalValue);
}