Programa Java para encontrar elementos comunes entre dos arreglos

Dadas dos arrays y nuestra tarea es encontrar sus elementos comunes. 
Ejemplos:

Input:  Array1 = ["Article", "for", "Geeks", "for", "Geeks"], 
        Array2 = ["Article", "Geeks", "Geeks"]
Output: [Article,Geeks]

Input:  Array1 = ["a", "b", "c", "d", "e", "f"], 
        Array2 = ["b", "d", "e", "h", "g", "c"]
Output: [b, c, d, e]

Uso de métodos iterativos         

Acercarse: 

1. Obtenga las dos arrays Java.
2. Recorre todos y cada uno de los elementos de las arrays uno por uno y verifica si son comunes en ambos.
3. Agregue cada elemento común en el conjunto para entradas únicas.

// Java Program to find common elements
// in two Arrays
// Using iterative method
 
import java.io.*;
import java.util.*;
 
class GFG {
    private static void FindCommonElemet(String[] arr1,
                                         String[] arr2)
    {
        Set<String> set = new HashSet<>();
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr2.length; j++) {
                if (arr1[i] == arr2[j]) {
 
                    // add common elements
                    set.add(arr1[i]);
                    break;
                }
            }
        }
        for (String i : set) {
            System.out.print(i + " ");
        }
    }
 
    // main method
    public static void main(String[] args)
    {
 
        // create Array 1
        String[] arr1
            = { "Article", "in", "Geeks", "for", "Geeks" };
 
        // create Array 2
        String[] arr2 = { "Geeks", "for", "Geeks" };
 
        // print Array 1
        System.out.println("Array 1: "
                           + Arrays.toString(arr1));
 
        // print Array 2
        System.out.println("Array 2: "
                           + Arrays.toString(arr2));
 
        System.out.print("Common Elements: ");
 
        // Find the common elements
        FindCommonElemet(arr1, arr2);
    }
}

Array 1: [Article, in, Geeks, for, Geeks]
Array 2: [Geeks, for, Geeks]
Common Elements: Geeks for 

Complejidad del tiempo: O(n^2)

Uso de hashsets:

Al usar el método de retención de todos () de HashSet , podemos encontrar los elementos comunes entre dos arrays.

Sintaxis: 

// This method keeps only the common elements
// of both Collection in Collection1.

Collections1.retainAll(Collections2)

Acercarse : 

1. Consigue las dos arrays.
2. Cree dos hashsets y agregue elementos de arrays a esos conjuntos.
3. Encuentre los elementos comunes en ambos conjuntos usando el método Collection.retainAll() . Este método mantiene solo los elementos comunes de ambas Collection en Collection1.
4. El conjunto 1 ahora contiene solo los elementos comunes.

A continuación se muestra la implementación del enfoque anterior:

// Java Program to find common elements
// in two Arrays using hashsets
// and retainAll() method
import java.io.*;
import java.util.*;
 
class GFG {
 
    // function to create hashsets
    // from arrays and find
    // their common element
    public static void FindCommonElements(int[] arr1,
                                          int[] arr2)
    {
        // create hashsets
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
 
        // Adding elements from array1
        for (int i : arr1) {
            set1.add(i);
        }
 
        // Adding elements from array2
        for (int i : arr2) {
            set2.add(i);
        }
 
        // use retainAll() method to
        // find common elements
        set1.retainAll(set2);
        System.out.println("Common elements- " + set1);
    }
 
    // main method
    public static void main(String[] args)
    {
        // create Array 1
        int[] arr1
            = { 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 };
 
        // create Array 2
        int[] arr2 = { 100, 9, 64, 7, 36, 5, 16, 3, 4, 1 };
 
        // print Array 1
        System.out.println("Array 1: "
                           + Arrays.toString(arr1));
        // print Array 2
        System.out.println("Array 2: "
                           + Arrays.toString(arr2));
        FindCommonElements(arr1, arr2);
    }
}

Array 1: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Array 2: [100, 9, 64, 7, 36, 5, 16, 3, 4, 1]
Common elements- [16, 64, 1, 4, 36, 100, 9]

Complejidad de tiempo: O(n) Usando HashSet:                                                                                                                                   

Acercarse:

1. Agregue todos los elementos de la primera array en un hashset.

2. Repita la segunda array y verifique si el elemento está presente en el hashset usando el método contiene. Si contiene == verdadero, agregue el elemento para dar como resultado una array.

A continuación se muestra la implementación del enfoque anterior:

// Java program for the above approach
import java.io.*;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
 
class Test {
 
    private static void findCommonElements(int[] arr1,
                                           int[] arr2)
    {
         
        // Check if length of arr1 is greater than 0
        // and length of arr2 is greater than 0
        if (arr1.length > 0 && arr2.length > 0) {
            Set<Integer> firstSet = new HashSet<Integer>();
            for (int i = 0; i < arr1.length; i++) {
                firstSet.add(arr1[i]);
            }
           
            // Iterate the elements of the arr2
            for (int j = 0; j < arr2.length; j++) {
                if (firstSet.contains(arr2[j])) {
                    System.out.println(arr2[j]);
                }
            }
        }
    }
   
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6, 7 };
        int[] arr2 = new int[] { 1, 3, 4, 5, 6, 9, 8 };
       
        // Function Call
        findCommonElements(arr1, arr2);
    }
}

1
3
4
5
6

Complejidad de tiempo : O(n)