Создать массив значений, которые появляются в обоих заданных массивах Java

Question

Мне нужно создать массив со значениями, которые появляются в обоих заданных массивах.

Я думал о циклическом просмотре каждого из массивов и сравнении значений, если они совпадают, увеличьте переменную 'counter', которая будет длиной нового массива, выполните цикл по новому массиву и присвойте значения элементам массива.

Мне нужно найти решение с помощью цикла, приведенный ниже код - это то, что я получил до сих пор

class New {
    public static void main(String[] args) {

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

        int counter = 0;
        int combined[] = new int[counter];

        for (int s = 0; s < arr1.length; s++) {
            for (int x = 0; x < arr2.length; x++) {
                for (int i = 0; i < combined.length; i++) {
                    if (arr1[s] == arr2[x]) {
                        counter++;
                        combined[i] = arr1[s];
                    }

                }
            }
            for (int i = 0; i < combined.length; i++) {
                System.out.print(combined[i] + " ");
            }
        }
    }
}

Answer 1

В Java 8 вы можете попробовать:

public static void main(String[] args) {
        Integer[] arr1 = {2, 4, 5, 7, 9, 10};
        Integer[] arr2 = {1, 2, 5, 6, 8};
        List<Integer> integers = Stream.of(arr1)
                .filter(Arrays.asList(arr2)::contains)
                .collect(Collectors.toList());
        System.out.println(integers);
}

Вывод будет:

[2, 5]

Answer 2

Первая проблема состоит в том, что вы инициализируете массив combined в 0, чтобы он не содержал ничего, и вторая проблема заключается в том, что у вас есть один for цикл для многих, один над массивом combined.

Вместо этого вам нужно создать временный массив, который будет достаточно большим, чтобы охватить все возможные дубликаты, а затем скопировать из временного массива в массив нужного размера.

public static void main(String[] args) {
    int arr1[] = { 2, 4, 5, 7, 9, 10 };
    int arr2[] = { 1, 2, 5, 6, 8 };

    int min = Math.min(arr1.length, arr2.length); //We can never have more duplicates than the number of elements in the smallest array
    int counter = 0;
    int combined[] = new int[min];

    for (int s = 0; s < arr1.length; s++) {
        for (int x = 0; x < arr2.length; x++) {
            if (arr1[s] == arr2[x]) {
                combined[counter] = arr1[s];
                counter++;
                break; //We have found a duplicate, exit inner for loop and check next digit in outer loop
            }
        }
    }
    int[] result = Arrays.copyOf(combined, counter); //This makes a copy of the array but only with the number of elements that are used
    for (int i = 0; i < result.length; i++) {
        System.out.print(result[i] + " ");
    }
}

Если вы не хотите использовать Arrays.copy, вы можете выполнить копирование самостоятельно, просто замените эту строку на

int[] result = new int[counter]
for (int j = 0; j < counter; j++) {
    result[j] = combined[j];
}

Answer 3

public static int[] intersection(int[] arr1, int[] arr2) {
    Set<Integer> elements = IntStream.of(arr1).boxed().collect(Collectors.toSet());
    return IntStream.of(arr2).filter(elements::contains).toArray();
}

Или используя только int[]:

// create temporary array to not modify input data
int[] tmp = Arrays.copyOf(arr1, arr1.length);
Arrays.sort(tmp);

for(int v : arr2)
    if(Arrays.binarySearch(tmp, v) >= 0)
        System.out.print(v + " ");

Answer 4

Если вы хотите решить эту проблему, используя только массивы и итерации, Вы можете:

1. сортировка входных массивов: O (n log n)
2. Итерация по массивам: O (n)

код:

public static void main(String[] args) {
    ...

    // make sure input arrays are sorted
    Arrays.sort(arr1);
    Arrays.sort(arr2);

    List<Integer> common = new ArrayList<Integer>();

    int i = 0, j = 0;
    while (i < arr1.length && j < arr2.length) {

        int v1 = arr1[i];
        int v2 = arr2[j];

        if (v1 == v2) {
            common.add(v1);
            i++;
            j++;
        } else if (v1 < v2) {
            i++;
        } else {
            j++;
        }
    }

    System.out.println(common);
}

на каждой итерации вы двигаетесь вперед:

• индекс arr1 (i)
• или индекс arr2 (j)
• или оба

нет версии ArrayList:

public static void main(String[] args) {
    ...

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

    int found = 0;
    int[] common = new int[Math.min(arr1.length, arr2.length)];

    int i = 0, j = 0;
    while (i < arr1.length && j < arr2.length) {

        int v1 = arr1[i];
        int v2 = arr2[j];

        if (v1 == v2) {
            common[found] = v1;
            found++;
            i++;
            j++;
        } else if (v1 < v2) {
            i++;
        } else {
            j++;
        }
    }

    for (int k = 0; k < found; k++) {
        System.out.println("common: " + common[k]);
    }
}

Answer 5

Это поможет:

public static void main(String[] args) {

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

    int combined[] = new int[arr1.length];

    for (int x = 0; x < arr1.length; x++) {
        for (int i = 0; i < arr2.length; i++) {
            if (arr1[x] == arr2[i]) {
                combined[x] = arr1[x];
            }

        }
    }
    for (int i = 0; i < combined.length; i++) {
        System.out.print(combined[i] + " ");
    }
}

1. Вам не нужно 3 цикла, чтобы найти дубликаты между двумя массивами.
2. Здесь внешний цикл перебирает больший массив (arr1) и внутренний цикл повторяется по меньшему массиву (arr1).
3. combined определен, чтобы иметь тот же размер большего массива (чтобы избежать любых ArrayOutOfBoundsException)
4. После завершения вложенного цикла, combined будет содержать только повторяющиеся записи вместе с некоторыми нулями, как это было инициализировано, используя размер из arr1. (В качестве упражнения вы можете изменить цикл, чтобы отфильтровать ненулевые элементы, указывающие только на дубликаты!)

Answer 6

Вот, пожалуйста:

int[] intersection = IntStream.of(arr1)
            .filter(v1 -> IntStream.of(arr2).anyMatch(v2 -> v2 == v1))
            .toArray();