Supprimer les doublons de valeurs à partir d'une chaîne de caractères en java

Quelqu'un peut s'il vous plaît laissez-moi savoir comment faire pour supprimer les valeurs en double à partir de

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

et de sortie devrait être comme

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

à l'aide de Java..

Toute aide serait appréciée.

Bien sûr, vous voulez le "-" à la fin de la suite?

OriginalL'auteur SSG | 2011-07-22

33

Ce fait en une seule 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"));
}
```
De sortie:
```
Bangalore-Chennai-NewYork
```
Avis que l'ordre est préservé 🙂

Points clés sont:
- split("-") nous donne les différentes valeurs dans un tableau
- Arrays.asList() transforme le tableau en une Liste
- LinkedHashSet préserve l'unicité et ordre d'insertion - elle fait tout le travail de nous donner les valeurs uniques, qui sont passés par le constructeur
- la toString() d'une Liste est [element1, element2, ...]
- la finale replace commandes de supprimer la "ponctuation" de la toString()
Cette solution nécessite que les valeurs ne contiennent la séquence de caractères ", " - une exigence raisonnable pour une telle laconique code.

Java 8 Update!

Bien sûr, c'est 1 ligne:
```
public String deDup(String s) {
    return Arrays.stream(s.split("-")).distinct().collect(Collectors.joining("-"));
}
```
Regex mise à jour!

Si vous n'avez pas de soins sur le maintien de l'ordre (c'est à dire que c'est OK pour supprimer le première survenance d'un doublon):
```
public String deDup(String s) {
    return s.replaceAll("(\\b\\w+\\b)-(?=.*\\b\\\b)", "");
}
```
Coupe des crochets aurais-je le faire à l'aide de la fonction substring(), et de le faire sur deux lignes au lieu.
vous pourriez briser ce en plusieurs lignes, mais cette réponse est aussi une démonstration de la façon dont il peut être fait en une seule ligne.

OriginalL'auteur 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);

}

Utilisation:

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

Imprime:

Bangalore-Chennai-NewYork

OriginalL'auteur Martijn Courteaux

2

Vous pouvez ajouter vos chaînes à un HashSet.
1. Diviser les cordes d'un "-".
2. Stocker les mots dans le Tableau. j'.e 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]);
      }
```
Ou un LinkedHashSet de conserver l'original de l'ordre
Grâce a été d'une grande aide......
Allez, êtes-vous pour de vrai? Vous êtes de la vérification pour voir si la Chaîne est déjà dans le Jeu. Mais le point de l'ensemble d'un Ensemble, c'est qu'il ne contient pas de doublons. Que du code redondant!!!

OriginalL'auteur sgokhales

Créer la matrice de chaîne en crève par - et puis créer un hashSet.

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

Si vous voulez revenir comme tableau de chaîne puis effectuer les opérations suivantes:

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

Voici un exemple de code pour ce 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());

De sortie:-

Bangalore-Chennai-NewYork

OriginalL'auteur Harry Joy

1

Juste l'idée:
1. analyser la chaîne et de diviser les jetons en utilisant le séparateur "-"
2. de charger les tokens dans un Collection
3. de réitérer la Collection et d'effacer les doublons
4. utiliser le résultat Collection à la construction de la nouvelle chaîne de
La partie la plus délicate devrait être de 3, mais pas impossible. Si vous utilisez un Set, vous pouvez sauter cette étape.

MODIFIER peut-être vous pouvez remplacer 2&3 avec une présence de vérifier avant l'ajout de l'élément

OriginalL'auteur ascanio

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;
}

Il faut vous dire quelques mots au sujet de votre solution de code et comment il répond à l'OPs question, de sorte qu'ils peuvent comprendre, plutôt que de simplement poster du code.

OriginalL'auteur raj neeraj

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

OriginalL'auteur Hunter McMillen

Je préfère ce qui est plus simple que tous les ci-dessus.

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

Un -1? Pour quoi?

OriginalL'auteur 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);
}

Il serait bon d'expliquer ce que la solution serait, plutôt que de simplement coller le code de la solution.

OriginalL'auteur RAJESHPODDER007

Un peu tard pour le jeu, mais je voudrais simplement utiliser une HashMap. C'est facile à comprendre et a rapidement des recherches sur les touches, peut-être pas la meilleure façon mais c'est toujours une bonne réponse de l'OMI. Je l'utilise tout le temps quand j'ai besoin de format rapide et 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());

OriginalL'auteur Petro

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] + " ");
        }

    }

}

}

OriginalL'auteur 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();

Merci de ne pas poster des blocs de code sans contexte - comprendre une explication ainsi

OriginalL'auteur venkat

-1

import java.util.HashSet;

public class SplitString {
    public static void main(String[] args) {
        String st = new String("New Delhi-Chennai-New York-Bangalore-Chennai-New Delhi-Chennai-New York");
        StringBuffer stb = new StringBuffer();

        HashSet<String> hashset = new HashSet<String>();
        for (String a : st.split("-"))
            hashset.add(a);

        Object[] str = (Object[]) hashset.toArray();

        for (int i = 0; i < str.length; i++) {
            stb.append(str[i]);

            if (i < str.length - 1)
                stb.append("-");

        }

        System.out.println(stb);
    }
}

OriginalL'auteur sushil kumar bhaskar

-2

import java.util.*;

public class RemoveDuplicateWord {

    public static void main(String[] args) {
        String str = "Hai hello Hai how hello are how you";
        removeDupWord(str);
    }

    public static void removeDupWord(String input) {
        List<String> list = Arrays.asList(input.split(" "));
        LinkedHashSet<String> lhs = new LinkedHashSet<String>(list);
        for(String s : lhs) {
            System.out.print(s+" ");
        }                   
    }
}

J'espère que cela fonctionnera certainement,,,

OriginalL'auteur Abdullah...

Vous devez vous connecter pour publier un commentaire.

Java 8 Update!

Regex mise à jour!