Nombre d'occurrences Java dans un tableau 2D

Compte d'occurrences Java dans un tableau 2D | Dans cette section, nous allons compter les occurrences de l'élément dans le tableau à deux dimensions, c'est-à-dire que nous comptons le nombre d'occurrences dans la matrice. Pour afficher la matrice, nous utilisons la méthode Arrays.deepToString() cette méthode est utilisée pour convertir des tableaux multidimensionnels en chaînes.

Pour en savoir plus sur le problème, observez les exemples ci-dessous. Exemples :-

1) Tableau ={ { 1, 2 }, { 1, 5 }, { 2, 1 } } ;
Élément pour trouver l'occurrence =1
Occurrence de 1 =3 fois

2) Tableau ={ { 1, 2 }, { 1, 5 }, { 2, 1 } } ;
Élément pour trouver occurrence =2
Occurence de 2 =2 fois

3) Tableau ={ { 1, 2 }, { 1, 5 }, { 2, 1 } } ;
Élément pour trouver occurrence =5
Occurence de 5 =1 fois

4) Tableau ={ { 1, 2 }, { 1, 5 }, { 2, 1 } } ;
Élément pour trouver l'occurrence =0
Occurrence de 0 =0 fois

5) Exemple pour trouver l'occurrence de chaque élément dans le tableau 2D donné :-
Array ={ { 1, 2 }, { 1, 5 }, { 2, 1 } } ;
Occurence of 1 =3 fois
Occurrence de 2 =2 fois
Occurrence de 5 =1 fois
Occurrence de 0 =0 fois

Compte d'occurrences Java dans le code de tableau 2D

Voyons maintenant un programme Java pour compter l'occurrence d'un élément donné dans le tableau 2D donné.

import java.util.Arrays;
import java.util.Scanner;

public class Main {

   public static int findOccurrences(int arr[][], int element) {
      int count = 0;
      for (int i = 0; i < arr.length; i++) {
         for (int j = 0; j < arr[i].length; j++) {
            if (element == arr[i][j])
               count++;
         }
      }
      return count;
   }

   public static void main(String args[]) {
      Scanner scan = new Scanner(System.in);
      int array[][] = { { 1, 2, 3 }, { 2, 2, 3 }, { 7, 7, 8 } };
      System.out.println("Array = " + Arrays.deepToString(array));

      System.out.print("Enter element to find occurrence: ");
      int element = scan.nextInt();

      System.out.println("Occurrence of " + element 
         + " = " + findOccurrences(array, element) + " times.");
      scan.close();
   }
}

Sortie :-

Array =[ [1, 2, 3], [2, 2, 3], [7, 7, 8] ]
Entrez l'élément pour trouver l'occurrence :2
Occurrence de 2 =3 fois.

Array =[ [1, 2, 3], [2, 2, 3], [7, 7, 8] ]
Entrez l'élément pour trouver l'occurrence :8
Occurrence de 8 =1 fois.

Array =[ [1, 2, 3], [2, 2, 3], [7, 7, 8] ]
Entrez l'élément pour trouver l'occurrence :9
Occurrence de 9 =0 fois.

Voyons un autre exemple pour un tableau 2D de chaînes.

import java.util.Arrays;

public class Main {

   public static int findOccurrences(String arr[][], String element) {
      int count = 0;
      for (int i = 0; i < arr.length; i++) {
         for (int j = 0; j < arr[i].length; j++) {
            if (element.equals(arr[i][j])) {
               count++;
            }
         }
      }
      return count;
   }

   public static void main(String args[]) {
      String[][] array = 
         { 
            { "Apple", "Banana", "Grapes", "Orange", "Strawberry" },
            { "Apple", "Pineapple", "Mango", "Papaya", "Sapodilla" } 
         };

      System.out.println("Array = " + Arrays.deepToString(array));
      String element = "Apple";

      System.out.println("Occurrence of " + element + 
           " = " + findOccurrences(array, element) + " times.");
   }
}

Sortie :-

Array =[ [Pomme, Banane, Raisin, Orange, Fraise], [Pomme, Ananas, Mangue, Papaye, Sapotille] ]
Occurrence de Pomme =2 fois.

Java compte les occurrences dans le tableau 2D de chaque élément

Voyons un programme Java pour compter les occurrences de tous les éléments uniques présents dans le tableau donné. Pour résoudre ce problème, nous prendrons l'aide de HashMap. Dans le HashMap, l'élément du tableau sera stocké en tant que clé et leur nombre sera stocké en tant que valeur. Enfin, nous afficherons la paire clé, valeur de HashMap.

import java.util.HashMap;
import java.util.Map;

public class Main {
   public static void main(String args[]) {
      String[][] array = 
          { 
            { "Apple", "Banana", "Grapes", "Orange", "Strawberry" },
            { "Apple", "Pineapple", "Mango", "Papaya", "Sapodilla" } 
          };
      
      Map<String, Integer> count = new HashMap<>();
      for (String[] arr : array) {
         for (String string : arr) {
            if (!count.containsKey(string)) {
               count.put(string, 1);
            } else {
               count.put(string, count.get(string) + 1);
            }
         }
      }
      System.out.println(count);
   }
}

Sortie :

{Pomme=2, Raisins=1, Papaye=1, Fraise=1, Sapotille=1, Mangue=1, Ananas=1, Orange=1, Banane=1}

Un autre exemple d'occurrences de comptage Java dans un tableau 2D d'entiers. Dans l'exemple précédent, c'est un tableau 2D de chaînes donc nous avons pris HashMap mais maintenant c'est un tableau 2D de valeurs int donc nous allons prendre HashMap.

import java.util.HashMap;
import java.util.Map;

public class Main {
   public static void main(String args[]) {
      int array[][] = { { 1, 2, 3 }, { 2, 2, 3 }, { 7, 7, 8 } };
      Map<Integer, Integer> count = new HashMap<>();
      for (int[] arr : array) {
         for (int element : arr) {
            if (!count.containsKey(element)) {
               count.put(element, 1);
            } else {
               count.put(element, count.get(element) + 1);
            }
         }
      }
      System.out.println(count);
   }
}

Sortie :-

{1=1, 2=3, 3=2, 7=2, 8=1}