web-dev-qa-db-fra.com

Supprimer les valeurs en double d'une chaîne en java

Quelqu'un peut-il me dire comment supprimer les valeurs en double de

String s="Bangalore-Chennai-NewYork-Bangalore-Chennai";

et la sortie devrait être comme

String s="Bangalore-Chennai-NewYork-";

en utilisant Java ..

Toute aide serait appréciée.

javastringduplicatesduplicate-removal
15
SSG

Cela le fait en une ligne:

public String deDup(String s) {
    return new LinkedHashSet<String>(Arrays.asList(s.split("-"))).toString().replaceAll("(^\\[|\\]$)", "").replace(", ", "-");
}

public static void main(String[] args) {
    System.out.println(deDup("Bangalore-Chennai-NewYork-Bangalore-Chennai"));
}

Sortie:

Bangalore-Chennai-NewYork

Notez que l'ordre est préservé :)

Les points clés sont:

  • split("-") nous donne les différentes valeurs sous forme de tableau
  • Arrays.asList() transforme le tableau en une liste
  • LinkedHashSet préserve l'unicité et ordre d'insertion - il fait tout le travail pour nous donner les valeurs uniques, qui sont transmises via le constructeur
  • la toString() d'une liste est [element1, element2, ...]
  • les dernières commandes replace suppriment la "ponctuation" de la toString()

Cette solution nécessite que les valeurs ne contiennent pas la séquence de caractères ", " - une exigence raisonnable pour un tel code abrégé.

Mise à jour Java 8!

Bien sûr, c'est 1 ligne:

public String deDup(String s) {
    return Arrays.stream(s.split("-")).distinct().collect(Collectors.joining("-"));
}

Regex update!

Si vous ne vous souciez pas de préserver l’ordre (c’est-à-dire que vous pouvez supprimer la première occurrence d’un duplicata):

public String deDup(String s) {
    return s.replaceAll("(\\b\\w+\\b)-(?=.*\\b\\1\\b)", "");
}
35
Bohemian
public static String removeDuplicates(String txt, String splitterRegex)
{
    List<String> values = new ArrayList<String>();
    String[] splitted = txt.split(splitterRegex);
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < splitted.length; ++i)
    {
        if (!values.contains(splitted[i]))
        {
            values.add(splitted[i]);
            sb.append('-');
            sb.append(splitted[i]);
        }
    }
    return sb.substring(1);

}

Usage:

String s = "Bangalore-Chennai-NewYork-Bangalore-Chennai";
s = removeDuplicates(s, "\\-");
System.out.println(s);

Impressions:

Bangalore-Chennai-NewYork
4
Martijn Courteaux

Vous pouvez ajouter vos chaînes à un HashSet.

  1. Fractionner les chaînes sur un "-".
  2. Stockez les mots individuels dans un tableau. c'est-à-dire arr []

Sinppet:

Set<String> set = new HashSet<String>();

    for(int i=0; i < arr.length; i++){
      if(set.contains(arr[i])){
        System.out.println("Duplicate string found at index " + i);
      } else {
        set.add(arr[i]);
      }
2
sgokhales

Juste l'idée:

  1. analyser la chaîne et diviser les jetons à l'aide du séparateur "-"
  2. charge les jetons dans une Collection
  3. itérer la Collection et effacer les doublons
  4. utilisez le résultat Collection pour construire la nouvelle chaîne

La partie la plus délicate devrait être 3, mais pas impossible. Si vous utilisez une Set, vous pouvez ignorer cette étape.

EDITpeut-être que vous pouvez remplacer 2 & 3 par un contrôle de présence avant d'ajouter l'élément

1
ascanio

Créez un tableau de chaînes en divisant par -, puis créez un hashSet à partir de celui-ci.

String s="Bangalore-Chennai-NewYork-Bangalore-Chennai"; 
String[] strArr = s.split("-");
Set<String> set = new HashSet<String>(Arrays.asList(strArr));

Si vous voulez le récupérer sous forme de tableau de chaînes, procédez comme suit:

String[] result = new String[set.size()];
set.toArray(result);

Voici un exemple de code pour le faire:

String s="Bangalore-Chennai-NewYork-Bangalore-Chennai"; 
String[] strArr = s.split("-");
Set<String> set = new LinkedHashSet<String>(Arrays.asList(strArr));
String[] result = new String[set.size()];
set.toArray(result);
StringBuilder res = new StringBuilder();
for (int i = 0; i < result.length; i++) {
    String string = result[i];
    if(i==result.length-1)
        res.append(string);
    else
        res.append(string).append("-");
}
System.out.println(res.toString());

Sortie:-

Bangalore-Chennai-NewYork
1
Harry Joy
static String RemoveDuplicateCharInString(String s){
    for (int i = 0; i < s.length(); i++) {
        if((s.substring(i+1)).indexOf(s.charAt(i))!=-1){
            s=s.substring(0,i+1)+(s.substring(i+1)).replaceAll(""+s.charAt(i),"");
        }
    }
    return s;
}
1
raj neeraj
public class RemDuplicateWordFromString {
public static void main(String[] args) {
    String s1 = "Hello India Hello India Hello India Hello India";
    countWords(s1);
}
public static void countWords(String s1) {
    String[] s2 = s1.split(" ");
    for (int i = 0; i < s2.length; i++) {
        for (int j = i + 1; j < s2.length; j++) {
            if (s2[i].equals(s2[j])) {
                if (i != j) {
                    s2[i] = "";
                }
            }
        }
    }
    for (int i = 0; i < s2.length; i++) {
        if (s2[i] != "") {
            System.out.print(s2[i] + " ");
        }

    }

}

}

0
Manash Ranjan Dakua
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();
0
venkat
wordsArray = s.split("-");
List<String> wordsList = new Arrays.asList(wordsArray);
Set<String>  wordsSet  = new LinkedHashSet<String>(wordsList);

String[] noDuplicates = new String[wordsSet.size()];
wordsSet.toArray(noDuplicates);
0
Hunter McMillen

Je préférerais ce qui est plus simple que tout ce qui précède.

public void removeDuplicates() {
  String myString = "Bangalore-Chennai-NewYork-Bangalore-Chennai";

  String[] array = myString.split("-");

  Set<String> hashSet = new HashSet<String>(Arrays.asList(array));

  String newString = StringUtils.join(hashSet, "-");        
}
0
Aaron Chambers
public static void main(String[] args) {
    String str="Bangalore-Chennai-Newyork-Bangalore-Chennai";
    String output="";
    String [] arr=str.split("-");

    LinkedHashSet<String> lhs=new LinkedHashSet<String>();
    for (int i = 0; i < arr.length; i++) {
        lhs.add(arr[i]);
    }
    for(String s:lhs){
        output=output+s+"-";
    }

    System.out.println(output);
}
0
RAJESHPODDER007

Un peu tard dans le jeu, mais j'utiliserais simplement un HashMap. C'est facile à comprendre et il y a des recherches rapides sur les touches, ce n'est peut-être pas la meilleure solution, mais c'est quand même une bonne réponse, IMO. Je l'utilise tout le temps quand j'ai besoin de formater rapidement et de manière sale:

                    String reason = "Word1 , Word2 , Word3";
                    HashMap<String,String> temp_hash = new HashMap<String,String>();
                    StringBuilder reason_fixed = new StringBuilder();
                    //in:
                    for(String Word : reason.split(",")){
                        temp_hash.put(Word,word);
                    }
                    //out:
                    for(String words_fixed : temp_hash.keySet()){
                        reason_fixed.append(words_fixed + " , ");
                    }
                    //print:
                    System.out.println(reason_fixed.toString());
0
Petro