Question

private String removeDuplicates(String userKeyword){
    int wordLength = userKeyword.length();
    int lengthCounter;
    for (lengthCounter=0; lengthCounter<wordLength; lengthCounter++){
        if (userKeyword.charAt(lengthCounter) != userKeyword.charAt(lengthCounter + 1)){
            String revisedKeyword = "" + userKeyword.charAt(lengthCounter);
            userKeyword = revisedKeyword;
        } 
    }
    return userKeyword;
}

我是java的新手。我们还没有使用过字符串构建器，Strung缓冲区，数组等....我们甚至没有进行循环，但我认为这将是最简单的使用方法...请帮忙。

Answer 1

有很多方法可以做到这一点。在您已经建立的工具集的范围内找到自己的解决方案是学习编程的全部内容。这是一个让你思考的可能解决方案：

创建一个Set，默认情况下只能包含唯一值

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

然后遍历String中的字符，将每个字符添加到mySet

mySet.add(c);

完成后，您的设置将包含一系列唯一且按顺序排列的字符，您可以使用

打印出来。

for (char c : mySet) {
    System.out.println(c)
}

编辑：

这是一个使用嵌套循环的简单设置

String s = "einstein"; //This is the word you will look for duplicates in
String temp = ""; //In this string, you will add characters that are not duplicates
boolean isDuplicate = false; //This will reset every out iteration

我正在使用一个简单的例子来保持简单。请理解，字符串temp将从空开始，但是当您的整个过程完成后，您的目标是让temp与爱因斯坦具有相同的字符，而不会重复。像stein

这样的东西

public static void main (String[] args) {

    String s = "einstein";
    String temp = "";
    boolean isDuplicate = false;

    for (int i = 0; i < s.length(); i++) {
        isDuplicate = false;
        char comparisonChar = s.charAt(i);
        for (int j = i + 1; j < s.length(); j++) {
            char nextChar = s.charAt(j);
            if (comparisonChar == nextChar) isDuplicate = true;
        }
        if (!isDuplicate) temp = temp + comparisonChar;
    }

    System.out.println(temp); //should print `stein`
}

}

现在我没有对此进行过测试，因此很可能会出现错误，但要在心理上进行测试并尝试理解它。困惑时问我。

Answer 2

好吧，我可以看看您尝试使用的方法。首先，当你说“删除重复项”时，你是否只删除彼此相邻的重复项？换句话说，您想将“簿记员”更改为“bokeper”，但“abcabcabc”不会更改。如果你只想为第二个返回“abc”，那么你的整个方法都是错误的。

假设您只想删除彼此相邻的副本，那么您就是在正确的轨道上，但这就是您做错了：

（1）当您查看userKeyword中的每个字符时，如下所示：

for (lengthCounter=0; lengthCounter<wordLength; lengthCounter++){
    if (userKeyword.charAt(lengthCounter) != userKeyword.charAt(lengthCounter + 1)){

如果你在循环中改变userKeyword就会搞砸了，就像你做的那样。字符将移位，但您将继续递增索引，这意味着您将跳过某些字符。

（2）因为你正在查看lengthCounter和lengthCounter + 1处的字符，所以当你到达字符串的末尾时要小心。在这种情况下，不希望索引到达最后一个字符，因为后面没有字符，charAt（lengthCounter + 1）将崩溃。将for改为lengthCounter < wordLength-1。

（3）最后，您将modifiedKeyword和userKeyword设置为单字符字符串。

String revisedKeyword = "" + userKeyword.charAt(lengthCounter);
userKeyword = revisedKeyword;

这肯定不是你想要的。您可能想要设置一个新的String来保存整个关键字。这样的事情：将放在循环

之后

String newKeyword = "";

然后，添加一个新角色

newKeyword = newKeyword + userKeyword.charAt(lengthCounter);

并且不要在循环中更改userKeyword;然后在最后，newKeyword就是答案。

（我假设你需要学习如何使用循环和东西。在现实生活中，我认为我可以用正则表达式在一行中完成整个事情，但这不是练习的重点。）

Answer 3

让它保持干净简洁。以下代码将检查并确保.charAt(char c) result上找不到String处的字符。

public static void main(String[] args)
{
    String input = "ABCADEDBF";
    String result = delDuplicate(input);
    System.out.println(result);
}


public static String delDuplicate(final String str)
{
    String result = "";

    for (int i = 0; i < str.length(); i++)
        if (!result.contains(str.charAt(i) + ""))
            result += str.charAt(i);

    return result;
}

Answer 4

以下是我最喜欢的两种删除String中重复字符的方法：

第一个不使用StringBuffer或StringBuilder。仅使用contains（）。

private static String removeDup(String str){
    String result = new String("");

    for (int i = 0; i < str.length(); i++) {
        if (!result.contains("" + str.charAt(i))) {
            result += "" + str.charAt(i);
        }
    }

    return result;
}

如果允许StringBuffer或StringBuilder，代码可能变得更清晰，更简单。这是我使用StringBuilder的第二种方式。

private static String removeDup(String str){
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i<str.length();i++){
        String si = str.substring(i, i+1);
        if (sb.indexOf(si)==-1){
            sb.append (si);
        }
    }
    return sb.toString();
}

当然，使用set来实现这个功能也是一个很好的解决方案。 Kon在这个帖子中做得很好。

Answer 5

String removeDuplicates(String s) {

    //Unicode characters range from 0x0000 to 0xFFFF
    boolean[] marker = new boolean[0xFFFF]; 

    StringBuilder sb = new StringBuilder();

    for(int i =0; i< s.length();i++) {
        char c = s.charAt(i);

        if(marker[c] == false) {
            //Character is first time occurred
            sb.append(c);

            //mark character as occurred
            marker[c] = true; 
        }
    }
    return sb.toString();
}

Answer 6

一个简单的解决方案是

public class duplicate

{
  public static void main(String args[])
   {
     String a= "stackoverflow";
     char c[]=a.toCharArray();
     int l=a.length();
     String b="";
     for(int i=0;i<l;i++)
       {
            if(b.contains(""+c[i]))
            {   
            }
            else
            {
                b=b+""+c[i];
            }
        }


    System.out.println(b);

    }

}

Answer 7

class Twice_Occuring
{
    void main(String s)
    {
        int count=0;
        for(int i=0;i<s.length();i++)
        {
            char c=s.charAt(i);
            int ind1=s.indexOf(c,i);
            int ind2=s.indexOf(c,i+1);
            if(ind2-ind1==1)
            {
                System.out.print(c+" ");
                count++;
            }
        }
        System.out.println("\n Number of counts = "+count);
    }
}

Answer 8

public static void main(String[] args) 

    {
        String stringWithDuplicates = "sathishssathish";
        char[] charecters = stringWithDuplicates.toCharArray();
        boolean[] duplicateFound = new boolean[130];
        StringBuilder sb = new StringBuilder();
        for (char c : charecters) {
            if (!duplicateFound[c]) {
                duplicateFound[c] = true;
                sb.append(c);
            }
        }
        System.out.println("SubString.main()" + sb);
    }

删除字符串中的重复字符（用户输入的关键字）

8 个答案: