How do I count the duplicate items in an ArrayList?
I need to split and count how many values in an arraylist are the same and print them according to the number of occurrences.
I have an arraylist called numbers:
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
I created a method that strips each value and stores it in a new array.
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;
}
After that, I have a new array called numbers. I am using sorting by this array
Collections.sort(numbers);
and my ArrayList looks like this:
[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]
He has:
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;
I need to print a string of numbers, depends on how many of them So let's say it looks like this: 1354678290
source to share
Using the Stream API, eg.
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));
}
}
source to share
Ok, for this you can try using 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);
}
After the forEach loop ends, you will have a filled map with your elements against it.
source to share
The question is to count how many of them there are two and three in the array. In Java 7 the solution is:
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
}}
In Java 8, the solution to the problem is:
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 ) );
}}
Another way is to use Collections.frequency. Decision:
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));
}
}}
Another method is to change the int array to Integer List using the => Arrays.stream (array) .boxed () method. collect (Collectors.toList ()) and then get the integer used for the loop.
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
}
source to share
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");
});
}
source to share
Use below function to count duplicate items:
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();
}
}
source to share
You can count the number of duplicate items in a list by adding all the items in the list and storing it in a hashset, once that's done, all you need to know is to get the difference in hash size and the list.
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);
Let me know if this needs clarification
source to share