Cómo contar el número de ocurrencias de un elemento en una Lista

Tengo una ArrayList, una clase de colección de Java, como sigue:

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

Como puede ver, animals ArrayListconsta de 3 batelementos y un owlelemento. Me preguntaba si hay alguna API en el marco de la Colección que devuelve el número de batocurrencias o si hay otra forma de determinar el número de ocurrencias.

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

Estoy bastante seguro de que el método de frecuencia estática en Colecciones sería útil aquí:

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

Así es como lo haría de todos modos. Estoy bastante seguro de que esto es jdk 1.6 directamente.

En Java 8:

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

Esto muestra por qué es importante " Referirse a los objetos por sus interfaces " como se describe en el libro Effective Java .

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 todos esos 50 lugares, y probablemente tendrá que rompa su código (si solo lo usa usted, no es gran cosa, pero si alguien más lo usa, también romperá su código)

Al programar en la interfaz, 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 sobre cómo se podría escribir esto. Esto es solo una muestra, una lista lista para producción sería mucho 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" ));
    }
}

Principios de OO aplicados aquí: herencia, polimorfismo, abstracción, encapsulación.

Lo sentimos, no hay una llamada a un método simple que pueda hacerlo. Sin embargo, todo lo que debe 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); }
}

No hay 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.

En realidad, la clase Colecciones tiene un método estático llamado: frecuencia (Colección c, Objeto o) que devuelve el número de ocurrencias del elemento que está buscando, por cierto, esto 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"));

Solución alternativa de Java 8 usando Streams :

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

Me pregunto por qué no puedes usar esa API de Google Collection con JDK 1.6. ¿Eso lo dice? Creo que puede, no debería haber problemas de compatibilidad, ya que está diseñado para una versión inferior. El caso habría sido diferente si se hubiera creado para 1.6 y está ejecutando 1.5.

¿Me equivoco en alguna parte?

Un enfoque un poco 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();
}

Para obtener las ocurrencias del objeto de la lista directamente:

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

Para obtener la aparición de la colección Object dentro de la lista, anule 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 a Colecciones.frecuencia como:

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

Manera simple de encontrar la aparición del valor de cadena en una matriz utilizando las características 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);
    }

Salida: {Cat = 2, Goat = 1, Cow = 1, cow = 1, Dog = 1}

Puede notar que "Vaca" y vaca no se consideran como la misma cadena, en caso de que lo requiera con el mismo recuento, use .toLowerCase (). Encuentra el fragmento a continuación para lo mismo.

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

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

Lo que quieres 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 bolsa impl. Para eso hay que usar el texto del enlace Apache Common Collection

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

Si usa Eclipse Collections , puede usar a Bag. A MutableBagpuede ser devuelto desde cualquier implementación de RichIterablemediante una llamada 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 HashBagimplementación en Eclipse Collections está respaldada por a MutableObjectIntMap.

Nota: Soy un committer para Eclipse Collections.

Coloque los elementos de la lista de arrays en el hashMap para contar la frecuencia.

Java 8 : otro método

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

Así que hazlo a la antigua usanza y hazlo tú mismo:

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

Si es usuario de mi DSL de ForEach , puede hacerlo con una Countconsulta.

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

No quería hacer este caso más difícil y lo hice con dos iteradores. Tengo un HashMap con Apellido -> Nombre. Y mi método debería eliminar elementos con FirstName debidamente.

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

    }

}

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}

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

package traversal;

import java.util.ArrayList;
import java.util.List;

public class Occurrance {
    static int count;

    public static void main(String[] args) {
        List<String> ls = new ArrayList<String>();
        ls.add("aa");
        ls.add("aa");
        ls.add("bb");
        ls.add("cc");
        ls.add("dd");
        ls.add("ee");
        ls.add("ee");
        ls.add("aa");
        ls.add("aa");

        for (int i = 0; i < ls.size(); i++) {
            if (ls.get(i) == "aa") {
                count = count + 1;
            }
        }
        System.out.println(count);
    }
}

Salida: 4