Comment calculer le nombre de Valeurs Uniques dans une ArrayList?

Je dois compter le nombre de mots uniques à partir d'un document texte à l'aide de Java. J'ai d'abord dû se débarrasser de la ponctuation dans tous les mots. J'ai utilisé le Scanner classe à l'analyse de chaque mot dans le document et de le placer dans une Chaîne de ArrayList.

Donc, la prochaine étape est l'endroit où je vais avoir le problème! Comment puis-je créer une méthode qui peut compter le nombre de Chaînes uniques dans le tableau?

Par exemple, si le tableau contient des apple, bob, apple, jim, bob; le nombre de valeurs uniques dans ce tableau est de 3.

public countWords() {
    try {
        Scanner scan = new Scanner(in);
        while (scan.hasNext()) {
            String words = scan.next();
            if (words.contains(".")) {
                words.replace(".", "");
            }
            if (words.contains("!")) {
                words.replace("!", "");
            }
            if (words.contains(":")) {
                words.replace(":", "");
            }
            if (words.contains(",")) {
                words.replace(",", "");
            }
            if (words.contains("'")) {
                words.replace("?", "");
            }
            if (words.contains("-")) {
                words.replace("-", "");
            }
            if (words.contains("‘")) {
                words.replace("‘", "");
            }
            wordStore.add(words.toLowerCase());
        }
    } catch (FileNotFoundException e) {
        System.out.println("File Not Found");
    }
    System.out.println("The total number of words is: " + wordStore.size());
}

Il y a aucune restriction à ce que vous pouvez ou ne pouvez pas l'utiliser?
ne leurs sont pas de restrictions!

OriginalL'auteur | 2012-10-04

19

Êtes-vous autorisé à utiliser Ensemble? Si oui, vous HashSet peut résoudre votre problème. HashSet n'accepte pas les doublons.
```
HashSet noDupSet = new HashSet();
noDupSet.add(yourString);
noDupSet.size();
```
size() méthode renvoie le nombre de mots uniques.

Si vous devez vraiment utiliser ArrayList seulement, alors un moyen d'atteindre peut-être,
```
1) Create a temp ArrayList
2) Iterate original list and retrieve element
3) If tempArrayList doesn't contain element, add element to tempArrayList
```
Oui, je suis autorisé à utiliser HashSet. Pouvez vous s'il vous plaît me montrer comment utiliser HashSet?
Voir ma réponse mis à jour.
Je n'ai pas de liste de tableaux seulement, je peux utiliser tout ce qui fonctionne. Puis-je démarrent des instances d'une nouvelle HashSet et ajouter toutes les valeurs de chaîne à partir de la liste de tableaux?
Oui, vous pouvez (ou) vous pouvez directement ajouter des éléments à Définir, de cette façon, vous n'avez même pas besoin de liste de tableaux.

OriginalL'auteur kosa
12

À partir de Java 8 vous pouvez utiliser Stream:

Après l'ajout d'éléments dans votre ArrayList:
```
long n = wordStore.stream().distinct().count();
```
Il convertit votre ArrayList à un jet et puis il ne compte que les éléments distincts.

OriginalL'auteur ROMANIA_engineer
3

Je voudrais des conseils pour utiliser HashSet. Ce filtre automatiquement les doublons lors de l'appel de add méthode.

OriginalL'auteur Yogendra Singh
2

Bien que je crois qu'un ensemble est la solution la plus simple, vous pouvez toujours utiliser votre solution originale et juste ajouter une instruction if pour vérifier si une valeur existe déjà dans la liste avant de faire votre ajouter.
```
if( !wordstore.contains( words.toLowerCase() )
   wordStore.add(words.toLowerCase());
```
Puis le nombre de mots dans votre liste est le nombre total de mots uniques (c'est à dire: wordStore.size() )

Merci pour votre aide! - N'est-ce pas HashSet plus efficace, car elle ne permet pas aux précédentes valeurs par défaut.
Absolument qu'il devrait être. Cependant, je voulais vous donner une option qui ne serait pas vous amener à modifier votre code existant. Vraiment, vous étiez juste en manque une instruction "if".

OriginalL'auteur Eric B.

En sténographie façon, vous pouvez le faire comme suit...

    ArrayList<String> duplicateList = new ArrayList<String>();
    duplicateList.add("one");
    duplicateList.add("two");
    duplicateList.add("one");
    duplicateList.add("three");

    System.out.println(duplicateList); //prints [one, two, one, three]

    HashSet<String> uniqueSet = new HashSet<String>();

    uniqueSet.addAll(duplicateList);
    System.out.println(uniqueSet); //prints [two, one, three]

    duplicateList.clear();
    System.out.println(duplicateList);//prints []


    duplicateList.addAll(uniqueSet);
    System.out.println(duplicateList);//prints [two, one, three]

Personnellement, je ne comprends pas pourquoi je voudrais utiliser votre méthode abrégée. Je pouvais créer une boucle pour ajouter la Chaîne de valeurs à l'intérieur de la HashSet; le HashSet n'autorise pas les précédentes valeurs par défaut.
Ici, j'ai mentionné à l'écart de l'extrait de l'unique vaues de la liste du réseau. La pensée de la méthode abrégée est pratique à utiliser. Mais il est de votre préférence pour sélectionner le meilleur methos... 🙂
Très joli, merci pour le partage!

OriginalL'auteur namalfernandolk

0

Vous pouvez créer une table de hachage ou une table de hachage. Clés seraient vos chaînes d'entrée et la Valeur serait le nombre de fois que la chaîne se produit dans votre tableau d'entrée. O(N) le temps et l'espace.

Solution 2:

Trier la liste d'entrée.
Des chaînes similaires serait à côté de l'autre.
La liste de comparaison(i) à la liste de la(i+1) et de compter le nombre de doublons.

OriginalL'auteur FSP

public class UniqueinArrayList {

    public static void main(String[] args) { 
        StringBuffer sb=new StringBuffer();
        List al=new ArrayList();
        al.add("Stack");
        al.add("Stack");
        al.add("over");
        al.add("over");
        al.add("flow");
        al.add("flow");
        System.out.println(al);
        Set s=new LinkedHashSet(al);
        System.out.println(s);
        Iterator itr=s.iterator();
        while(itr.hasNext()){
            sb.append(itr.next()+" ");
        }
        System.out.println(sb.toString().trim());
    }

}

OriginalL'auteur S N Prasad Rao

0

Cette finalité générale de la solution tire parti du fait que le Jeu de type abstrait de données ne permet pas de doublons. Le Set.méthode add() est particulièrement utile en ce qu'elle renvoie un drapeau booléen indiquant le succès de la 'ajouter' opération. Une table de hachage est utilisée pour suivre l'occurrence de chaque élément d'origine. Cet algorithme peut être adapté pour des variations de ce type de problème. Cette solution produit O(n) performance..
```
public static void main(String args[])
{
  String[] strArray = {"abc", "def", "mno", "xyz", "pqr", "xyz", "def"};
  System.out.printf("RAW: %s ; PROCESSED: %s \n",Arrays.toString(strArray), duplicates(strArray).toString());
}

public static HashMap<String, Integer> duplicates(String arr[])
{

    HashSet<String> distinctKeySet = new HashSet<String>();
    HashMap<String, Integer> keyCountMap = new HashMap<String, Integer>();

    for(int i = 0; i < arr.length; i++)
    {
        if(distinctKeySet.add(arr[i]))
            keyCountMap.put(arr[i], 1); //unique value or first occurrence
        else
            keyCountMap.put(arr[i], (Integer)(keyCountMap.get(arr[i])) + 1);
    }     

    return keyCountMap; 
} 
```
RÉSULTATS:

RAW: [abc, def mno, xyz, pqr, xyz, def] ; TRAITEMENT: {pqr=1, abc=1, def=2, xyz=2, mno=1}

Êtes-vous réellement en citant quelque chose? Si vous ne l'êtes pas, n'utilisez pas de citer la mise en forme. Si vous citez quelque chose, vous devez attribuer correctement.
Ce 4 ans question a déjà une réponse à l'aide de HashSet pour O(1) de la performance. Votre algorithme pour le comptage des occurrences de mots dans un tableau de chaînes, de ne pas répondre à l'OP de la question (vous n'êtes pas de comptage de valeurs uniques dans une ArrayList); ni le fait d'améliorer la solution courante. Peut-être que vous avez mal compris la question?
Merci pour les commentaires. Je m'excuse pour la confusion. Je voulais simplement faire part d'une solution pour le comptage des éléments distincts dans un tableau que j'ai trouvé intéressant et différent, et pourrait peut-être être utile à quelqu'un d'autre dans l'avenir qui peut être la recherche de solutions à un problème similaire. Je devrais probablement avoir ajouté la solution la plus appropriée fil.

OriginalL'auteur Casmon Gordon

3 solutions possibles:

Utilisation HashSet comme suggéré ci-dessus.

Créer un temporaire ArrayList et de stocker seul et unique élément, comme ci-dessous:

public static int getUniqueElement(List<String> data) {
    List<String> newList = new ArrayList<>();
    for (String eachWord : data)
    if (!newList.contains(eachWord))
        newList.add(eachWord);
    return newList.size();
}

Java 8 solution

long count = data.stream().distinct().count();

OriginalL'auteur ChandraBhan Singh

Vous devez vous connecter pour publier un commentaire.