计数重复列表(java)

zmeyuzjn  于 2021-07-13  发布在  Java
关注(0)|答案(5)|浏览(290)

这个问题在这里已经有答案了

从arraylist获取副本数(3个答案)
四年前关门了。
我想在java中计算arraylist中的重复项,怎么做?
特别是,我想创建一个应用程序,告诉我在给定的数字中有多少素数因子,并将它们全部保存在一个整数数组列表中。
然后,arraylist如下所示(例如,数字100)[2,2,5,5]
我想数一数有多少2,有多少5。。。
提前谢谢!

bvhaajcl

bvhaajcl1#

可以使用集合的频率函数: int occurrences = Collections.frequency(yourList, whatToCount) ;

pbpqsu0x

pbpqsu0x2#

您可以在这个用例中使用map。如下所示:
//将所有值放在Map中

for (Integer temp : list) {
            Integer count = map.get(temp);
            map.put(temp, (count == null) ? 1 : count + 1);
        }

//复制Map和视图

for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
        System.out.println("Found Duplicate for " + entry.getKey() + "  "
            + entry.getValue()+"  times.");
    }
j2datikz

j2datikz3#

通过使用groupingby和这样的计数,您可以获得频率计数

List<Integer> factors = ...
Map<Integer, Long> factorCount = factors.stream()
                            .collect(Collectors.groupingBy(i -> i), Collectors.counting());

在生成每个因子时,计算每个因子的数目将非常简单,而不是生成一个列表。

public static void main(String... args) {
    System.out.println(factorise(2L*2*2*5*5*49*11));
}

static Map<Long, Integer> factorise(long value) {
   Map<Long, Integer> map = new LinkedHashMap<>();
   for (int i = 2; i * i <= value; i++) {
       while (value % i == 0) {
           map.merge((long) i, 1, (p, n) -> p == null ? n : p + n);
           value /= i;
       }
   }
   if (value > 1)
       map.put(value, 1);
   return map;

}
印刷品
{2=3, 5=2, 7=2, 11=1}

70gysomp

70gysomp4#

如果您想手动执行此操作,可以使用 for 回路和a Map :

//Get your list in the appropriate way
ArrayList list = getList();

//Make a HashMap
HashMap<int,int> map = new HashMap<>();

for (int i : list) {
    if (map.containsKey(i)) {
        map.put(i, map.get(i)+1);
    } else {
        map.put(i, 1);
    }
}

然后你会有一张Map int 出现次数的键 intList .

cbjzeqam

cbjzeqam5#

您可以使用Map和 Package 器模式来封装一组方法来计算素数以及其他内容。
这与@peter lawrey的解决方案有些不同,因为它在junit框架和lambda流上使用单元测试。此解决方案可能有助于动态测试和检查方法的计算是否正确。

public class ComputePrime {

    public boolean isPrime(int n) {
        int i;
        for (i = 2; i <= n/2 ; i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public void throwExceptionIfIsNotPrime(int n){
        if(!isPrime(n))
            throw new IllegalStateException("It is not prime");
    }

    public List<Integer> generatePrime(int n){
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; i++) {
            if(isPrime(i))
                primes.add(i);
            else continue;
        }

        if(primes.isEmpty())
            return Collections.EMPTY_LIST;
        else return primes;
    }

    public List<Integer> dupPrimes(List<Integer> primes){
        primes.forEach( i-> throwExceptionIfIsNotPrime(i) );

        List<Integer> dupPrimes = new ArrayList<>();
        for (Integer prime : primes) {

            dupPrimes.add(prime);
            dupPrimes.add(prime);

        }
        return dupPrimes;
    }

    public List<Integer> dupRandonPrimes(List<Integer> primes){
        primes.forEach( i-> throwExceptionIfIsNotPrime(i) );

        List<Integer> dupPrimes = new ArrayList<>();
        for (Integer prime : primes) {
            dupPrimes.addAll(generatePrimeDup(prime));
        }
        return dupPrimes;
    }

    private Collection<? extends Integer> generatePrimeDup(final Integer prime) {
        final int n = ((int) (Math.random()*10) % 10) +1;
        List<Integer> dupPrimes = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            dupPrimes.add(prime);
        }

        return dupPrimes;
    }

    public Map<Integer,Long> countPrimes(List<Integer> primes){
        Map<Integer,Long> primeOnMap = new HashMap<>();

        primes.forEach( i-> throwExceptionIfIsNotPrime(i) );

        for (Integer prime : primes) {
            long count = primes
                            .stream()
                            .filter(i -> i == prime)
                            .count();

            primeOnMap.put(prime, count);
        }
        return primeOnMap;
}}
public class ArrayListSolutionTest {

    @Test
    public void testCheckGeneratePrimeOnList() throws Exception {
        List<Integer> primes     = new ComputePrime().generatePrime(100);
        List<Integer> dupPrimes  = new ComputePrime().dupPrimes(primes);

        Assert.assertTrue( !primes.isEmpty() );
        Assert.assertEquals((primes.size() * 2), dupPrimes.size());
    }

    @Test
    public void testCountPrimeOnList() throws Exception {
        List<Integer> primes     = new ComputePrime().generatePrime(100);
        List<Integer> dupPrimes  = new ComputePrime().dupPrimes(primes);

        Map<Integer, Long> countPrimes = new ComputePrime().countPrimes(dupPrimes);

        Assert.assertEquals( countPrimes.size(), dupPrimes.size()/2 );

        for (Map.Entry<Integer, Long> entry : countPrimes.entrySet()) {
            Assert.assertEquals( entry.getValue(), new Long(2) );
        }
    }

    @Test
    public void testCountPrimeOnList_Aleatory() throws Exception {
        List<Integer> primes          = new ComputePrime().generatePrime(100);
        List<Integer> aleatoryPrimes  = new ComputePrime().dupRandonPrimes(primes);

        Map<Integer, Long> countPrimes = new ComputePrime().countPrimes(aleatoryPrimes);

       Assert.assertNotNull( countPrimes );
    }}

相关问题