Question

我正在尝试遍历字符串以删除重复的字符。

例如，字符串aabbccdef应该变为abcdef 字符串abcdabcd应该变为abcd

这是我到目前为止所做的：

public class test {

    public static void main(String[] args) {

        String input = new String("abbc");
        String output = new String();

        for (int i = 0; i < input.length(); i++) {
            for (int j = 0; j < output.length(); j++) {
                if (input.charAt(i) != output.charAt(j)) {
                    output = output + input.charAt(i);
                }
            }
        }

        System.out.println(output);

    }

}

这样做的最佳方式是什么？

Answer 1

将字符串转换为char数组，并将其存储在LinkedHashSet中。这将保留您的订购，并删除重复。类似的东西：

String string = "aabbccdefatafaz";

char[] chars = string.toCharArray();
Set<Character> charSet = new LinkedHashSet<Character>();
for (char c : chars) {
    charSet.add(c);
}

StringBuilder sb = new StringBuilder();
for (Character character : charSet) {
    sb.append(character);
}
System.out.println(sb.toString());

Answer 2

我会使用LinkedHashSet的帮助。删除重复（因为我们使用Set，维护顺序，因为我们使用链表impl）。这是一种肮脏的解决方案。甚至可能有更好的方式。

String s="aabbccdef";
Set<Character> set=new LinkedHashSet<Character>();
for(char c:s.toCharArray())
{
    set.add(Character.valueOf(c));
}

Answer 3

尝试这个简单的解决方案：

public String removeDuplicates(String input){
    String result = "";
    for (int i = 0; i < input.length(); i++) {
        if(!result.contains(String.valueOf(input.charAt(i)))) {
            result += String.valueOf(input.charAt(i));
        }
    }
    return result;
}

Answer 4

使用流可以轻松实现。

import java.util.Arrays;
import java.util.stream.Collectors;

public class MyClass {

    public static String removeDuplicates(String myString) {
        return Arrays.asList(myString.split(""))
                     .stream()
                     .distinct()
                     .collect(Collectors.joining());
    }
}

以下是有关Stream的更多文档以及您可以使用的所有内容   它：   https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

“描述”部分对Streams的好处非常有启发性。

Answer 5

创建StringWriter。在for循环中使用charAt（i）运行原始字符串。保持char类型的变量，保留最后一个charAt值。如果迭代并且charAt值等于该变量中存储的值，请不要添加到StringWriter。最后，使用StringWriter.toString（）方法获取一个字符串，并用它做你需要的。

Answer 6

对我来说，看起来每个人都在努力完成这项任务。我们所关心的是，如果重复，它会复制每个字母的1份副本。然后因为我们只关心这些字符是否一个接一个地重复，所以嵌套循环变得任意，因为你可以简单地将位置n与位置n + 1进行比较。然后因为这只会在它们不同时复制内容，以解决对于最后一个字符，您可以将空格附加到原始字符串的末尾，或者只是让它将字符串的最后一个字符复制到结果中。

String removeDuplicate（String s）{

    String result = "";

    for (int i = 0; i < s.length(); i++){
        if (i + 1 < s.length() && s.charAt(i) != s.charAt(i+1)){
            result = result + s.charAt(i);
        }
        if (i + 1 == s.length()){
            result = result + s.charAt(i);
        }
    }

    return result;

}

Answer 7

我认为以这种方式工作会更容易，只需将字符串传递给此函数即可完成工作：）。

private static void removeduplicate(String name)
{   char[] arr = name.toCharArray();
    StringBuffer modified =new StringBuffer();
    for(char a:arr)
    {
        if(!modified.contains(Character.toString(a)))
        {
            modified=modified.append(Character.toString(a)) ;
        }
    }
    System.out.println(modified);
}

Answer 8

以下是answer by Dave的改进。

它使用HashSet代替稍微昂贵的LinkedHashSet，并重复使用chars缓冲区，无需StringBuilder。

String string = "aabbccdefatafaz";

char[] chars = string.toCharArray();
Set<Character> present = new HashSet<>();
int len = 0;
for (char c : chars)
    if (present.add(c))
        chars[len++] = c;

System.out.println(new String(chars, 0, len));   // abcdeftz

Answer 9

在不使用任何其他缓冲区的情况下删除字符串中重复字符的代码。注意：一个或两个额外的变量是好的。额外的数组不是：

import java.util.*;
public class Main{
    public static char[] removeDupes(char[] arr){
        if (arr == null || arr.length < 2)
            return arr;
        int len = arr.length;
        int tail = 1;
        for(int x = 1; x < len; x++){
            int y;
            for(y = 0; y < tail; y++){
                if (arr[x] == arr[y]) break;
            }
            if (y == tail){
                arr[tail] = arr[x];
                tail++;
            }
        }
        return Arrays.copyOfRange(arr, 0, tail);
    }

    public static char[] bigArr(int len){
        char[] arr = new char[len];
        Random r = new Random();
        String alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()-=_+[]{}|;:',.<>/?`~";

        for(int x = 0; x < len; x++){
            arr[x] = alphabet.charAt(r.nextInt(alphabet.length()));
        }

        return arr;
    }
    public static void main(String args[]){

        String result = new String(removeDupes(new char[]{'a', 'b', 'c', 'd', 'a'}));
        assert "abcd".equals(result) : "abcda should return abcd but it returns: " + result;

        result = new String(removeDupes(new char[]{'a', 'a', 'a', 'a'}));
        assert "a".equals(result) : "aaaa should return a but it returns: " + result;

        result = new String(removeDupes(new char[]{'a', 'b', 'c', 'a'}));
        assert "abc".equals(result) : "abca should return abc but it returns: " + result;

        result = new String(removeDupes(new char[]{'a', 'a', 'b', 'b'}));
        assert "ab".equals(result) : "aabb should return ab but it returns: " + result;

        result = new String(removeDupes(new char[]{'a'}));
        assert "a".equals(result) : "a should return a but it returns: " + result;

        result = new String(removeDupes(new char[]{'a', 'b', 'b', 'a'}));
        assert "ab".equals(result) : "abba should return ab but it returns: " + result;


        char[] arr = bigArr(5000000);
        long startTime = System.nanoTime();
        System.out.println("2: " + new String(removeDupes(arr)));
        long endTime = System.nanoTime();
        long duration = (endTime - startTime);
        System.out.println("Program took: " + duration + " nanoseconds");
        System.out.println("Program took: " + duration/1000000000 + " seconds");

    }
}

如何阅读和讨论上述代码：

名为removeDupes的方法采用名为arr。
arr作为原始字符数组返回＆＃34;按值＆＃34;。传入的arr是在Main的成员方法removeDupes结束时进行的垃圾收集。
该算法的运行时复杂度为O（n）或更具体地O（n +（小常数））常量是整个原始字符阵列中的唯一字符。
copyOfRange不会显着增加运行时复杂性，因为它只复制少量固定数量的项目。名为arr的char数组不会一直步进。
如果将null传递给removeDupes，则该方法返回null。
如果传递一个空的原始字符数组或一个包含一个值的数组，则返回该未修改的数组。
方法removeDupes在物理上尽可能快，充分利用L1和L2缓存，因此Branch redirects are kept to a minimum。
2015标准问题，无负担的计算机应该能够使用包含5亿个字符的原始字符数组在15到25秒之间完成此方法。

说明此代码的工作原理：

传入的数组的第一部分用作最终返回的唯一字符的存储库。在函数的开头，答案是：＆＃34; 0到1和＃34之间的字符;在0和尾之间。

我们在循环之外定义变量y，因为我们想要找到我们正在查看的数组索引在我们的存储库中重复的第一个位置。当找到重复项时，它会中断并退出，y == tail返回false并且没有提供存储库。

当我们正在查看的索引x未在我们的存储库中表示时，我们将其拉出并将其添加到我们的存储库末尾的索引尾部并增加尾部。

最后，我们返回点0和尾部之间的数组，它应该小于或等于原始数组的长度。

编写谈话的谈话要点：

如果将y ++更改为++ y，程序会有不同的行为吗？为什么或为什么不。

最后的阵列副本是否代表另一个N＆＃39; N＆＃39; N＆＃39;通过整个数组使运行时复杂度为O（n * n）而不是O（n）？为什么或为什么不。

你可以替换双等于比较原始字符和.equals吗？为什么或为什么不呢？

可以更改此方法以进行替换＆＃34;通过引用＆＃34;而不是现在，＆＃34;按价值＆＃34;？为什么或为什么不呢？

您可以通过在＆＃39; arr＆＃39;开头对唯一值的存储库进行排序来提高此算法的效率吗？在哪种情况下会更有效率？

Answer 10

public class RemoveRepeated4rmString {

    public static void main(String[] args) {
        String s = "harikrishna";
        String s2 = "";
        for (int i = 0; i < s.length(); i++) {
            Boolean found = false;
            for (int j = 0; j < s2.length(); j++) {
                if (s.charAt(i) == s2.charAt(j)) {
                    found = true;
                    break; //don't need to iterate further
                }
            }
            if (found == false) {
                s2 = s2.concat(String.valueOf(s.charAt(i)));
            }
        }
        System.out.println(s2);
    }
}

Answer 11

    String input = "AAAB";

    String output = "";
    for (int index = 0; index < input.length(); index++) {
        if (input.charAt(index % input.length()) != input
                .charAt((index + 1) % input.length())) {

            output += input.charAt(index);

        }
    }
    System.out.println(output);

但如果输入具有相同的元素，或者如果它是空的，则无法使用它！

Answer 12

import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class Sol {

    public static void main(String[] args) {
        char[] str = "bananas".toCharArray();
        LinkedHashMap<Character,Integer> map = new LinkedHashMap<>();
        StringBuffer s = new StringBuffer();

        for(Character c : str){
            if(map.containsKey(c))
                map.put(c, map.get(c)+1);
            else
                map.put(c, 1);
        }

        for(Entry<Character,Integer> entry : map.entrySet()){
            s.append(entry.getKey());
        }

        System.out.println(s);
    }

}

Answer 13

  let str = 'abcdabddbbccedbd'; 
  let res = "";
  new Set([...str]).forEach((val) => {
      res += val
  })

  console.log(res);

Answer 14

希望这会有所帮助。

public void RemoveDuplicates() {
    String s = "Hello World!";
    int l = s.length();
    char ch;
    String result = "";
    for (int i = 0; i < l; i++) {
        ch = s.charAt(i);
        if (ch != ' ') {
            result = result + ch;
        }
        // Replacing space in all occurrence of the current character
        s = s.replace(ch, ' ');
    }
    System.out.println("After removing duplicate characters : " + result);
}

Answer 15

有一个数组来知道某个角色是否已被录制过;如果没有，请将其添加到字符串缓冲区。请注意，我已将其区分大小写;使用int数组，你总是可以创建它（在这段代码中没有这样做）来返回出现次数。

private static String removeDuplicates(String s) {

    int [] occurrences = new int[52];
    Arrays.fill(occurrences,0);

    StringBuffer deDupS = new StringBuffer();
    for(int i = 0; i < s.length(); i++) {
        if(s.charAt(i) >= 97) {
            if(occurrences[s.charAt(i) - 97] == 0) {
                deDupS.append(s.charAt(i));
                occurrences[s.charAt(i) - 97]++;
            }
        } else if(s.charAt(i) >= 65) {
            if(occurrences[s.charAt(i) - 65 + 26] == 0) {
                deDupS.append(s.charAt(i));
                occurrences[s.charAt(i) - 65 + 26]++;
            }
        }
    }

    return deDupS.toString();

}

Answer 16

StringBuilder builderWord = new StringBuilder(word);
 for(int index=0; index < builderWord.length(); index++) {
   for(int reverseIndex=builderWord.length()-1; reverseIndex > index;reverseIndex--) {
     if (builderWord.charAt(reverseIndex) == builderWord.charAt(index)) {
       builderWord.deleteCharAt(reverseIndex);
     }
   }
}
return builderWord.toString();

Answer 17

String str1[] ="Hi helloo helloo  oooo this".split(" "); 

Set<String> charSet = new LinkedHashSet<String>();
for (String c: str1) 
{
       charSet.add(c); 
}
StringBuilder sb = new StringBuilder(); 
for (String character : charSet) 
{
       sb.append(character); 
}

System.out.println(sb.toString());

Answer 18

public String removeDuplicates(String dupCharsString){
    StringBuffer buffer = new StringBuffer(dupCharsString);
    int step = 0;
    while(step <= buffer.length()){
        for( int i = step + 1; i < buffer.length(); i++ ){
            if( buffer.charAt(i) == buffer.charAt(step) ){
                buffer.setCharAt(i, ' ');
            }
        }
        step++;
    }
    return buffer.toString().replaceAll("\\s","");
}

Answer 19

String output = "";
    HashMap<Character,Boolean> map = new HashMap<>();
    for(int i=0;i<str.length();i++){
        char ch = str.charAt(i);
        if (!map.containsKey(ch)){
            output += ch;
            map.put(ch,true);
        }
    }
    return output;

这是在 Java 中一次性使用 HashMap 的简单方法。

时间复杂度：O(n)

空间复杂度：O(n)

Answer 20

Java 8有一个新的String.chars()方法，该方法在String中返回字符流。您可以使用流操作来过滤出重复的字符，如下所示：

String out = in.chars()
            .mapToObj(c -> Character.valueOf((char) c)) // bit messy as chars() returns an IntStream, not a CharStream (which doesn't exist)
            .distinct()
            .map(Object::toString)
            .collect(Collectors.joining(""));

Answer 21

String s = "WelcomeToJava";
String result = "";
List<String> al = new ArrayList<String>();

for (int i = 0; i < s.length(); i++) {
    for (int k = 0; k < s.length(); k++) {
        if (String.valueOf(s.charAt(i)).equalsIgnoreCase(String.valueOf(s.charAt(k)))) {
            if (!al.contains(String.valueOf(s.charAt(i)))) {
                al.add(String.valueOf(s.charAt(i)));
                result = result + String.valueOf(s.charAt(i));
            }
        }
    }
}

System.out.println("Result--" + result);

Answer 22

Arrays.stream(input.split("")).distinct().collect(joining());

Answer 23

public class RemoveDuplicatesFromStingsMethod1UsingLoops {

    public static void main(String[] args) {

        String input = new String("aaabbbcccddd");
        String output = "";
        for (int i = 0; i < input.length(); i++) {
            if (!output.contains(String.valueOf(input.charAt(i)))) {
                output += String.valueOf(input.charAt(i));
            }
        }
        System.out.println(output);
    }
}

输出： abcd

Answer 24

 String input = "abbcccaabbddeessacccbbddefgaabbccddeeffggadscsda";
    String output ="";

    for (int i= 0; i<input.length();i++) {
        if (!output.contains(input.substring(i, i+1))) 
            output = output+ input.substring(i, i+1);

    }


        System.out.println(output);

Answer 25

package JavaPracticePackage;

public class Replace_same_char {

    public static void main(String[] args) {
        String value = "AABBCCDD";
        String FinalValue = "";
        for(int i=0; i<value.length();i++) {
            if(FinalValue.indexOf(value.charAt(i))==-1) {
                FinalValue=FinalValue+value.charAt(i);
            }
        }
        System.out.println(FinalValue);
    }
}

Answer 26

package StringPrograms;

public class RemoveDuplicateCharacters {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean flag;
        String str = "Stackoverflowtest";
        String a = "";
        int dlen = a.length();
        for (int i = 0; i < str.length(); i++) {
            flag = false;
            for (int j = 0; j <dlen; j++)
                
                 if (str.charAt(i) == a.charAt(j)) {
                    flag = true;
                    break;
                }
            if (flag == false) {
                a = a + str.charAt(i);
                dlen = dlen + 1;
            }
        }
        System.out.println(a);

    }

}

Answer 27

 public static void main (String[] args)
 {
    Scanner sc = new Scanner(System.in);
    String s = sc.next();
    String str = "";
    char c;
    for(int i = 0; i < s.length(); i++)
    {
        c = s.charAt(i);
        str = str + c;
        s = s.replace(c, ' ');
        if(i == s.length() - 1)
        {
           System.out.println(str.replaceAll("\\s", ""));   
        }
    }
}

Answer 28

你做不到。您可以创建一个删除了重复项的新String。你为什么不使用StringBuilder（或推测StringBuffer）？

您可以浏览字符串并将唯一字符存储在char []数组中，跟踪您看到的唯一字符数。然后，您可以使用String(char[], int, int)构造函数创建新的String。

此外，问题有点模糊 - “重复”是否意味着相邻的重复？（换句话说，abcab会发生什么？）

Answer 29

好的伙计们，我找到了一个更好的方法来做到这一点

public static void alpha(char[] finalname)
{
    if (finalname == null)
    {
        return;
    }

    if (finalname.length <2)
    {
        return;
    }

    char empty = '\000';
    for (int i=0; i<finalname.length-1; i++)
    {
        if (finalname[i] == finalname[i+1])
        {
            finalname[i] = empty;
        }
    }

    String alphaname = String.valueOf(finalname);
    alphaname = alphaname.replace("\000", "");
    System.out.println(alphaname);


}

Answer 30

Oldschool方式（因为我们在Apple中编写了这样的任务）[Basic，适用于Java]：

int i,j;
StringBuffer str=new StringBuffer();
Scanner in = new Scanner(System.in);
System.out.print("Enter string: ");
str.append(in.nextLine());

for (i=0;i<str.length()-1;i++){
    for (j=i+1;j<str.length();j++){
        if (str.charAt(i)==str.charAt(j))
            str.deleteCharAt(j);
    }
}
System.out.println("Removed non-unique symbols: " + str);

Answer 31

这是我想分享的另一个逻辑。你从字符串长度的中间开始比较并向后移动。

测试： input =“azxxzy”; output =“ay”;

String removeMidway(String input){
        cnt = cnt+1;
        StringBuilder str = new StringBuilder(input);
        int midlen = str.length()/2;
        for(int i=midlen-1;i>0;i--){

            for(int j=midlen;j<str.length()-1;j++){     
                if(str.charAt(i)==str.charAt(j)){
                    str.delete(i, j+1);
                    midlen = str.length()/2;
                    System.out.println("i="+i+",j="+j+ ",len="+ str.length() + ",midlen=" + midlen+ ", after deleted = " + str);
                }
            }
        }       
        return str.toString();
    }

Answer 32

这是另一种方法

void remove_duplicate (char* str, int len) {
    unsigned int index = 0;
    int c = 0;
    int i = 0;
    while (c < len) {
        /* this is just example more check can be added for
           capital letter, space and special chars */

        int pos = str[c] - 'a';
        if ((index & (1<<pos)) == 0) {
            str[i++] = str[c];
            index |= (1<<pos);
        }
        c++;
    }
    str[i] = 0;
}

Answer 33

如果字符串是ASCII字符串，另一种可能的解决方案是维护256个布尔元素的数组，以表示字符串中的ASCII字符外观。如果第一次出现一个角色，我们会保留它并附加到结果中。否则就跳过它。

public String removeDuplicates(String input) {
    boolean[] chars = new boolean[256];
    StringBuilder resultStringBuilder = new StringBuilder();
    for (Character c : input.toCharArray()) {
        if (!chars[c]) {
            resultStringBuilder.append(c);
            chars[c] = true;
        }
    }
    return resultStringBuilder.toString();
}

此方法也适用于Unicode字符串。您只需增加chars尺寸。

Answer 34

使用JDK7的解决方案：

public static String removeDuplicateChars(final String str){

    if (str == null || str.isEmpty()){
        return str;
    }

    final char[] chArray = str.toCharArray();
    final Set<Character> set = new LinkedHashSet<>();
    for (char c : chArray) {
        set.add(c);
    }

    final StringBuilder sb = new StringBuilder();
    for (Character character : set) {
        sb.append(character);
    }
    return sb.toString();
}

Answer 35

 public static void main(String a[]){
      String name="Madan";
      System.out.println(name);
      StringBuilder sb=new StringBuilder(name);
      for(int i=0;i<name.length();i++){
          for(int j=i+1;j<name.length();j++){
             if(name.charAt(i)==name.charAt(j)){
              sb.deleteCharAt(j);

             }
          }
      }
     System.out.println("After deletion :"+sb+"");

    }

Answer 36

    String str = "eamparuthik@gmail.com";
    char[] c = str.toCharArray();
    String op = "";

    for(int i=0; i<=c.length-1; i++){
        if(!op.contains(c[i] + ""))
        op = op + c[i];
    }
    System.out.println(op);

Answer 37

public static String removeDuplicateChar(String str){
         char charArray[] = str.toCharArray();
         StringBuilder stringBuilder= new StringBuilder();
         for(int i=0;i<charArray.length;i++){
             int index = stringBuilder.toString().indexOf(charArray[i]);
             if(index <= -1){
                 stringBuilder.append(charArray[i]);
             }
         }
         return stringBuilder.toString();
    }

Answer 38

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class RemoveDuplicacy
{
        public static void main(String args[])throws IOException
        {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("Enter any word : ");
            String s = br.readLine();
            int l = s.length();
            char ch;
            String ans=" ";

            for(int i=0; i<l; i++)
            {
                ch = s.charAt(i);
                if(ch!=' ')
                    ans = ans + ch;
                s = s.replace(ch,' '); //Replacing all occurrence of the current character by a space
            }

           System.out.println("Word after removing duplicate characters : " + ans);
        }

}

Answer 39

import java.util.Scanner;

public class dublicate {
    public static void main(String... a) {
        System.out.print("Enter the String");
        Scanner Sc = new Scanner(System.in);
        String st=Sc.nextLine();
        StringBuilder sb=new StringBuilder();
        boolean [] bc=new boolean[256];
        for(int i=0;i<st.length();i++)
        {
            int index=st.charAt(i);
            if(bc[index]==false)
            {
                sb.append(st.charAt(i));
                bc[index]=true;
            }

        }
        System.out.print(sb.toString());
    }
}

Answer 40

public static void main(String[] args) {

    int i,j;
    StringBuffer str=new StringBuffer();
    Scanner in = new Scanner(System.in);
    System.out.print("Enter string: ");

    str.append(in.nextLine());

    for (i=0;i<str.length()-1;i++)
    {
        for (j=1;j<str.length();j++)
        {
            if (str.charAt(i)==str.charAt(j))
                str.deleteCharAt(j);
        }
    }
    System.out.println("Removed String: " + str);
}

Answer 41

这是@Dave建议的解决方案的改进。在这里，我只在单循环中实现。

让重新使用 set.add（T item）方法的返回，如果add成功，则在StringBuffer中同时添加

这只是O（n）。无需再次循环。

String string = "aabbccdefatafaz";

char[] chars = string.toCharArray();
StringBuilder sb = new StringBuilder();
Set<Character> charSet = new LinkedHashSet<Character>();
for (char c : chars) {
    if(charSet.add(c) ){
        sb.append(c);
    }

}
System.out.println(sb.toString()); // abcdeftz

Answer 42

简单的解决方案是遍历给定的字符串，并将每个唯一字符放入另一个字符串（在本例中为变量结果），如果此字符串不包含该特定字符。最后返回< strong> result 字符串作为输出。

下面是工作和测试的代码段，用于从给定字符串中删除具有O（n）时间复杂度的重复字符。

private static String removeDuplicate(String s) {
      String result="";
      for (int i=0 ;i<s.length();i++) {
          char ch = s.charAt(i);
          if (!result.contains(""+ch)) {
              result+=""+ch;
          }
      }
      return result;
  }

如果输入女士，则输出疯狂。
如果输入为 anagram ，则输出将为 angrm

希望这有帮助。
感谢

Answer 43

为了简化代码 - 我采用了硬核输入，也可以通过使用Scanner类来输入

    public class KillDuplicateCharInString {
    public static void main(String args[]) {
        String str= "aaaabccdde ";
        char arr[]= str.toCharArray();
        int n = arr.length;
        String finalStr="";
        for(int i=0;i<n;i++) {
            if(i==n-1){
                finalStr+=arr[i];
                break;
            }
            if(arr[i]==arr[i+1]) {
                continue;
            }
            else {
                finalStr+=arr[i];
            }
        }
        System.out.println(finalStr);



    }
}

Answer 44

package com.st.removeduplicate;
 public class RemoveDuplicate {
   public static void main(String[] args) {
    String str1="shushil",str2="";      
    for(int i=0; i<=str1.length()-1;i++) {
        int count=0;
        for(int j=0;j<=i;j++) {
            if(str1.charAt(i)==str1.charAt(j)) 
                count++;
            if(count >1)
                break;
        }
        if(count==1) 
            str2=str2+str1.charAt(i);
    }
    System.out.println(str2);

}

}

Answer 45

使用Set集合概念尝试以下简单解决方案：字符串str =“ aabbcdegg”;

    Set<Character>removeduplicates = new LinkedHashSet<>();
    char strarray[]= str.toCharArray();
    for(char c:strarray)
    {
        removeduplicates.add(c);
    }


    Iterator<Character> itr = removeduplicates.iterator();
    while(itr.hasNext())
    {
        System.out.print(itr.next());
    }

Answer 46

public class StringTest {

    public static String dupRemove(String str) {

        Set<Character> s1 = new HashSet<Character>();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < str.length(); i++) {

            Character c = str.charAt(i);

            if (!s1.contains(c)) {
                s1.add(c);
                sb.append(c);
            }


        }

        System.out.println(sb.toString());

        return sb.toString();

    }

    public static void main(String[] args) {

        dupRemove("AAAAAAAAAAAAAAAAA BBBBBBBB");
    }

}

Answer 47

  val str="karunkumardev"
  val arr=str.toCharArray()
  val len=arr.size-1

  for(i in 0..len){
      var flag=false
      for(j in i+1..len){
          if(arr[i]==arr[j]){
             flag=true
              break
          }
      }
      if(!flag){
          print(arr[i])
      }
  }

Answer 48

public class RemoveDuplicate {

    static String st="papuuu";
    static String st1="";
    public static void main(String[] args) {
        for (int i = 0; i < st.length(); i++) {
            String ff = String.valueOf(st.charAt(i));
            if (!st1.contains(ff)) {
                st1 = st1 + st.charAt(i);
            }
        }   
        System.out.println(st1);
    }
}

Answer 49

package com.core.interview.client;

import java.util.LinkedHashSet;

import java.util.Scanner;

import java.util.Set;

公共类RemoveDuplicateFromString {

public static String DupRemoveFromString(String str){




    char[] c1 =str.toCharArray();

    Set<Character> charSet = new LinkedHashSet<Character>();

     for(char c:c1){

        charSet.add(c);
    }

     StringBuffer sb = new StringBuffer();


      for (Character c2 : charSet) {


          sb.append(c2);
    }   

    return sb.toString();

}

public static void main(String[] args) {


    System.out.println("Enter Your String: ");


    Scanner sc = new Scanner(System.in);


    String str = sc.nextLine();


    System.out.println(DupRemoveFromString(str));
}

}

从Java中的String中删除重复项

49 个答案: