Cómo contar el número de apariciones de un elemento en una lista

Question

Tengo una ArrayList, una clase de colección de Java, de la siguiente manera:

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

Como se puede ver, el animalsArrayList consta de 3 bat elementos y un elemento owl. Me preguntaba si hay alguna API en el marco de recopilación que devuelve el número de ocurrencias bat o si hay otra forma de determinar el número de instancias.

Encontré que la Colección de Google Multiset tiene una API que devuelve el número total de apariciones de un elemento. Pero eso solo es compatible con JDK 1.5. Nuestro producto se encuentra actualmente en JDK 1.6, por lo que no puedo usarlo.

Answer 1

No existe un método nativo en Java para hacer eso por usted. Sin embargo, puede usar IterableUtils#countMatches() de Apache Commons-Collections para hacerlo por usted.

Answer 2

Lo sentimos, no existe una llamada a método simple que pueda hacerlo. Todo lo que necesitas hacer es crear un mapa y contar la frecuencia con él.

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

Answer 3

Lo que quiere es una bolsa, que es como un conjunto pero también cuenta el número de ocurrencias. Desafortunadamente, el marco de colecciones de Java es genial, ya que no tienen una impl. Para que uno debe usar la colección Común Apache link text

Answer 4

Así que hacerlo de la manera antigua y rodar su propia:

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

Answer 5

me pregunto, ¿por qué no se puede utilizar esa API Colección de Google con JDK 1.6. ¿Eso dice? Creo que puede, no debería haber problemas de compatibilidad, ya que está diseñado para una versión más baja. El caso habría sido diferente si eso fue construido para 1.6 y está ejecutando 1.5.

¿Me equivoco?

Answer 6

Coloque los elementos del arraylist en el hashMap para contar la frecuencia.

Answer 7

Un enfoque ligeramente más eficiente podría ser

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

Answer 8

Esto demuestra, por eso es importante "Refer to objects by their interfaces" como se describe en Effective Java libro.

Si codifica la implementación y usa ArrayList en, digamos, 50 lugares en su código, cuando encuentre una buena implementación de "Lista" que cuente los elementos, tendrá que cambiar esos 50 lugares, y probablemente usted Tendrás que romper tu código (si solo lo usas no hay gran problema, pero si lo usa alguien más, también romperás su código)

Programando en la interfaz que puede dejar esos 50 lugares sin cambios y reemplazar la implementación de ArrayList a "CountItemsList" (por ejemplo) o alguna otra clase.

A continuación se muestra una muestra muy básica de cómo podría escribirse esto. Esta es solo una muestra, una lista de producción lista sería mucho más más complicada.

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 principios aplicados aquí: herencia, polimorfismo, abstracción, encapsulación.

Answer 9

Si usted es un usuario de mi ForEach DSL, se puede hacer con una consulta Count.

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

Answer 10

Estoy bastante seguro de la frecuencia-método estático en las colecciones sería muy útil aquí:

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

Así es como yo lo haría de todos modos. Estoy bastante seguro de que esto es jdk 1.6 en línea recta.

Answer 11

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

Salida:

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

Answer 12

En Java 8:

Map<String, Long> counts = 
    list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting())); 

Answer 13

Si utiliza Eclipse Collections, se puede utilizar un Bag. Se puede devolver un MutableBag desde cualquier implementación de RichIterable llamando al 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 aplicación HashBag en CE está respaldado por una MutableObjectIntMap.

Nota: Soy un committer para colecciones de Eclipse.

Answer 14

En realidad, la clase Colecciones tiene un método estático denominado: frecuencia (Collection c, Object o) que devuelve el número de veces que aparece el elemento que está buscando, por cierto, esto va a funcionar perfectamente para usted:

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

Answer 15

Java 8 - otro método

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

Answer 16

alternativa Java 8 solución usando Streams:

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

Answer 17

Para obtener las ocurrencias del objeto de la lista directamente:

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

Para obtener la ocurrencia de la colección de objetos de lista en el interior, reemplazar el método equals en la clase Object como:

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

Llame al Collections.frequency como:

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

Answer 18

No quería que este caso fuera más difícil y lo hice con dos iteradores Tengo un HashMap con Apellido -> Nombre. Y mi método debe eliminar elementos con el nombre de pila.

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

    } 

} 

Answer 19

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étodo 1:

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

for (String s : set) { 

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

Método 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); 

Answer 20

manera sencilla de encontrar la ocurrencia de valor de cadena en una matriz usando Java 8 funciones.

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

Salida: {cat = 2, Cabra = 1, vaca = 1, vaca = 1, Perro = 1}

Se puede notar "vaca" y la vaca no se consideran como la misma cadena, en caso de que lo requiera bajo el mismo conteo, use .toLowerCase(). Encuentre el fragmento a continuación para el mismo.

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

Salida: {cat = 2, vaca = 2, cabra = 1, perro = 1}