计数重复列表（Java）
我想在Java中计算ArrayList中的重复项，如何计算 特别是，我想创建一个应用程序，告诉我给定数字中有多少素数因子，并将它们全部保存在整数数组列表中 然后，ArrayList看起来像这样（例如，数字100）[2，2，5，5] 我想数一数有多少2，有多少5计数重复列表（Java）,java,arraylist,duplicates,Java,Arraylist,Duplicates,我想在Java中计算ArrayList中的重复项，如何计算 特别是，我想创建一个应用程序，告诉我给定数字中有多少素数因子，并将它们全部保存在整数数组列表中 然后，ArrayList看起来像这样（例如，数字100）[2，2，5，5] 我想数一数有多少2，有多少5 提前谢谢 您可以在这个用例中使用Map。如下所示： //将所有值放入映射中 for (Integer temp : list) { Integer count = map.get(temp);
提前谢谢 您可以在这个用例中使用Map。如下所示： //将所有值放入映射中
for (Integer temp : list) {
Integer count = map.get(temp);
map.put(temp, (count == null) ? 1 : count + 1);
}
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println("Found Duplicate for " + entry.getKey() + " "
+ entry.getValue()+" times.");
}
for（Map.Entry:Map.entrySet（））{
System.out.println（“为“+entry.getKey（）+”找到重复项”
+entry.getValue（）+“times.”）；
}
for (Integer temp : list) {
Integer count = map.get(temp);
map.put(temp, (count == null) ? 1 : count + 1);
}
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println("Found Duplicate for " + entry.getKey() + " "
+ entry.getValue()+" times.");
}
for（Map.Entry:Map.entrySet（））{
System.out.println（“为“+entry.getKey（）+”找到重复项”
+entry.getValue（）+“times.”）；
}
int executions=Collections.frequency（yourList，whatToCount）您可以使用集合的频率功能：
int executions=Collections.frequency（yourList，whatToCount）您可以使用groupingBy和这样的计数来获得频率计数
List<Integer> factors = ...
Map<Integer, Long> factorCount = factors.stream()
.collect(Collectors.groupingBy(i -> i), Collectors.counting());
列出因素=。。。
Map 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;
publicstaticvoidmain（字符串…参数）{
System.out.println（factorse（2L*2*2*5*5*49*11））；
}
静态映射因子（长值）{
Map Map=newlinkedhashmap（）；
对于（int i=2；i*ip==null？n:p+n）；
值/=i；
}
}
如果（值>1）
map.put（值1）；
返回图；
}
印刷品
{2=3，5=2，7=2，11=1}您可以通过使用groupingBy和这样的计数来获得频率计数
List<Integer> factors = ...
Map<Integer, Long> factorCount = factors.stream()
.collect(Collectors.groupingBy(i -> i), Collectors.counting());
列出因素=。。。
Map 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;
publicstaticvoidmain（字符串…参数）{
System.out.println（factorse（2L*2*2*5*5*49*11））；
}
静态映射因子（长值）{
Map Map=newlinkedhashmap（）；
对于（int i=2；i*ip==null？n:p+n）；
值/=i；
}
}
如果（值>1）
map.put（值1）；
返回图；
}
印刷品
{2=3，5=2，7=2，11=1}如果要手动执行此操作，可以使用for
循环和映射：
//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);
}
}
//以适当的方式获取您的列表
ArrayList=getList（）；
//制作一个HashMap
HashMap=newHashMap（）；
用于（int i:列表）{
if（图1）{
map.put（i，map.get（i）+1）；
}否则{
图.put（i，1）；
}
}
然后，您将拥有一个映射，该映射将int
键与列表中该int
的出现次数相关联。如果您想手动执行此操作，可以使用for
循环和映射：
//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);
}
}
//以适当的方式获取您的列表
ArrayList=getList（）；
//制作一个HashMap
HashMap=newHashMap（）；
用于（int i:列表）{
if（图1）{
map.put（i，map.get（i）+1）；
}否则{
图.put（i，1）；
}
}
然后，您将在列表中有一个将int
键与该int
的出现次数相关的映射您可以使用和包装模式来封装一组方法来计算素数以及其他内容
这与@Peter Lawrey的解决方案有点不同，因为它在jUnit框架和上使用单元测试。此解决方案可能有助于动态测试和检查方法是否正确计算
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;
}}
公共类ComputePrime{
公共布尔iPrime（int n）{
int i；
对于（i=2；i通过ExceptionIFisnotTime（i））；
List dupPrimes=new ArrayList（）；
for（整数素数：素数）{
addAll（generatePrimeDup（prime））；
}
返回素数；
}
私有集合您可以使用和包装器模式来封装一组方法来计算素数以及其他内容
这与@Peter Lawrey的解决方案有点不同，因为它在jUnit框架和上使用了一个单元测试。这个解决方案可能有助于动态测试和检查方法的计算是否正确
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;
}}
公共类ComputePrime{
公共布尔iPrime（int n）{
int i；
对于（i=2；i通过ExceptionIFisnotTime（i））；
List dupPrimes=new ArrayList（）；
for（整数素数：素数）{
addAll（generatePrimeDup（prime））；
}
返回素数；
}
私人收藏