从 Java 中的字符串中删除重复项

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

将字符串转换为字符数组，并将其存储在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

使用Stream可以很容易。

noDuplicates = 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 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

我会使用LinkedHashSet的帮助。 删除 dups（因为我们使用的是 Set，保持我们使用链表 impl 的顺序）。 这是一种肮脏的解决方案。 可能还有更好的方法。

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

Answer 5

这是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 6

创建一个 StringWriter。 在 for 循环中使用 charAt(i) 遍历原始字符串。 维护一个 char 类型的变量，保留最后一个 charAt 值。 如果您进行迭代并且 charAt 值等于该变量中存储的值，则不要添加到 StringWriter。 最后，使用 StringWriter.toString() 方法并获取一个字符串，然后使用它执行您需要的操作。

Answer 7

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

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 8

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

    }
}

如何阅读和谈论上面的代码：

1. 名为 removeDupes 的方法采用名为 arr 的原始字符数组。
2. arr 作为“按值”的原始字符数组返回。 传入的 arr 是在 Main 的成员方法 removeDupes 末尾进行垃圾回收的。
3. 该算法的运行时复杂度是 O(n) 或更具体地说是 O(n+(small constant)) 常量是整个原始字符数组中的唯一字符。
4. copyOfRange 不会显着增加运行时复杂性，因为它只复制少量恒定数量的项目。 称为 arr 的 char 数组并没有完全遍历。
5. 如果将 null 传递给 removeDupes，该方法将返回 null。
6. 如果传递原始字符的空数组或包含一个值的数组，则返回未修改的数组。
7. 方法 removeDupes 在物理上尽可能快地运行，充分利用 L1 和 L2 缓存，因此将分支重定向保持在最低限度。
8. 一台 2015 年标准版的无负担计算机应该能够使用包含 5 亿个字符的原始字符数组在 15 到 25 秒之间完成此方法。

解释这段代码是如何工作的：

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

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

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

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

程序员面试的谈话要点练习：

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

最后的数组副本是否代表另一个“N”通过整个数组，使运行时复杂度 O(n*n) 而不是 O(n) ？ 为什么或者为什么不。

你能用 .equals 替换比较原始字符的双等号吗？ 为什么或者为什么不？

是否可以更改此方法以“通过引用”而不是像现在这样“通过值”进行替换？ 为什么或者为什么不？

您能否通过对 'arr' 开头的唯一值存储库进行排序来提高该算法的效率？ 在什么情况下效率会更高？

Answer 10

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 11

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

字符串 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 12

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 13

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

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 14

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 15

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

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 16

老派方式（因为我们在 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 17

这是我想分享的另一个逻辑。 您从字符串长度的中间开始比较，然后向后进行比较。

测试： input = "azxxzy"; 输出=“是”；

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 18

这是另一种方法

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 19

如果字符串是 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 20

使用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 21

 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 22

    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 23

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 24

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 25

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 26

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

让我们重用set.add(T item)方法的返回值，如果添加成功，同时添加到 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 27

简单的解决方案是遍历给定的字符串并将每个唯一字符放入另一个字符串（在本例中为变量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;
  }

如果输入是madam ，那么输出将是mad 。
如果输入是anagram，则输出将是angrm

希望这可以帮助。
谢谢

Answer 28

为了代码的简单性 - 我采用了硬核输入，也可以使用 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 29

 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 30

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 31

你不能。 您可以创建一个删除重复项的新字符串。 为什么不使用 StringBuilder（或 StringBuffer，大概）？

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

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

Answer 32

希望这会有所帮助。

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 33

'有一个数组来知道一个字符是否已经被记录； 如果没有，请将其添加到字符串缓冲区。 请注意，我已将其区分大小写； 使用 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 34

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 35

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 36

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 37

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 38

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

Answer 39

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 40

 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 41

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 42

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 43

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 44

可以在java中使用HashSet class：

public static String removeDuplicates(String str) {
        char[] chars = str.toCharArray();
        Set<String> set = new HashSet<>();
        for (int i = 0; i < chars.length; i++) {
            set.add(String.valueOf(chars[i]));
        }
       return String.join("", set);
    }

例子：

public class Test {
    public static void main(String[] args) {
        System.out.println(removeDuplicates("aabbccdd")); // abcd
    }
}

Answer 45

使用 Set 集合概念试试这个简单的解决方案： String 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

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

Answer 50

package com.core.interview.client;

import java.util.LinkedHashSet;

import java.util.Scanner;

import java.util.Set;

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