Cuente las ocurrencias de elementos de la lista en Java

Supongamos que tenemos elementos en ArrayList , podemos contar las ocurrencias de elementos presentes de varias maneras.

Esta estructura de datos utiliza la función hash para asignar valores similares, conocidos como claves para sus valores asociados. Los valores del mapa se pueden recuperar utilizando la clave, ya que contiene pares clave-valor. 

// Java program to count frequencies of elements
// using HashMap.
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.*;
 
class GFG {
    public static void countFrequencies(ArrayList<String> list)
    {
        // hashmap to store the frequency of element
        Map<String, Integer> hm = new HashMap<String, Integer>();
 
        for (String i : list) {
            Integer j = hm.get(i);
            hm.put(i, (j == null) ? 1 : j + 1);
        }
 
        // displaying the occurrence of elements in the arraylist
        for (Map.Entry<String, Integer> val : hm.entrySet()) {
            System.out.println("Element " + val.getKey() + " "
                               + "occurs"
                               + ": " + val.getValue() + " times");
        }
    }
 
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();
        list.add("Geeks");
        list.add("for");
        list.add("Geeks");
        countFrequencies(list);
    }
}

Element Geeks occurs: 2 times
Element for occurs: 1 times

Esta estructura de datos no permite elementos duplicados ya que implementa Set Interface . Los objetos se insertan en función de su código hash. Para contar las ocurrencias de elementos de ArrayList, creamos HashSet y agregamos todos los elementos de ArrayList. Usamos Collections.frequency(Collection c, Object o) para contar la aparición del objeto o en la colección c. El programa a continuación ilustra el funcionamiento de HashSet: Programa para encontrar ocurrencias de palabras 

// Java program to count frequencies of elements
// using HashSet and Collections.frequency.
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.*;
 
class GFG {
    public static void countFrequencies(ArrayList<String> list)
    {
 
        // hash set is created and elements of
        // arraylist are inserted into it
        Set<String> st = new HashSet<String>(list);
        for (String s : st)
            System.out.println(s + ": " + Collections.frequency(list, s));
    }
 
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();
        list.add("Geeks");
        list.add("for");
        list.add("Geeks");
        countFrequencies(list);
    }
}

Geeks: 2
for: 1

Esta estructura de datos almacena elementos únicos en orden ordenado. Utiliza el concepto de árbol rojo-negro en el fondo para evitar duplicados. 

// Java program to count frequencies of elements
// using HashMap.
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.*;
 
class GFG {
    public static void countFrequencies(ArrayList<String> list)
    {
 
        TreeMap<String, Integer> tmap = new TreeMap<String, Integer>();
        for (String t : list) {
            Integer c = tmap.get(t);
            tmap.put(t, (c == null) ? 1 : c + 1);
        }
 
        for (Map.Entry m : tmap.entrySet())
            System.out.println("Frequency of " + m.getKey() + " is " + m.getValue());
    }
 
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();
        list.add("Geeks");
        list.add("for");
        list.add("Geeks");
        countFrequencies(list);
    }
}

Frequency of Geeks is 2
Frequency of for is 1

Puntos clave:

• HashMap implementa Map Interface mientras que TreeMap implementa SortedMap Interface.
• HashMap usa Hashing mientras que TreeMap usa Red-Black Tree (BST equilibrado). Por lo tanto , las soluciones basadas en HashMap son generalmente mucho más rápidas que las soluciones basadas en TreeMap .