Java 如何确定数组列表中的数字是否可被另一个数组列表中的数字整除？

我试图确定数组列表中的数字是否可以被antoher arraylist中的所有数字整除。下面的“我的代码”输出了

listdiv

列表中所有可被

listdivator

中的任何除数删除的数字。我想输出可被列表中所有除数整除的值，而不是其中任何一个。例如，如果我有listdiv=[1,2,3,5,8]和listdivisor=[2,4]。预期输出应为8，但此代码输出2和8

谢谢大家!！我们将非常感谢您的努力

for (int i = 0; i < listdiv.size(); i++) {
            for (int c = 0; c < listdivisor.size(); c++) {
                if (listdiv.get(i) % listdivisor.get(c) == 0) {
                System.out.println("final results are :  " + listdiv.get(i));
                }
            }
        }

for（int i=0；i

您的错误似乎是由于您在命中第一个匹配的除数时将股息计算为可被所有除数整除。相反，您需要添加跟踪所有除数的逻辑，并确保每个除数都使用给定的除数

System.out.println("final results are: ");

for (int i=0; i < listdiv.size(); i++) {
    boolean isDivisible = true;
    for (int c=0; c < listdivisor.size(); c++) {
        if (listdiv.get(i) % listdivisor.get(c) != 0) {
            isDivisible = false;
            break;
        }
    }

    if (isDivisible) {
        System.out.println(listdiv.get(i));
    }
}

System.out.println（“最终结果为：”）；
对于（int i=0；i

您的条件检查至少可被一个除数整除的值，这不是您想要的

在生成输出之前，需要检查所有除数：

for (int i = 0; i < listdiv.size(); i++) {
    boolean divisible = true;
    for (int c = 0; c < listdivisor.size() && divisible; c++) {
        if (listdiv.get(i) % listdivisor.get(c) != 0) {
            divisible = false;
        }
    }
    if (divisible) {
        System.out.println("final results are :  " + listdiv.get(i));
    }
}

for（int i=0；i

在下面的解决方案中，当第一个列表中的元素不能被第二个列表中的任何元素整除时，我将继续外部for循环。如果没有这种情况发生，将调用println

outer: 
for (int i = 0; i < listdiv.size(); i++) {
    for (int c = 0; c < listdivisor.size(); c++) {
        if (listdiv.get(i) % listdivisor.get(c) != 0) {
            continue outer;
        }
    }
    System.out.println("Found :  " + listdiv.get(i));
}

外部：
对于（int i=0；i

此解决方案不需要任何额外的变量（例如布尔值以保持可整除状态），并使用不太为人所知的java 8的另一种方式：

List<Integer> collect = listdiv.stream().filter(p ->
        listdivisor.stream().allMatch(d -> p % d == 0)
).collect(Collectors.toList());

---

目前提出的算法都是O（N*M）。通过首先查找第一个列表的值并使用该值过滤第二个列表，可以得到O（N+M）

int thelcm = 1
for(int i : listdivisor) {
  thelcm = lcm(thelcm, i);
}

ArrayList<Integer> result = new ArrayList<>();
for(int j : listdiv) {
  if( j % thelcm == 0 ) {
    result.put(j);
  }
}

int-thelcm=1
for（int i:listdivisor）{
thelcm=lcm（thelcm，i）；
}
ArrayList结果=新建ArrayList（）；
for（int j:listdiv）{
如果（j%thelcm==0）{
结果：put（j）；
}
}

我们可以使用Set获得预期的输出，我已经修改了您的代码

Set<Integer> firstIteration = new HashSet<>();
        Set<Integer> nextIteration = new HashSet<>();
        for (int c = 0; c < divisors.size(); c++) {
            for (int i = 0; i < numbers.size(); i++) {
                if (numbers.get(i) % divisors.get(c) == 0) {
                    if (c == 0) {
                        firstIteration.add(numbers.get(i));
                    } else {
                        nextIteration.add(numbers.get(i));
                    }
                }

            }
            if (c != 0) {
                // We will perform Set intersection here for each iteration
                firstIteration.retainAll(nextIteration);
            }
        }
        System.out.println(firstIteration);

Set firstIteration=new HashSet（）；
Set nextIteration=new HashSet（）；
对于（int c=0；c

---

希望这能解决您的问题

谢谢，您的代码也能正常工作，但我只能选择一个！谢谢你，你的代码也很好用，但我只能选择一个！当输入列表如此小时，并行实际上会更慢。尽管如此，还是要投票支持Java8流解决方案。

Set<Integer> firstIteration = new HashSet<>();
        Set<Integer> nextIteration = new HashSet<>();
        for (int c = 0; c < divisors.size(); c++) {
            for (int i = 0; i < numbers.size(); i++) {
                if (numbers.get(i) % divisors.get(c) == 0) {
                    if (c == 0) {
                        firstIteration.add(numbers.get(i));
                    } else {
                        nextIteration.add(numbers.get(i));
                    }
                }

            }
            if (c != 0) {
                // We will perform Set intersection here for each iteration
                firstIteration.retainAll(nextIteration);
            }
        }
        System.out.println(firstIteration);