Question

假设我有两个数组;

Integer[] array= { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 200, 5, 6, 5 };
Integer[] array2= { 12, 2 ,3, 2, 200, 5 };

我试图创建一个方法，返回一个除去了所有元素的数组，除了那些同样存在于array2中的元素，所以这个方法的输出应该是

{2 ,3, 5, 200, 5, 5 }

我不想使用其他数据结构，我不知道如何编写我想尝试的内容，我不知道如何确定生成的数组长度

感谢

Answer 1

这是一个只使用数组而根本没有其他数据结构的解决方案。 retainAll方法将返回一个包含一些空值的数组。您可以创建一些代码来使用该数组并创建一个没有空值的数组。它真的很容易。

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        Integer[] array = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 200, 5, 6, 5 };
        Integer[] array2 = { 12, 2, 3, 2, 200, 5 };

        Integer[] res = retainAll(array, array2);
        String str = Arrays.toString(res);
        System.out.println(str);
        res = removeArrayDuplicates(res);
        str = Arrays.toString(res);
        System.out.println(str);

    }

    public static Integer[] retainAll(Integer[] a, Integer[] b) {

        int ln1 = a.length;
        int ln2 = b.length;

        Integer[] res = new Integer[(ln1 < ln2) ? ln1 : ln2];
        Integer[] small = (ln1 < ln2) ? a : b;
        Integer[] big = (ln1 < ln2) ? b : a;

        boolean found = false;

        for (int i = 0; i < small.length; i++) {
            found = arrayContains(big, small[i]);
            if (found == true) {
                res[i] = small[i];
            }

        }

        return res;

    }

    public static Integer[] removeArrayDuplicates(Integer[] a) {

        int len = a.length;
        int dups = 0;
        boolean noNulls = false;

        for (int i = 0; i < len; i++) {

            for (int j = i + 1; j < len; j++) {

                noNulls = a[i] != null && a[j] != null;

                if (noNulls && a[i].equals(a[j])) {
                    a[j] = null;
                    dups++;
                }
            }

        }

        return a;

    }

    public static boolean arrayContains(Object[] a, Integer b) {
        boolean contains = false;

        for (Object c : a) {
            if (c != null && c.equals(b)) {
                contains = true;
                break;
            }
        }

        return contains;
    }

}

Answer 2

如果我理解您的问题，您可以先创建一个contains(Integer[], Integer)方法。如果数组包含值，则迭代数组并返回true。

private static boolean contains(Integer[] a, Integer v) {
    for (Integer t : a) {
        if (t.equals(v)) {
            return true;
        }
    }
    return false;
}

然后你可以利用它来迭代你的数组两次。一次执行计数，第二次用count个元素填充新创建的数组。像，

public static Integer[] retainAll(Integer[] a, Integer[] b) {
    int count = 0;
    for (Integer val : a) {
        if (contains(b, val)) {
            count++;
        }
    }
    Integer[] out = new Integer[count];
    count = 0;
    for (Integer val : a) {
        if (contains(b, val)) {
            out[count++] = val;
        }
    }
    return out;
}

然后测试一下，

public static void main(String[] args) {
    Integer[] array = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 200, 5, 6, 5 };
    Integer[] array2 = { 12, 2, 3, 2, 200, 5 };
    System.out.println(Arrays.toString(retainAll(array, array2)));
}

输出是请求的

[2, 3, 5, 200, 5, 5]

当然，您也可以使用Arrays.asList(T...)和retainAll()之类的

public static Integer[] retainAll(Integer[] a, Integer[] b) {
    List<Integer> al = new ArrayList<>(Arrays.asList(a));
    al.retainAll(Arrays.asList(b));
    return al.toArray(new Integer[al.size()]);
}

从另一个数组中的数组中保留数组中的特定元素

2 个答案: