Question

所以，长话短说，我有一个Java作业分配，需要以各种方式操作字符串的长ArrayList（我们正在做的事情，如显示单词组合，添加和删除ArrayList，没有任何东西特别）。我注意到一些提供的ArrayLists有重复的条目（这个分配不需要重复项），所以我从老师那里得到了通过删除重复条目来清理数据的好处。这就是我想出的：

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;
}

这对我的任务很好，但我怀疑它在现实世界中会非常有用。有没有办法在比较期间忽略空格和特殊字符？是否有更清洁的方法来处理这个问题（可能没有嵌套的For循环）？还有其他问题我应该问我不知道要问吗？

Answer 1

是。它可以在1（优雅）行中完成：

List<String> noDups = new ArrayList<String>(new LinkedHashSet<String>(list));

中间Set确保没有重复。选择Set List的实现来保留列表的顺序。

另外，在样式注释中：

使用以小写字母开头的名称命名您的方法和参数
在指定方法签名时始终引用摘要（即ArrayList）而不是具体（即private static List<String> killDups(List<String> list) { return new ArrayList<String>(new LinkedHashSet<String>(list)); }）

然后你的整个方法是：

List

对于额外的LinkedHashSet，该方法是通用的，因此它适用于任何类型的private static <T> List<T> killDups(List<T> list) { return new ArrayList<T>(new LinkedHashSet<T>(list)); }：

public class MungedString {
    // simplified code
    String s;

    public boolean equals(Object o) {
        // implement how you want to compare them here
    }

    public int hashCode() {
        // keep this consistent with equals()
    }
}

如果你想忽略某些字符，我会为它创建一个类并列出这些字符。 brownie points依赖hashCode()和equals()方法删除重复内容：

List<MungedString> list;
List<MungedString> noDupList = killDups(list);

然后

{{1}}

Answer 2

考虑使用Set

对于最简单的情况，即直接比较字符串，使用Hashset就是你想要做的事情：

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

mySet.addAll(aListWithDuplciatedStrings);

然后，mySet内的内容将是唯一的字符串集。

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

Answer 3

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

缺点是HashSet的顺序是不可预测的，所以当维护顺序很重要时，请改用LinkedHashSet（这有点慢）。

Answer 4

首先，您可以使用Set在漂亮的单行中完成：

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

这将删除所有重复项。带循环的第二个选项是将它们添加到新的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
}

至于自定义比较。我相信有一套可以让你提供一个比较器，但我现在还记不清了。

Answer 5

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));
          } 
    }
}
}

Answer 6

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);
}

}

在Java中，是否有更优雅的方法从Strings的ArrayList中删除重复的字符串？

6 个答案: