web-dev-qa-db-fra.com

Comment compter les éléments en double dans ArrayList?

Je dois séparer et compter combien de valeurs dans arraylist sont identiques et les imprimer en fonction du nombre d'occurrences.

J'ai un auteur appelé digits:

 [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

J'ai créé une méthode qui sépare chaque valeur et l'enregistre dans un nouveau tableau.

public static ArrayList<Integer> myNumbers(int z) {

    ArrayList<Integer> digits = new ArrayList<Integer>();
    String number = String.valueOf(z);
    for (int a = 0; a < number.length(); a++) {
        int j = Character.digit(number.charAt(a), 10);
        digits.add(j);
    }
    return digits;

}

Après cela, j'ai un nouveau tableau appelé nombres. J'utilise une sorte sur ce tableau

Collections.sort(numbers);

et mon ArrayList ressemble à ceci: 

[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9]

Il a:

2 times 0; 
9 times 1;
4 times 2;
6 times 3;
5 times 4;
6 times 5;
5 times 6;
5 times 7;
5 times 8;
3 times 9;

J'ai besoin d'imprimer la chaîne de nombres qui dépend de combien ils sontAlors supposons qu'ils ressemblent à ceci: 1354678290

javasortingarraylist
5
Piotr Szczepanik

En utilisant l'API Stream par exemple.

package tests;

import org.junit.Assert;
import org.junit.Test;

import Java.util.Arrays;
import Java.util.List;
import Java.util.Map;
import Java.util.function.Function;
import Java.util.stream.Collectors;

public class Duplicates {

    @Test
    public void duplicates() throws Exception {
        List<Integer> items = Arrays.asList(1, 1, 2, 2, 2, 2);

        Map<Integer, Long> result = items.stream()
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        Assert.assertEquals(Long.valueOf(2), result.get(1));
        Assert.assertEquals(Long.valueOf(4), result.get(2));
    }
}
2
Florian Salihovic

utilisez la méthode Collections.frequency pour compter les doublons

6
praba buddy

Eh bien, pour cela, vous pouvez essayer d’utiliser Map

Map<Integer, Integer> countMap = new HashMap<>();

  for (Integer item: yourArrayList) {

      if (countMap.containsKey(item))
          countMap.put(item, countMap.get(item) + 1);
      else
          countMap.put(item, 1);
  }

Après la fin de chaque boucle, vous aurez une carte remplie avec vos éléments.

4
Andrew Petryk

La question est de compter combien il y a de deux ou trois dans un tableau . En Java 7, la solution est:

import Java.util.Arrays;
import Java.util.HashMap;
import Java.util.HashSet;
import Java.util.List;
import Java.util.Map;
import Java.util.Set;

public class howMany1 {
public static void main(String[] args) {

    List<Integer> list = Arrays.asList(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765);

    Map<Integer ,Integer> map = new HashMap<>();

      for(  Integer r  : list) {
          if(  map.containsKey(r)   ) {
                 map.put(r, map.get(r) + 1);
          }//if
          else {
              map.put(r, 1);
          }
      }//for

      //iterate

      Set< Map.Entry<Integer ,Integer> > entrySet = map.entrySet();
      for(    Map.Entry<Integer ,Integer>  entry : entrySet     ) {
          System.out.printf(   "%s : %d %n "    , entry.getKey(),entry.getValue()  );
      }//for

}}

En Java 8, la solution au problème est la suivante:

import Java.util.Arrays;
import Java.util.HashMap;
import Java.util.HashSet;
import Java.util.List;
import Java.util.Map;
import Java.util.Set;
import Java.util.stream.Collectors;

public class howMany2 {
public static void main(String[] args) {

    List<Integer> list = Arrays.asList(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765);
     // we can also use Function.identity() instead of c->c
    Map<Integer ,Long > map = list.stream()
            .collect(  Collectors.groupingBy(c ->c , Collectors.counting())         ) ;


    map.forEach(   (k , v ) -> System.out.println( k + " : "+ v )                    );

}}

Une autre méthode consiste à utiliser Collections.frequency. La solution est:

import Java.util.Arrays;
import Java.util.Collections;
import Java.util.HashSet;
import Java.util.List;
import Java.util.Set;

public class Duplicates1 {
public static void main(String[] args) {

    List<Integer> list = Arrays.asList(1, 1, 2, 3, 5, 8, 13,13, 21, 34, 55, 89, 144, 233);

    System.out.println("Count all with frequency");
    Set<Integer> set = new HashSet<Integer>(list);
    for (Integer r : set) {
        System.out.println(r + ": " + Collections.frequency(list, r));
    }

}}

Une autre méthode consiste à modifier le tableau int en Liste entière à l'aide de la méthode => Arrays.stream (tableau) .boxed (). Collect (Collectors.toList ()), puis à obtenir l'entier à l'aide de la boucle for.

public class t7 {
    public static void main(String[] args) {
        int[] a = { 1, 1, 2, 3, 5, 8, 13, 13 };
        List<Integer> list = Arrays.stream(a).boxed().collect(Collectors.toList());

        for (Integer ch : list) {
            System.out.println(ch + " :  " + Collections.frequency(list, ch));
        }

    }// main
}
2
Soudipta Dutta

Utilisez la fonction ci-dessous pour compter les éléments en double:

public void countDuplicate(){
        try {
            Set<String> set = new HashSet<>(original_array);
            ArrayList<String> temp_array = new ArrayList<>();
            temp_array.addAll(set);
            for (int i = 0 ; i < temp_array.size() ; i++){
                Log.e(temp_array.get(i),"=>"+Collections.frequency(original_array,temp_array.get(i)));
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
0
Ramij
Java 8, the solution: 1. Create Map when the Key is the Value of Array and Value is counter. 
2. Check if Map contains the Key increase counter or add a new set.

 private static void calculateDublicateValues(int[] array) {
      //key is value of array, value is counter
      Map<Integer, Integer> map = new HashMap<Integer, Integer>();

      for (Integer element : array) {
        if (map.containsKey(element)) {
          map.put(element, map.get(element) + 1); // increase counter if contains
        } else
          map.put(element, 1);
      }

      map.forEach((k, v) -> {
        if (v > 1)
          System.out.println("The element " + k + " duplicated " + v + " times");
      });

    }
0
Madina Mountaniol

Vous pouvez compter le nombre d'éléments dupliqués dans une liste en ajoutant tous les éléments de la liste et en le stockant dans un hachage. Une fois que cela est fait, il vous suffit de connaître la différence entre la taille du hachage et celle de la liste.

ArrayList<String> al = new ArrayList<String>();
al.add("Santosh");
al.add("Saket");
al.add("Saket");
al.add("Shyam");
al.add("Santosh");
al.add("Shyam");
al.add("Santosh");
al.add("Santosh");
HashSet<String> hs = new HashSet<String>();
hs.addAll(al);
int totalDuplicates =al.size() - hs.size();
System.out.println(totalDuplicates);

Faites-moi savoir si cela nécessite plus de clarification

0
Srivastava