重複リストをカウントする（Java）

Question

JavaのArrayListで重複を数えたいのですが、どうすればいいですか？

特に、与えられた数にいくつの素因数が含まれているかを示すアプリケーションを作成したいと思います。それらをすべて整数のArrayListに保存します。私は5どのように多くは、ある何とかどのように多くの2カウントしたい

その後、ArrayListには、（数100、たとえば）このようになります[2、2、5、5]

...

ありがとうございます！

Answer 1

このユースケースでは、マップを利用できます。以下のような何か：

：地図

内のすべての値

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

// Iterareマップとビューが

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

Answer 2

を複製しますが、コレクションの周波数関数を使用することができますを入れ

// int occurrences = Collections.frequency(yourList, whatToCount) ;

Answer 3

groを使用すると、 upingByとこのように数える

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、= 2 5 = 2 7、11 = 1}

Answer 4

手動でこれを実行したい場合、次のことができあなたはその後、に関連するマップを持っています

//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); 
    } 
} 

：forループとMapを使用は、Listにあるintの出現回数をキーします。

Answer 5

Mapとラッパーパターンを使用して、素数などの計算方法のセットを囲むことができます。

jUnitフレームワークでユニットテストを使用しており、Stream Lambdaを使用しているため、これは@Peter Lawreyとは少し異なる解決策です。このソリューションは、メソッドが正しく計算されているかどうかを動的にテストしてチェックするのに役立ちます。

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); 
    }}