Cuente las ocurrencias de elementos en ArrayList

Question

Tengo un objeto java.util.ArrayList<Item> y Item.

Ahora, quiero obtener el número de veces que el Item se almacena en el arraylist.

Sé que puedo hacer arrayList.contains() comprobar pero se cumple, independientemente de si contiene uno o más Item s.

Q1. ¿Cómo puedo encontrar la cantidad de tiempo que el artículo está almacenado en la lista?

Q2. Además, si la lista contiene más de un artículo, ¿cómo puedo determinar el índice de otros artículos porque arrayList.indexOf(item) devuelve el índice del primer artículo cada vez?

Answer 1

Esto es fácil de hacer a mano.

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

Tenga en cuenta que si no se sobreescribe equals en su clase Item, este método se utiliza la identidad del objeto (ya que esto es la implementación de Object.equals()).

Editar: En cuanto a su segunda pregunta (intente limitar las publicaciones a una pregunta cada una), puede hacerlo a mano también.

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

Puede utilizar Collections clase:

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

Devuelve el número de elementos de la colección especificada igual al objeto especificado. Más formalmente, devuelve el número de elementos e en la colección de manera que (o == null? E == null: o.equals (e)).

Si es necesario contar las ocurrencias de una larga lista de muchas veces que sugerimos utilizar un HashMap para almacenar los contadores y actualizarlos mientras introduce nuevos elementos a la lista. Esto evitaría calcular cualquier tipo de contadores ... pero, por supuesto, no tendrá índices.

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

Una última pista: puede utilizar otro marco de las colecciones (como Apache Collections) y el uso de una estructura de datos Bag que se describe como

define una colección que cuenta el número de veces que un objeto aparece en la colección.

Así exactamente lo que necesita ..

Answer 3

Como los otros encuestados han dicho ya, si está firmemente comprometido con el almacenamiento de sus artículos en un ArrayList desordenada, entonces contar los elementos tendrá un tiempo O (n) , donde n es la cantidad de elementos en la lista. ¡Aquí en SO, damos consejos pero no hacemos magia!

Como acabo de insinuar, si la lista se busca mucho más de lo que se modificó, podría tener sentido mantenerla ordenada.Si su lista está ordenada, puede encontrar su artículo en el tiempo O (log n), que es mucho más rápido; y si tiene una implementación hashcode que va bien con su equals, todos los elementos idénticos estarán uno al lado del otro.

Otra posibilidad sería crear y mantener dos estructuras de datos en paralelo. Puede usar un HashMap que contenga sus elementos como claves y su recuento como valores. Usted estaría obligado a actualizar esta segunda estructura cada vez que su lista cambie, pero las búsquedas de recuento de elementos serían o (1).

Answer 4

puedo estar equivocado, pero parece a mí como la estructura de datos que realmente desea podría ser un Multiset (de google-collections/guava) en lugar de un List. Permite múltiplos, a diferencia de Set, pero en realidad no le importa el orden. Dado que tiene un método int count(Object element) que hace exactamente lo que quiere. Y como no es una lista y tiene implementaciones respaldadas por un HashMap, obtener el recuento es considerablemente más eficiente.

Answer 5

Gracias por su muy buena sugerencia. Pero este código a continuación es realmente muy útil ya que no tenemos ningún método de búsqueda con la Lista que pueda dar el número de ocurrencia.

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

    items.add(newEl); 
} 

Gracias a Jack. Buena publicación.

Gracias,

Binod Suman

http://binodsuman.blogspot.com