Contare le occorrenze di elementi in ArrayList

Question

Ho un java.util.ArrayList<Item> e un oggetto Item.

Ora, voglio ottenere il numero di volte che lo Item è memorizzato nell'arrayist.

So che posso eseguire il controllo arrayList.contains() ma restituisce true, indipendentemente dal fatto che contenga uno o più Item s.

Q1. Come posso trovare il numero di volte in cui l'elemento è memorizzato nell'elenco?

Q2. Inoltre, se l'elenco contiene più di un articolo, come è possibile determinare l'indice di altri articoli perché arrayList.indexOf(item) restituisce l'indice del solo primo elemento ogni volta?

Answer 1

Questo è facile da fare a mano.

public int countNumberEqual(ArrayList<Item> itemList, Item itemToCheck) { 
    int count = 0; 
    for (Item i : itemList) { 
     if (i.equals(itemToCheck)) { 
      count++; 
     } 
    } 
    return count; 
} 

Tenete presente che se non si esegue l'override equals nella classe Item, questo metodo usa identità di un oggetto (in quanto questo è l'implementazione di Object.equals()).

Modifica: Per quanto riguarda la tua seconda domanda (prova a limitare i post a una domanda a testa), puoi farlo anche a mano.

public List<Integer> indices(ArrayList<Item> items, Item itemToCheck) { 
    ArrayList<Integer> ret = new ArrayList<Integer>(); 
    for (int i = 0; i < items.size(); i++) { 
     if (items.get(i).equals(itemToCheck)) { 
      ret.add(i); 
     } 
    } 
    return ret; 
} 

Answer 2

È possibile utilizzare Collections classe:

public static int frequency(Collection<?> c, Object o) 

Restituisce il numero di elementi della collezione specificato uguale all'oggetto specificato. Più formalmente, restituisce il numero di elementi e nella raccolta in modo tale che (o == null? E == null: o.equals (e)).

Se è necessario contare occurencies di una lunga lista molte volte vi consiglio di utilizzare un HashMap per memorizzare i contatori e aggiornarli mentre si inserisce nuovi elementi alla lista. Questo eviterebbe di calcolare qualsiasi tipo di contatore ... ma ovviamente non avrai indici.

HashMap<Item, Integer> counters = new HashMap<Item, Integer>(5000); 
ArrayList<Item> items = new ArrayList<Item>(5000); 

void insert(Item newEl) 
{ 
    if (counters.contains(newEl)) 
    counters.put(newEl, counters.get(newEl)+1); 
    else 
    counters.put(newEl, 1); 

    items.add(newEl); 
} 

Un suggerimento finale: è possibile utilizzare altri framework collezioni (come Apache Collections) e utilizzare un datastructure Bag che è descritto come

Definisce una collezione che conta il numero di volte in cui un oggetto viene visualizzato nella collezione.

Quindi esattamente ciò che serve ..

Answer 3

Come gli altri intervistati hanno già detto, se si sta fermamente impegnati a memorizzare i tuoi oggetti in un ArrayList non ordinata, quindi contando articoli prenderà O (n) , dove n è il numero di elementi nell'elenco. Qui in SO, diamo consigli ma non facciamo magie!

Come ho appena accennato, se la lista viene cercata molto più di quanto non sia stata modificata, potrebbe aver senso tenerla ordinata.Se il tuo elenco è ordinato, puoi trovare il tuo oggetto in O (log n) ora, che è molto più veloce; e se hai un'implementazione hashcode che si adatta perfettamente al tuo equals, tutti gli elementi identici si troveranno uno accanto all'altro.

Un'altra possibilità sarebbe quella di creare e mantenere due strutture di dati in parallelo. È possibile utilizzare uno HashMap contenente gli elementi come chiavi e il loro conteggio come valori. Sarai obbligato ad aggiornare questa seconda struttura ogni volta che la tua lista cambierà, ma le ricerche di conteggio degli articoli sarebbero o (1).

Answer 4

potrei sbagliarmi, ma mi sembra come la struttura dei dati si vuole realmente potrebbe essere un Multiset (da google-collections/guava) piuttosto che un List. Permette multipli, a differenza di Set, ma in realtà non interessa l'ordine. Detto questo, ha un metodo int count(Object element) che fa esattamente quello che vuoi. E poiché non è un elenco e ha implementazioni supportate da un HashMap, ottenere il conteggio è notevolmente più efficiente.

Answer 5

Grazie per il tuo suggerimento. Ma questo sotto codice è davvero molto utile in quanto non abbiamo alcun metodo di ricerca con List che possa dare il numero di occurance.

void insert(Item newEl) 
{ 
    if (counters.contains(newEl)) 
    counters.put(newEl, counters.get(newEl)+1); 
    else 
    counters.put(newEl, 1); 

    items.add(newEl); 
} 

Grazie a Jack. Buona pubblicazione.

Grazie,

Binod Suman

http://binodsuman.blogspot.com