Cómo eliminar duplicados de caracteres de una cadena en java?

Probar este método…debería funcionar bien!

String removeDup() 
{         
   getMode();
   int i;
   int j;
   String rdup = "";

   for (i = 0; i< s.length(); i++) {
       int count = 1;

       for (j = i+1; j < s.length(); j++) {
           if (s.charAt(i) == s.charAt(j)) {
                count++;
           }
       }
       if (count == 1){
           rdup += s.charAt(i);
       }
   } 
     // System.out.print(rdup);
   System.out.println();
   return rdup;
}

Bienvenido a StackOverflow!

Estás llamando getMode() tanto en el exterior como en el interior de removeDup(), que es por qué es la impresión dos veces.

Con el fin de eliminar todos duplicados, tendrá que llamar a removeDup() más y más hasta que todos los duplicados se ha ido de su cadena. Ahora sólo estás llamando a la vez.

¿Cómo podría hacer eso? Piense acerca de cómo está la detección de duplicados, y usar eso como la condición final para un while bucle o similar.

Feliz codificación!

¿No debería esto ser una manera más fácil? Además, todavía estoy aprendiendo.

import java.util.*;

public class First {

public static void main(String arg[])
{
    Scanner sc= new Scanner(System.in);
    StringBuilder s=new StringBuilder(sc.nextLine());        
    //String s=new String();
    for(int i=0;i<s.length();i++){
        String a=s.substring(i, i+1);
        while(s.indexOf(a)!=s.lastIndexOf(a)){s.deleteCharAt(s.lastIndexOf(a));}
    }
    System.out.println(s.toString());
}
}

Usted puede hacer esto:

public static void main(String[] args) {
    String str = new String("PINEAPPLE");
    Set <Character> letters = new <Character>HashSet();

    for (int i = 0; i < str.length(); i++) {
        letters.add(str.charAt(i));
    }
    System.out.println(letters);
}

Creo que una versión optimizada que soporta códigos ASCII puede ser como este:

public static void main(String[] args) {
    System.out.println(removeDups("*PqQpa abbBBaaAAzzK zUyz112235KKIIppP!!QpP^^*Www5W38".toCharArray()));
}
public static String removeDups(char []input){
    long ocr1=0l,ocr2=0l,ocr3=0;
    int index=0;
    for(int i=0;i<input.length;i++){
        int val=input[i]-(char)0;
        long ocr=val<126?val<63?ocr1:ocr2:ocr3;
        if((ocr& (1l<<val))==0){//not duplicate
            input[index]=input[i];
            index++;
        }
        if(val<63)
            ocr1|=(1l<<val);
        else if(val<126)
            ocr2|=(1l<<val);
        else 
            ocr3|=(1l<<val);
    }
    return new String(input,0,index);
}

por favor, tenga en cuenta que cada uno de orc(s) representan una asignación de un rango de caracteres ASCII y cada java largo variable puede crecer tan grande como (2^63) y ya tenemos 128 caracteres en ASCII, así que tenemos tres ocr(s) que, básicamente, los mapas de las apariciones de los caracteres a un número largo.

• ocr1: (char)0 a (char)62
• ocr2: (char)63 a (char)125
• ocr3: (char)126 (char)128

Ahora si es un duplicado de la

(ocr& (1l<<val)) 

será mayor que cero y nos saltamos ese char y, finalmente, podemos crear una nueva cadena con el tamaño de índice que muestra el pasado de no duplicar los elementos del índice.
Puede definir más orc(s) y el apoyo de los demás-conjuntos de caracteres si desea.

Puede usar HashSet así como normal para los bucles:

public class RemoveDupliBuffer 
{
public static String checkDuplicateNoHash(String myStr)
{
    if(myStr == null)
        return null;
    if(myStr.length() <= 1)
        return myStr;

    char[] myStrChar = myStr.toCharArray();
    HashSet myHash = new HashSet(myStrChar.length);
    myStr = "";

    for(int i=0; i < myStrChar.length ; i++)
    {
        if(! myHash.add(myStrChar[i]))
        {

        }else{
            myStr += myStrChar[i];
        }
    }
    return myStr;
}

public static String checkDuplicateNo(String myStr) 
{
    //null check
    if (myStr == null)
        return null;
    if (myStr.length() <= 1)
        return myStr;

    char[] myChar = myStr.toCharArray();
    myStr = "";
    int tail = 0;
    int j = 0;

    for (int i = 0; i < myChar.length; i++) 
    {
        for (j = 0; j < tail; j++)
        {
            if (myChar[i] == myChar[j])
            {
                break;
            }
        }
        if (j == tail)
        {
            myStr += myChar[i];
            tail++;
        }
    }

    return myStr;
}

public static void main(String[] args) {
    String myStr = "This is your String";
    myStr = checkDuplicateNo(myStr);
    System.out.println(myStr);
}

Probar esta simple respuesta – funciona bien para una simple cadena de caracteres que acepta como entrada del usuario:

importar java.util.Escáner;

clase pública string_duplicate_char {

String final_string = "";

public void inputString() {

    //accept string input from user
    Scanner user_input = new Scanner(System.in);
    System.out.println("Enter a String to remove duplicate Characters : \t");
    String input = user_input.next();
    user_input.close();

    //convert string to char array
    char[] StringArray = input.toCharArray();
    int StringArray_length = StringArray.length;

    if (StringArray_length < 2) {
        System.out.println("\nThe string with no duplicates is: "
                + StringArray[1] + "\n");
    } else {
        //iterate over all elements in the array
        for (int i = 0; i < StringArray_length; i++) {

            for (int j = i + 1; j < StringArray_length; j++) {

                if (StringArray[i] == StringArray[j]) {
                    int temp = j;//set duplicate element index

                    //delete the duplicate element by copying the adjacent elements by one place
                    for (int k = temp; k < StringArray_length - 1; k++) {
                        StringArray[k] = StringArray[k + 1];
                    }
                    j++;
                    StringArray_length--;//reduce char array length

                }
            }

        }

    }

    System.out.println("\nThe string with no duplicates is: \t");

    //print the resultant string with no duplicates
    for (int x = 0; x < StringArray_length; x++) {

        String temp= new StringBuilder().append(StringArray[x]).toString();
        final_string=final_string+temp;
    }
    System.out.println(final_string);

}

public static void main(String args[]) {

    string_duplicate_char object = new string_duplicate_char();
    object.inputString();

}

}

Otra solución fácil para recortar los elementos duplicados en una cadena con HashSet y ArrayList :

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class sample_work {

    public static void main(String args[]) {

        String input = "";

        System.out.println("Enter string to remove duplicates: \t");
        Scanner in = new Scanner(System.in);
        input = in.next();
        in.close();

        ArrayList<Character> String_array = new ArrayList<Character>();
        for (char element : input.toCharArray()) {
            String_array.add(element);
        }

        HashSet<Character> charset = new HashSet<Character>();
        int array_len = String_array.size();
        System.out.println("\nLength of array = " + array_len);

        if (String_array != null && array_len > 0) {
            Iterator<Character> itr = String_array.iterator();
            while (itr.hasNext()) {
                Character c = (Character) itr.next();
                if (charset.add(c)) {

                } else {
                    itr.remove();
                    array_len--;
                }
            }
        }
        System.out.println("\nThe new string with no duplicates: \t");
        for (int i = 0; i < array_len; i++) {
            System.out.println(String_array.get(i).toString());
        }
    }

}

puede utilizar este código simple y entender cómo quitar valores duplicados de una cuerda.Creo que esta es la manera más sencilla de entender este problema.

clase RemoveDup
{

static int l;
public String dup(String str)
{

l=str.length();
System.out.println("length"+l);
char[] c=str.toCharArray();

for(int i=0;i<l;i++)
{

    for(int j=0;j<l;j++)
    {
        if(i!=j)
        {   
        if(c[i]==c[j])
        {
            l--;
            for(int k=j;k<l;k++)
            {
        c[k]=c[k+1];
            }
            j--;
        }
        }
    }


}

System.out.println("after concatination lenght:"+l);
StringBuilder sd=new StringBuilder();
for(int i=0;i<l;i++)
{
    sd.append(c[i]);

}
str=sd.toString();
return str;
}



public static void main(String[] ar)
{
RemoveDup obj=new RemoveDup();
Scanner sc=new Scanner(System.in);
String st,t;
System.out.println("enter name:");
st=sc.nextLine();
sc.close();
t=obj.dup(st);
System.out.println(t);
}

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package javaapplication26;

import java.util.*;

/**
 *
 * @author THENNARASU
 */
public class JavaApplication26 {

    public static void main(String[] args) {


   int i,j,k=0,count=0,m;

    char a[]=new char[10];

       char b[]=new char[10]; 

    Scanner ob=new Scanner(System.in);

    String str;

    str=ob.next();

    a=str.toCharArray();

    int c=str.length();


    for(j=0;j<c;j++)

   {

        for(i=0;i<j;i++)

        {

            if(a[i]==a[j])

            {

                count=1;


            }

        }

         if(count==0)

        {

            b[k++]=a[i];

        }

        count=0;

    }

   for(m=0;b[m]!='\0';m++)

   {


System.out.println(b[m]);

        }

        }


    }

escribí este programa. Estoy usando 2 char matrices lugar. Puede definir el número de duplicados de los caracteres que desea eliminar de la cadena original y también muestra el número de ocurrencias de cada carácter en la cadena.

 public String removeMultipleOcuranceOfChar(String string, int numberOfChars){
     char[] word1 = string.toCharArray();
     char[] word2 = string.toCharArray();
     int count=0;         
     StringBuilder builderNoDups = new StringBuilder();
     StringBuilder builderDups = new StringBuilder();

     for(char x: word1){             
         for(char y : word2){
             if (x==y){
                 count++;
             }//end if                  
         }//end inner loop            
         System.out.println(x + " occurance: " + count );
         if (count ==numberOfChars){
             builderNoDups.append(x);                 
         }else{
             builderDups.append(x);
         }//end if else
         count = 0;             
     }//end outer loop
     return String.format("Number of identical chars to be in or out of input string: "
             + "%d\nOriginal word: %s\nWith only %d identical chars: %s\n"
             + "without %d identical chars: %s",
             numberOfChars,string,numberOfChars, builderNoDups.toString(),numberOfChars,builderDups.toString());
}

Probar esta sencilla solución para la ELIMINACIÓN de CARACTERES DUPLICADOS/CARTAS DE CADENA DADA

import java.util.Scanner;

public class RemoveDuplicateLetters {

public static void main(String[] args) {

    Scanner scn=new Scanner(System.in);
    System.out.println("enter a String:");
    String s=scn.nextLine();
    String ans="";

           while(s.length()>0)
        {
           char ch = s.charAt(0);
            ans+= ch;
            s = s.replace(ch+"",""); //Replacing all occurrence of the current character by a spaces
        }
    System.out.println("after removing all duplicate letters:"+ans);
    }
  }