Java compte l'occurrence de chaque élément dans un tableau
Existe-t-il une méthode pour compter l'occurrence de chaque élément dans un tableau?
Disons que j'ai:
String[] array = {"name1","name2","name3","name4", "name5"};
Ici, la sortie sera:
name1 1
name2 1
name3 1
name4 1
name5 1
et si j'ai:
String[] array = {"name1","name1","name2","name2", "name2"};
La sortie serait:
name1 2
name2 3
La sortie ici est juste pour démontrer le résultat attendu.
Vous pouvez utiliser un MultiSet de Google Collections/Guava ou un Bag d'Apache Commons.
Si vous avez une collection au lieu d'un tableau, vous pouvez utiliser addAll() pour ajouter tout le contenu à la structure de données ci-dessus, puis appliquer la méthode count() à chaque valeur. Un SortedMultiSet ou SortedBag vous donnerait les éléments dans un ordre défini.
Google Collections propose en fait des moyens très pratiques pour passer des tableaux à un SortedMultiset.
List asList = Arrays.asList(array);
Set<String> mySet = new HashSet<String>(asList);
for(String s: mySet){
System.out.println(s + " " +Collections.frequency(asList,s));
}
Avec Java-8 , vous pouvez le faire comme ceci:
String[] array = {"name1","name2","name3","name4", "name5", "name2"};
Arrays.stream(array)
.collect(Collectors.groupingBy(s -> s))
.forEach((k, v) -> System.out.println(k+" "+v.size()));
Sortie:
name5 1
name4 1
name3 1
name2 2
name1 1
Ce qu'il fait, c'est:
- Créer un
Stream<String>à partir du tableau d'origine - Regroupez chaque élément par identité, ce qui donne un
Map<String, List<String>> - Pour chaque paire de valeurs clés, imprimez la clé et la taille de la liste
Si vous voulez obtenir un Map qui contient le nombre d'occurrences pour chaque mot, cela peut être fait en faisant:
Map<String, Long> map = Arrays.stream(array)
.collect(Collectors.groupingBy(s -> s, Collectors.counting()));
Pour plus d'informations:
J'espère que ça aide! :)
J'ai écrit une solution pour que cela se pratique moi-même. Cela ne semble pas aussi génial que les autres réponses publiées, mais je vais le publier de toute façon, puis apprendre à le faire en utilisant également les autres méthodes. Prendre plaisir:
public static Integer[] countItems(String[] arr)
{
List<Integer> itemCount = new ArrayList<Integer>();
Integer counter = 0;
String lastItem = arr[0];
for(int i = 0; i < arr.length; i++)
{
if(arr[i].equals(lastItem))
{
counter++;
}
else
{
itemCount.add(counter);
counter = 1;
}
lastItem = arr[i];
}
itemCount.add(counter);
return itemCount.toArray(new Integer[itemCount.size()]);
}
public static void main(String[] args)
{
String[] array = {"name1","name1","name2","name2", "name2", "name3",
"name1","name1","name2","name2", "name2", "name3"};
Arrays.sort(array);
Integer[] cArr = countItems(array);
int num = 0;
for(int i = 0; i < cArr.length; i++)
{
num += cArr[i]-1;
System.out.println(array[num] + ": " + cArr[i].toString());
}
}
J'utiliserais une table de hachage avec en clé prend l'élément du tableau (ici chaîne) et en valeur un entier.
puis parcourez la liste en faisant quelque chose comme ceci:
for(String s:array){
if(hash.containsKey(s)){
Integer i = hash.get(s);
i++;
}else{
hash.put(s, new Interger(1));
}
Cela peut être fait de manière très simple en utilisant des collections, veuillez trouver le code ci-dessous
String[] array = {"name1","name1","name2","name2", "name2"};
List<String> sampleList=(List<String>) Arrays.asList(array);
for(String inpt:array){
int frequency=Collections.frequency(sampleList,inpt);
System.out.println(inpt+" "+frequency);
}
Ici, la sortie sera comme name1 2 name1 2 name2 3 name2 3 name2 3
Pour éviter d'imprimer des clés redondantes, utilisez HashMap et obtenez la sortie souhaitée
Utiliser HashMap c'est marcher dans le parc.
main(){
String[] array ={"a","ab","a","abc","abc","a","ab","ab","a"};
Map<String,Integer> hm = new HashMap();
for(String x:array){
if(!hm.containsKey(x)){
hm.put(x,1);
}else{
hm.put(x, hm.get(x)+1);
}
}
System.out.println(hm);
}
Vous pouvez le faire en utilisant Arrays.sort et Recursion. Le même vin mais dans une bouteille différente ....
import Java.util.Arrays;
public class ArrayTest {
public static int mainCount=0;
public static void main(String[] args) {
String prevItem = "";
String[] array = {"name1","name1","name2","name2", "name2"};
Arrays.sort(array);
for(String item:array){
if(! prevItem.equals(item)){
mainCount = 0;
countArray(array, 0, item);
prevItem = item;
}
}
}
private static void countArray(String[] arr, int currentPos, String item) {
if(currentPos == arr.length){
System.out.println(item + " " + mainCount);
return;
}
else{
if(arr[currentPos].toString().equals(item)){
mainCount += 1;
}
countArray(arr, currentPos+1, item);
}
}
}
Voici ma solution - La méthode prend en entrée un tableau d'entiers (en supposant une plage comprise entre 0 et 100) et renvoie le nombre d'occurrences de chaque élément.
disons que l'entrée est [21,34,43,21,21,21,45,65,65,76,76,76]. La sortie serait donc dans une carte et c'est: {34=1, 21=4, 65=2, 76=3, 43=1, 45=1}
public Map<Integer, Integer> countOccurrence(int[] numbersToProcess) {
int[] possibleNumbers = new int[100];
Map<Integer, Integer> result = new HashMap<Integer, Integer>();
for (int i = 0; i < numbersToProcess.length; ++i) {
possibleNumbers[numbersToProcess[i]] = possibleNumbers[numbersToProcess[i]] + 1;
result.put(numbersToProcess[i], possibleNumbers[numbersToProcess[i]]);
}
return result;
}
</code>Vous pouvez utiliser Hash Map comme indiqué dans l'exemple ci-dessous:
import Java.util.HashMap;
import Java.util.Set;
/**
*
* @author Abdul Rab Khan
*
*/
public class CounterExample {
public static void main(String[] args) {
String[] array = { "name1", "name1", "name2", "name2", "name2" };
countStringOccurences(array);
}
/**
* This method process the string array to find the number of occurrences of
* each string element
*
* @param strArray
* array containing string elements
*/
private static void countStringOccurences(String[] strArray) {
HashMap<String, Integer> countMap = new HashMap<String, Integer>();
for (String string : strArray) {
if (!countMap.containsKey(string)) {
countMap.put(string, 1);
} else {
Integer count = countMap.get(string);
count = count + 1;
countMap.put(string, count);
}
}
printCount(countMap);
}
/**
* This method will print the occurrence of each element
*
* @param countMap
* map containg string as a key, and its count as the value
*/
private static void printCount(HashMap<String, Integer> countMap) {
Set<String> keySet = countMap.keySet();
for (String string : keySet) {
System.out.println(string + " : " + countMap.get(string));
}
}
}
vous pouvez trouver en utilisant HashMap avec une technique simple
public class HashMapExample {
public static void main(String[] args) {
stringArray();
}
public static void stringArray()
{
String[] a = {"name1","name2","name3","name4", "name5"};
Map<String, String> hm = new HashMap<String, String>();
for(int i=0;i<a.length;i++)
{
String bl=(String)hm.get(a[i]);
if(bl==null)
{
hm.put(a[i],String.valueOf(1));
}else
{
String k=hm.get(a[i]);
int j=Integer.valueOf(k);
hm.put(a[i],String.valueOf(j+1));
}
}
//hm.entrySet();
System.out.println("map elements are "+hm.toString());
}
}
Ceci est un simple script que j'ai utilisé dans Python mais il peut être facilement adapté. Rien d'extraordinaire cependant.
def occurance(arr):
results = []
for n in arr:
data = {}
data["point"] = n
data["count"] = 0
for i in range(0, len(arr)):
if n == arr[i]:
data["count"] += 1
results.append(data)
return results
// Une réponse sans utiliser Hashset ou map ou Arraylist
public class Count {
static String names[] = {"name1","name1","name2","name2", "name2"};
public static void main(String args[]) {
printCount(names);
}
public static void printCount(String[] names){
Java.util.Arrays.sort(names);
int n = names.length, c;
for(int i=0;i<n;i++){
System.out.print(names[i]+" ");
}
System.out.println();
int result[] = new int[n];
for(int i=0;i<n;i++){
result[i] = 0;
}
for(int i =0;i<n;i++){
if (i != n-1){
for(int j=0;j<n;j++){
if(names[i] == names[j] )
result[i]++;
}
}
else if (names[n-2] == names[n-1]){
result[i] = result[i-1];
}
else result[i] = 1;
}
int max = 0,index = 0;
for(int i=0;i<n;i++){
System.out.print(result[i]+" ");
if (result[i] >= max){
max = result[i];
index = i;
}
}
}
}
Il existe plusieurs méthodes qui peuvent vous aider, mais celle-ci utilise la boucle for.
import Java.util.Arrays;
public class one_dimensional_for {
private static void count(int[] arr) {
Arrays.sort(arr);
int sum = 0, counter = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[0] == arr[arr.length - 1]) {
System.out.println(arr[0] + ": " + counter + " times");
break;
} else {
if (i == (arr.length - 1)) {
sum += arr[arr.length - 1];
counter++;
System.out.println((sum / counter) + " : " + counter
+ " times");
break;
} else {
if (arr[i] == arr[i + 1]) {
sum += arr[i];
counter++;
} else if (arr[i] != arr[i + 1]) {
sum += arr[i];
counter++;
System.out.println((sum / counter) + " : " + counter
+ " times");
sum = 0;
counter = 0;
}
}
}
}
}
public static void main(String[] args) {
int nums[] = { 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 5, 5, 6 };
count(nums);
}
}