Question

我试图打印2个阵列A和B之间的非交集。但是，我有一个问题如何在不同的B上打印元素。这是我的示例代码：

public class Array {

    public static void main(String[] args) {
        for (int i = 0; i <= arrA.length - 1; i++) {
            arrA[i] = sc.nextInt();
        }
        for (int i = 0; i <= arrB.length - 1; i++) {
            arrB[i] = sc.nextInt();
        }

        boolean x = true;
        int y = 0;
        for (int i = 0; i < arrA.length; i++) {
            for (int j = 0; j < arrB.length; j++) {
                if (arrA[i] == arrB[j]) {
                    arrTestA[i] = true;
                }else y = arrA[i];
            }
        }

        for (int i = 0; i < arrA.length; i++) {
            x = x && arrTestA[i];
        }

        if (x) {
            System.out.println("All the elements of A contained in B.");
        }else {
            System.out.println("There are elements on A different B.");
            System.out.println("The elements of A which is not in B = "); //My Problem
        }

    }
}

Answer 1

要实现这一点，您可以使用openssl asn1parse -inform DER -in <publickey.der>和Collections方法。 E.g：

retainAll

ETA：非收集尝试：

List<Integer> arrTestA = new ArrayList<>();
List<Integer> arrTestB = new ArrayList<>();

[...]

List<Integer> common = new ArrayList<>(arrTestA);
common.retainAll(arrTestB);

List<Integer> diff = new ArrayList<>();
for(Integer element : arrTestA) 
    if(!common.contains(element))
        diff.add(element);

[here you print out elements of diff as The elements of A which is not in B]

...或循环可能如下所示：

int[] arr1 = { 1, 11, 5, 9, 4, 3, 4, 8 };
int[] arr2 = { 1, 7, 5, 3, 4, 8 };

Arrays.sort(arr1);
Arrays.sort(arr2);

for (int i : arr1) {
    boolean contains = false;
    for (int j : arr2) {
        if (i == j) {
            contains = true;
            break;
        }
    }
    if (!contains)
        System.out.println("Arr2 doesn't contain number: " + i);
}

这只是一种方法，但希望你明白这一点。

<强> ETA2：事实上，在我的方法中，这些数组不必排序。您只需删除负责排序的代码行即可。

Answer 2

您可以使用设置（它需要额外的空间来存储其元素，但代码很简单）：

Integer[] a = {0, 1, 2};
Integer[] b = {1, 2, 3};
Set<Integer> setFromA = new HashSet<>(Arrays.asList(a));
for (int num : b) {
    if (!setFromA.contains(num)) {
        System.out.println(num);
    }
}

使用Java 8 Stream API：

Arrays.stream(b).filter(num -> !setFromA.contains(num)).forEach(System.out::println);

此外，您可以将结果保存到新列表中（如果您愿意）：

List<Integer> result = Arrays.stream(b)
        .filter(num -> !setFromA.contains(num))
        .collect(Collectors.toList());

Answer 3

这个想法是对两个数组进行排序并完成两个数组。通过对它们进行排序，您不必交叉检查所有元素

   int[] arr1 = {1,3,5,6,7,4,8};
   int[] arr2 = {1,2,5,6,9,4,8};

    Arrays.sort(arr1);
    Arrays.sort(arr2);
    int j =0;
    for(int i = 0; i < arr1.length; i++){
        while(j < arr2.length && arr2[j] < arr1[i]){
            System.out.println("number: " +arr2[j]);
            j++;
        }

        if(arr2[j] != arr1[i]){
            System.out.println("number: " +arr1[i]);
        }else{
            j++;
        }
    }

Answer 4

我不建议在此使用列表，因为包含o(n)时间复杂度使用set作为其包含的常量时间:(如果您还想维护顺序，请转到LinkedHashSet）

// store array b into a set
Set<Integer> setInts = new HashSet<>(Arrays.asList(B);

// traverse array a, and check if set contains currrent element
for(int e : A)
{
   if(!setInts.contains(e))
     System.out.println(e);
}

找到2个数组的不同元素

4 个答案: