comment supprimer le caractère en double d'une chaîne

Question

Le problème me demande d'écrire une méthode pour supprimer les caractères dupliqués de la chaîne d'origine et renvoyer la nouvelle chaîne. Par exemple, la chaîne d'origine est abracadabra et le résultat doit être abrcd.

Je pensais utiliser StringBuilder pour supprimer le caractère, mais quelque chose s'est mal passé quand j'ai essayé d'exécuter le code. quelqu'un peut-il m'aider à le réparer.

public static String eliminateDuplicates(String str){ 
    String result = ""; 
    StringBuilder strings = new StringBuilder(str); 
    for(int i = 0; i<str.length(); i++){ 
     for(int j = 1; j<str.length();j++){ 
      if(str.charAt(i)==str.charAt(j)){ 
       strings.deleteCharAt(j); 
      } 
     } 
    } 
    result = strings.toString(); 
    return result; 
} 

Answer 1

Essayez ce code, peut-être votre peut optimiser:

public static String eliminateDuplicates(String source) { 
    StringBuilder result = new StringBuilder(); 
    for (int i = 0, sLength = source.length(); i < sLength; i++) { 
     char readyToAdd = source.charAt(i); 
     boolean add = true; 

     for (int j = 0; j < result.length(); j++) { 
      if (readyToAdd == result.charAt(j)) { 
       add = false; 
       break; 
      } 
     } 

     if (add) result.append(readyToAdd); 
    } 

    return result.toString(); 
} 

Answer 2

Le code en question est itérez chaîne d'entrée, mais en utilisant l'index pour supprimer des caractères de l'objet générateur de chaîne.

Chaque fois que le générateur de chaîne supprime le caractère, sa taille diminue. Ainsi, votre code échouera avec IndexOutofBoundsException. Veuillez ajouter la trace entière de la pile de l'exception dans la question pour confirmer, si c'est le cas.

Une meilleure approche pour supprimer des doublons consiste à créer une autre chaîne en itérant sur la chaîne d'entrée, puis en ne copiant que les caractères uniques de la nouvelle chaîne. La nouvelle chaîne peut ensuite être retournée en conséquence.

Cela aura également une meilleure complexité temporelle de O(n*m) par rapport au code actuel qui avait la complexité temporelle de O(n*n)

Answer 3

Essayez ceci.

public static String eliminateDuplicates(String str){ 
    int[] uniq = str.codePoints().distinct().toArray(); 
    return new String(uniq, 0, uniq.length); 
} 

Answer 4

En utilisant @ l'idée de PJ

public static String eliminateDuplicates(String str) { 
    HashSet<Character> hashSet = new HashSet(); 
    //A hashSet is a collection that only adds unique elements. 

    char[] toCharArray = str.toCharArray(); 
    for (char c : toCharArray) { 
     hashSet.add(c); 
    } 

    StringBuilder answer = new StringBuilder(); 
    for (Character character : hashSet) { 
     answer.append(character); 
    } 

    return answer.toString(); 
} 

Answer 5

Essayez cette

public static String eliminateDuplicates(String str){ 
    StringBuilder result = new StringBuilder(); 
    BitSet bs=new BitSet(256); 
    char[] chars=str.toCharArray(); 
    char getChar=0; 
    for(int i=0;i<chars.length;i++){ 
     getChar=chars[i]; 
     if(!bs.get(getChar)){ 
      result.append(getChar); 
      bs.set(getChar); 
     } 
    } 
    return result.toString(); 
}