Comment compter le nombre d'occurrences d'un élément dans une Liste

J'ai un ArrayList, une Collection de classes de Java, comme suit:

ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");

Comme vous pouvez le voir, le animals ArrayList se compose de 3 bat éléments et un owl élément. Je me demandais si il existe une API dans le cadre de Collecte qui renvoie le nombre de bat occurrences ou si il y a une autre façon de déterminer le nombre d'occurrences.

J'ai constaté que Google Collecte Multiset possède une API qui renvoie le nombre d'occurrences d'un élément. Mais qui est uniquement compatible avec le JDK 1.5. Notre produit est actuellement en JDK 1.6, donc je ne peux pas l'utiliser.

C'est une des raisons pourquoi vous devez programmer une interface plutôt qu'une mise en œuvre. Si vous arrivez à trouver la bonne collection, vous devez changer le type d'utilisation que de la collection. Je vais poster une réponse sur ce.

InformationsquelleAutor MM. | 2009-02-03

300

Je suis sûr que la statique de la fréquence de la méthode dans les Collections seraient utiles ici:
```
int occurrences = Collections.frequency(animals, "bat");
```
C'est la façon dont je le ferais de toute façon. Je suis assez sûr que c'est jdk 1.6 vers le haut.
- Préférez toujours l'Api de JRE, qui ajoutent une autre dépendance pour le projet. Et ne pas Réinventer la roue !!
- Il a été introduit dans le JDK 5 (bien que personne n'utilise une version avant que cela n'a pas d'importance) docs.oracle.com/javase/8/docs/technotes/guides/collections/...
InformationsquelleAutor Lars Andren
80

Dans Java 8:
```
Map<String, Long> counts =
    list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
```
- À L'Aide De La Fonction.identity() (statiques import) au lieu de e -> e rend un peu plus agréable à lire.
- Pourquoi est-ce mieux que Collections.frequency()? Il semble de moins en moins lisible.
- Ce n'est pas ce qui était demandé. Il n'a plus de travail que nécessaire.
- Cela peut faire plus que ce qui était demandé, mais c'est justement ce que je voulais (obtenir une carte des éléments distincts dans une liste à leur compte). En outre, cette question a été le premier résultat dans Google quand j'ai cherché.
- Vous obtenez tous les chefs en une seule passe.
- si vous disposez déjà d'un cours d'eau, vous n'avez pas à collecter puis d'appliquer des Collections.fréquence, mais de mettre tout en un seul passage.
InformationsquelleAutor Vitalii Fedorenko
22

Cette montre, pourquoi il est important de "Faire référence à des objets par leurs interfaces" comme décrit dans la Efficace Java livre.

Si vous le code pour la mise en œuvre et utiliser ArrayList dans, disons, 50 places dans votre code, lorsque vous trouvez une bonne "Liste" de mise en œuvre qu'à compter les objets, vous devrez modifier tous les personnes de plus de 50 places, et probablement vous aurez à casser votre code ( si il n'est utilisé que par vous il n'y a pas une grosse affaire, mais si il est utilisé par quelqu'un d'autre l'utilise, vous aurez briser leur code de trop)

Par la programmation de l'interface, vous pouvez laisser ces 50 places inchangé et remplacer la mise en œuvre de ArrayList pour "CountItemsList" (par exemple ) ou d'une autre classe.

Ci-dessous est un exemple très simple sur la façon dont cela pourrait être écrit. Ce n'est qu'un échantillon, un prêt pour la production de la Liste serait beaucoup plus compliqué.
```
import java.util.*;

public class CountItemsList<E> extends ArrayList<E> { 

    //This is private. It is not visible from outside.
    private Map<E,Integer> count = new HashMap<E,Integer>();

    //There are several entry points to this class
    //this is just to show one of them.
    public boolean add( E element  ) { 
        if( !count.containsKey( element ) ){
            count.put( element, 1 );
        } else { 
            count.put( element, count.get( element ) + 1 );
        }
        return super.add( element );
    }

    //This method belongs to CountItemList interface ( or class ) 
    //to used you have to cast.
    public int getCount( E element ) { 
        if( ! count.containsKey( element ) ) {
            return 0;
        }
        return count.get( element );
    }

    public static void main( String [] args ) { 
        List<String> animals = new CountItemsList<String>();
        animals.add("bat");
        animals.add("owl");
        animals.add("bat");
        animals.add("bat");

        System.out.println( (( CountItemsList<String> )animals).getCount( "bat" ));
    }
}
```
OO principes appliqués ici: l'héritage, le polymorphisme, l'abstraction, l'encapsulation.
- Eh bien il faut toujours essayer de composition plutôt que de l'héritage. Votre application est maintenant collé à ArrayList lorsqu'il peut y avoir des moments que vous voulez une LinkedList ou autres. Votre exemple aurait du prendre une autre Liste dans son constructeur/l'usine et a renvoyé un wrapper.
- Je suis entièrement d'accord avec vous. La raison, j'ai utilisé l'héritage de l'échantillon est parce qu'il est beaucoup plus facile de montrer un exemple, l'utilisation de l'héritage que la composition ( le fait de devoir mettre en œuvre la Liste de l'interface ). L'héritage crée le plus élevé de couplage.
- Mais en le nommant CountItemsList vous implique qu'il fait deux choses, il compte les éléments et c'est une liste. Je pense qu'une seule et unique responsabilité de cette classe, le comptage des occurrences, serait aussi simple et vous n'avez pas besoin de mettre en œuvre la Liste de l'interface.
InformationsquelleAutor OscarRyz
11

Désolé il n'y a pas simple appel de méthode qui peut le faire. Tout vous devez faire est de créer une carte et de fréquence de comptage avec elle.
```
HashMap<String,int> frequencymap = new HashMap<String,int>();
foreach(String a in animals) {
  if(frequencymap.containsKey(a)) {
    frequencymap.put(a, frequencymap.get(a)+1);
  }
  else{ frequencymap.put(a, 1); }
}
```
- Ce n'est vraiment pas une solution évolutive - imaginer MM ensemble de données de l'eu des centaines et des milliers d'entrées et MM voulais savoir les fréquences pour chaque entrée. Cela pourrait être un très coûteux - en particulier lorsqu'il y a de bien meilleures façons de le faire.
- Oui, il pourrait ne pas être une bonne solution, ne veut pas dire son mal.
- Il veut juste le nombre de "chauve-souris" occurrences. Juste itérer une fois de plus de l'original de la liste de tableaux et incrémenter un compteur à chaque fois que vous voyez "chauve-souris".
- Je ne pense pas que, littéralement, il veut le nombre de chauve-souris occurrences au sein d'un 4-élément de la collection, je pense que c'était juste des données de l'échantillon, nous aimerions mieux comprendre :-).
- Simplement parce qu'il fonctionne ne signifie pas que ses la bonne façon de faire les choses. Nous avons pu balayer toutes les lignes dans une table et rechercher manuellement la chauve-souris, mais nous ne faisons pas nous créer la requête appropriée.
- 2/2. La programmation est de faire les choses correctement, de sorte que nous n'avons pas causer des maux de tête ou une mauvaise expérience pour quelqu'un d'autre qui peut être un utilisateur ou un autre programmeur dans l'avenir. PS: plus de code d'écriture le plus de chance il y a quelque chose peut aller mal.
- Je suis d'accord, c'est pourquoi je n'ai pas upvote ceux maladroit solutions. Mais ni moi, downvote, car ils donnent le bon résultat. Depuis, nous ne pouvons pas downvote deux fois pour une mauvaise réponse. Et de l'OMI, il faut distinguer les faux pas.
- Veuillez expliquer pourquoi ce n'est pas une solution évolutive. Ray Hidayat est la construction d'une fréquence de comptage pour chaque jeton de sorte que chaque jeton peut ensuite être recherché. Quelle est la meilleure solution?
- Cela ressemble à du C#, mais la question est étiqueté java.
InformationsquelleAutor Ray Hidayat
10

Effectivement, les Collections de la classe possède une méthode statique nommée : fréquence(Collection c, Object o) renvoie le nombre d'occurrences de l'élément que vous recherchez, par la manière, ce sera fonctionner parfaitement pour vous:
```
ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
System.out.println("Freq of bat: "+Collections.frequency(animals, "bat"));
```
- Lars Andren posté la même réponse de 5 ans avant le vôtre.
InformationsquelleAutor Khafaga
9

Il n'existe pas de méthode native en Java pour le faire pour vous. Toutefois, vous pouvez utiliser IterableUtils#countMatches() de Apache Commons-Collections pour le faire pour vous.
- Se référer à ma réponse ci-dessous - la bonne réponse est d'utiliser une structure qui prend en charge le comptage idée dès le début, plutôt que de compter les entrées du début à la fin à chaque fois qu'une requête est faite.
- Il vous suffit de le downvote tout le monde qui a une opinion différente de vous? Que faire si il ne peut pas utiliser un Sac pour une raison ou est coincé avec l'aide de l'un de la patrie, de Collections?
- Ne mérite pas un downvote, à mon humble avis.
- -1 pour être un mauvais perdant 🙂 je pense que le député downvoted vous parce que votre solution de coûts à chaque fois que vous voulez un résultat. Un sac en coûtera un peu de temps seul au moment de l'insertion. Comme les bases de données, ces structures ont tendance à être "plus lire que d'écrire" il est donc logique d'utiliser l'option à faible coût.
- Et il semble que votre réponse nécessite aussi des non-natifs choses, de sorte que votre commentaire me semble un peu étrange.
- Merci à vous deux, les gars. Je crois que l'une des deux approches ou les deux d'entre eux pourraient travailler. Je vais l'essayer demain.
- Je peux imaginer un cas d'utilisation où il n'est pas le propriétaire/créateur de la Collection, mais simplement un utilisateur. Dans un tel cas, il ne serait pas capable d'utiliser un Sac. De toute façon, la réponse appropriée est: Utiliser les Communes Collections 🙂
- Avez-vous les gars pense que c'est faux. Il peut être inefficace ne veut pas dire son mal. Pour l'inefficacité de ne pas voter, simple. Downvote signifie que, au moins pour moi, quelque chose de totalement faux. Le gonflement de ses, je suis d'accord, mais il va donner un bon résultat.
- Que pensez-vous de cette algo de Fibonacci. Son Groovy BTW.... "def fib(x) {x <= 1 ? x : fib(x-1) + fib(x-2)}"..... Son terriblement inefficace, mais il donnera le bon résultat, et si ce que vous voulez, c'est moins de 20 il est bon d'aller. Ne mérite pas un négatif.
- le véritable texte d'aide est "pas utile" plutôt que de mal. Cela dit, je n'ai pas downvote celui-ci (voir le smiley sur mon commentaire) car il n'est pas "pas utile". Je n'ai pas upvote ce soit puisque je crois que les députés n'est plus utile, et je me limiterai à upvoting la meilleure réponse IMNSHO.
- bulle de sortes sont aussi inefficaces mais donne le bon résultat. Voyons voir combien de points de rep que vous obtenez ici DONC si vous avez répondu une sorte de question avec "tri à bulles" :-). Accordé, c'est bien pour le tri de petits ensembles de données, mais il ne sera pas à l'échelle.
- Mon point étant, les sacs sont une meilleure réponse à la question spécifique.
- J'ai tendance à être d'accord, Pax. Ni je suis très incliné vers cette solution. J'ai voté c' +1 pour faire le zéro. Et pour le tri à bulles exemple, je ne m'attends pas à n'importe quel point dans ce cas, ni +ve ni -cinq. 🙂
- Et si un prendre un coup d'oeil de cette réponse à partir d'un angle légèrement différent, je suppose que Kevin a également regardé de cette façon. Commune de la Collecte de travailler en tant que remplaçant de Google Collecte, puisque l'affiche originale a mentionné lui-même. Mais encore Sacs sont les meilleurs.
InformationsquelleAutor Kevin
8

Je me demande, pourquoi vous ne pouvez pas utiliser que Google Collecte de l'API du JDK 1.6. Est-il le dire? Je pense que vous pouvez, il ne devrait pas y avoir de problèmes de compatibilité, car il est construit pour une version inférieure. L'affaire aurait été différente si qui ont été construites pour 1.6 et que vous exécutez la version 1.5.

Je me trompe quelque part?
- Ils ont clairement indiqué qu'ils sont dans le processus de mise à niveau de leurs api du jdk 1.6.
- Ce n'est pas faire de vieux incompatible. N'est ce pas?
- Il ne devrait pas. Mais la façon dont ils lançaient des avertissements, me rend mal à l'aise de l'utiliser dans leur version 0.9
- Nous l'utilisons avec 1.6. Où faut-il dire il est uniquement compatible avec la version 1.5?
- Par "mise à niveau vers 1.6" elles sans doute dire "la mise à niveau pour profiter de nouvelles choses en 1.6," non", la fixation de la compatibilité avec 1.6".
InformationsquelleAutor Adeel Ansari

Un peu plus efficace, peut-être

Map<String, AtomicInteger> instances = new HashMap<String, AtomicInteger>();

void add(String name) {
     AtomicInteger value = instances.get(name);
     if (value == null) 
        instances.put(name, new AtomicInteger(1));
     else
        value.incrementAndGet();
}

InformationsquelleAutor Peter Lawrey

Alternative Java 8 solution à l'aide de Flux:

long count = animals.stream().filter(animal -> "bat".equals(animal)).count();

InformationsquelleAutor Cristina

Moyen Simple de trouver l'occurrence de la chaîne de valeur dans un tableau à l'aide de Java 8.

public void checkDuplicateOccurance() {
        List<String> duplicateList = new ArrayList<String>();
        duplicateList.add("Cat");
        duplicateList.add("Dog");
        duplicateList.add("Cat");
        duplicateList.add("cow");
        duplicateList.add("Cow");
        duplicateList.add("Goat");          
        Map<String, Long> couterMap = duplicateList.stream().collect(Collectors.groupingBy(e -> e.toString(),Collectors.counting()));
        System.out.println(couterMap);
    }

De sortie : {Cat=2, Chèvre=1, Vache=1, vache=1, Chien=1}

Vous pouvez le remarquer "la Vache et de lait de vache ne sont pas considérées comme de la même chaîne, dans le cas où vous requis en vertu du même comte, utiliser .toLowerCase(). S'il vous plaît trouver l'extrait de code ci-dessous pour les mêmes.

Map<String, Long> couterMap = duplicateList.stream().collect(Collectors.groupingBy(e -> e.toString().toLowerCase(),Collectors.counting()));

De sortie : {cat=2, la vache=2, chèvre=1, chien=1}

InformationsquelleAutor Eswaran Venkatesan

5

Ce que vous voulez, c'est un Sac qui est comme un ensemble, mais aussi de compter le nombre d'événements. Malheureusement, la java des Collections cadre - grands car ils sont de ne pas avoir un Sac impl. Pour cela on doit utiliser Apache Commun de Collecte texte du lien
- La meilleure solution évolutive et, si vous ne pouvez pas utiliser de tiers, choses, il suffit d'écrire votre propre. Les sacs ne sont pas la science de fusée à créer. +1.
- Downvoted pour donner une vague réponse, tandis que d'autres ont fourni des implémentations de la fréquence de comptage des structures de données. Le 'sac' la structure de données que vous avez associé est pas une solution appropriée pour l'OP de la question; que " dans un sac, la structure est destiné à contenir un nombre précis d'exemplaires d'un jeton, pas de compter le nombre d'occurrences de jetons.
InformationsquelleAutor mP.

Pour obtenir les occurrences de l'objet à partir de la liste directement:

int noOfOccurs = Collections.frequency(animals, "bat");

Pour obtenir l'occurrence de l'Objet de collection à l'intérieur de la liste, remplacer la méthode equals de la classe de l'Objet comme:

@Override
public boolean equals(Object o){
    Animals e;
    if(!(o instanceof Animals)){
        return false;
    }else{
        e=(Animals)o;
        if(this.type==e.type()){
            return true;
        }
    }
    return false;
}

Animals(int type){
    this.type = type;
}

Appeler les Collections.fréquence:

int noOfOccurs = Collections.frequency(animals, new Animals(1));

InformationsquelleAutor Andrew TR

Java 8 - une autre méthode

String searched = "bat";
long n = IntStream.range(0, animals.size())
            .filter(i -> searched.equals(animals.get(i)))
            .count();

InformationsquelleAutor ROMANIA_engineer

2

Si vous utilisez Eclipse Collections, vous pouvez utiliser un Bag. Un MutableBag peut être retourné à partir de la mise en œuvre des RichIterable en appelant toBag().
```
MutableList<String> animals = Lists.mutable.with("bat", "owl", "bat", "bat");
MutableBag<String> bag = animals.toBag();
Assert.assertEquals(3, bag.occurrencesOf("bat"));
Assert.assertEquals(1, bag.occurrencesOf("owl"));
```
La HashBag mise en œuvre de la CE est soutenu par une MutableObjectIntMap.

Remarque: je suis un committer pour Eclipse Collections.

InformationsquelleAutor Donald Raab

List<String> list = Arrays.asList("as", "asda", "asd", "urff", "dfkjds", "hfad", "asd", "qadasd", "as", "asda",
        "asd", "urff", "dfkjds", "hfad", "asd", "qadasd" + "as", "asda", "asd", "urff", "dfkjds", "hfad", "asd",
        "qadasd", "as", "asda", "asd", "urff", "dfkjds", "hfad", "asd", "qadasd");

Méthode 1:

Set<String> set = new LinkedHashSet<>();
set.addAll(list);

for (String s : set) {

    System.out.println(s + " : " + Collections.frequency(list, s));
}

Méthode 2:

int count = 1;
Map<String, Integer> map = new HashMap<>();
Set<String> set1 = new LinkedHashSet<>();
for (String s : list) {
    if (!set1.add(s)) {
        count = map.get(s) + 1;
    }
    map.put(s, count);
    count = 1;

}
System.out.println(map);

Bienvenue à Débordement de Pile! Envisager d'expliquer votre code afin de le rendre plus facile pour les autres de comprendre votre solution.

InformationsquelleAutor sabm

1

Mettre les éléments de la liste de tableaux dans la table de hachage à compter de la fréquence.
- C'est exactement la même chose que tweakt dit, avec un exemple de code.
InformationsquelleAutor Shamik
0

Donc le faire à l'ancienne et rouler votre propre:
```
Map<String, Integer> instances = new HashMap<String, Integer>();

void add(String name) {
     Integer value = instances.get(name);
     if (value == null) {
        value = new Integer(0);
        instances.put(name, value);
     }
     instances.put(name, value++);
}
```
- Avec le "synchronisé", si nécessaire, afin d'éviter des conditions de course. Mais je préfère encore voir cela dans sa propre classe.
- Vous avez une faute de frappe. Besoin HashMap au lieu de cela, comme vous le prenez à la Carte. Mais l'erreur de mettre 0 au lieu de 1 est un peu plus sérieux.
InformationsquelleAutor Mark Renouf

Si vous êtes un utilisateur de mon ForEach DSL, il peut être fait avec un Count requête.

Count<String> query = Count.from(list);
for (Count<Foo> each: query) each.yield = "bat".equals(each.element);
int number = query.result();

InformationsquelleAutor akuhn

Je ne voulais pas faire de ce cas plus difficile et il a fait avec deux itérateurs
J'ai une table de hachage avec de Nom -> Prenom. Et ma méthode doit supprimer des éléments avec dulicate Prénom.

public static void removeTheFirstNameDuplicates(HashMap<String, String> map)
{

    Iterator<Map.Entry<String, String>> iter = map.entrySet().iterator();
    Iterator<Map.Entry<String, String>> iter2 = map.entrySet().iterator();
    while(iter.hasNext())
    {
        Map.Entry<String, String> pair = iter.next();
        String name = pair.getValue();
        int i = 0;

        while(iter2.hasNext())
        {

            Map.Entry<String, String> nextPair = iter2.next();
            if (nextPair.getValue().equals(name))
                i++;
        }

        if (i > 1)
            iter.remove();

    }

}

InformationsquelleAutor Alexander Shapkin

List<String> lst = new ArrayList<String>();

lst.add("Ram");
lst.add("Ram");
lst.add("Shiv");
lst.add("Boss");

Map<String, Integer> mp = new HashMap<String, Integer>();

for (String string : lst) {

    if(mp.keySet().contains(string))
    {
        mp.put(string, mp.get(string)+1);

    }else
    {
        mp.put(string, 1);
    }
}

System.out.println("=mp="+mp);

De sortie:

=mp= {Ram=2, Boss=1, Shiv=1}

InformationsquelleAutor Ramling Muley

Map<String,Integer> hm = new HashMap<String, Integer>();
for(String i : animals) {
    Integer j = hm.get(i);
    hm.put(i,(j==null ? 1 : j+1));
}
for(Map.Entry<String, Integer> val : hm.entrySet()) {
    System.out.println(val.getKey()+" occurs : "+val.getValue()+" times");
}

InformationsquelleAutor fcm45

Vous devez vous connecter pour publier un commentaire.