0 
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真的很陌生。我们还没有使用过字符串构建器、字符串缓冲区、数组等......我们甚至还没有使用循环，但我认为这将是最简单的使用方式......请帮助。

4

8 回答 8

4

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

创建一个 Set，默认情况下只能保存唯一值

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

然后遍历字符串中的字符，将每个字符添加到 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`
}

}

现在我还没有对此进行测试，因此它可能存在错误，但请在心里仔细检查并尝试理解它。困惑时问我。

于 2013-08-10T00:13:45.393 回答
0

一个简单的解决方案是

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

    }

}
于 2014-08-30T10:51:38.413 回答
0 
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);
    }
}
于 2014-10-04T18:03:32.733 回答
0

让我们保持干净和简单。以下代码将检查并确保.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;
}
于 2013-08-10T03:36:53.827 回答
0

好吧，我可以看到您尝试使用的方法。首先，当您说“删除重复项”时，您是否仅删除彼此相邻的重复项？换句话说，您想将“bookkeeper”更改为“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 newKeyword = "";

然后，向其中添加一个新字符

newKeyword = newKeyword + userKeyword.charAt(lengthCounter);

并且不要在循环内更改 userKeyword；然后最后， newKeyword 将是答案。

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

于 2013-08-10T00:34:24.153 回答
0

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

第一个不使用 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 在这个线程中做得很好。

于 2013-11-13T18:16:13.543 回答
0 
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();
}
于 2014-02-04T12:29:00.750 回答
0 
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);
    }
于 2018-06-13T14:00:46.887 回答