Java, intersection de deux tableaux

La solution la plus simple serait d'utiliser les jeux, aussi longtemps que vous n'avez pas de soins que les éléments dans le résultat aura un ordre différent, et que les doublons seront supprimés. L'entrée des tableaux array1 et array2 sont les Integer[] des sous-tableaux de l' int[] tableaux correspondant au nombre d'éléments que vous avez l'intention de traiter:

Set<Integer> s1 = new HashSet<Integer>(Arrays.asList(array1));
Set<Integer> s2 = new HashSet<Integer>(Arrays.asList(array2));
s1.retainAll(s2);

Integer[] result = s1.toArray(new Integer[s1.size()]);

La ci-dessus sera de retour une Integer[], si besoin, il est simple pour copier et convertir son contenu dans une int[].

Si vous ne voulez pas utiliser d'autres structures de données comme un Ensemble, puis l'idée de base est que vous voulez faire une itération sur les éléments de l'un des tableaux et, pour chaque valeur de voir si il s'affiche dans l'autre. Comment voyez-vous qu'il apparaît dans l'autre tableau? Promenade à travers les éléments dans l'autre tableau et pour chacun, de voir si sa valeur est égale à la valeur que vous recherchez. Je pense que vous serez mieux servis en essayant de travailler par le biais de ce problème sur votre propre au-delà de ce point, si votre but dans la prise de cette classe est d'apprendre à écrire du Java, mais vous êtes coincé, vous pourriez envisager de mettre à jour votre question avec le code que vous avez écrit de sorte que vous pouvez obtenir des informations plus détaillées et des pointeurs dans la bonne direction.

Avec les éléments en double dans la matrice de trouver de l'intersection.

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

    Arrays.sort(arr1);
    Arrays.sort(arr2);
    ArrayList result = new ArrayList<>();
    int i =0 ;
    int j =0;
    while(i< arr1.length && j<arr2.length){
    if (arr1[i]>arr2[j]){
        j++;

    }else if (arr1[i]<arr2[j]){
        i++;

    }else {
        result.add(arr1[i]);
        i++;
        j++;
    }
    }
    System.out.println(result);

si les tableaux sont triés

    int a1[]=new int[] {1,2,3,5,7,8};
int a2[]=new int [] {1,5,6,7,8,9};
//get the length of both the array
int n1=a1.length;
int n2=a2.length;
//create a new array to store the intersection
int a3[]=new int[n1];
//run the loop and find the intersection
int i=0,j=0,k=0;
while(i<n1&& j<n2) {
if(a1[i]<a2[j]) {
//a1 element at i are smaller than a2 element at j so increment  i
i++;
}else if(a1[i]>a2[j]) {
//a2 element at i are smaller than a2 element at j so increment  j
j++;
}else {
//intersection element store the value and increment i, j, k    to find the next element
a3[k]=a1[i];
i++;
j++;
k++;
}
}
for(int l=0;l<a3.length;l++) {
System.out.println(a3[l]);
}

Comment Trouver l'Intersection de 3 des ménagères de tableaux en Java:-

J'ai utilisé la Base de Java, à l'aide de boucles & à l'aide de Tableaux.copyOf pour atteindre cet objectif.

public class Intersection {
public void intersection3Arrays(int ar1[], int ar2[], int ar3[]) {
Arrays. sort(ar1);
Arrays. sort(ar2);
Arrays. sort(ar3);
int ar1Len = ar1.length;
int ar2Len = ar2.length;
int ar3Len = ar3.length;
int larArray = ar3Len > (ar1Len > ar2Len ? ar1Len : ar2Len) ? ar3Len : ((ar1Len > ar2Len) ? ar1Len : ar2Len);
System.out.println("The largest array is " +larArray);
int[] inputArray1 = Arrays.copyOf(ar1, larArray);
int[] inputArray2 = Arrays.copyOf(ar2, larArray);
int[] inputArray3 = Arrays.copyOf(ar3, larArray);
Integer[] inputArray11 = new Integer[inputArray1.length];
Integer[] inputArray22 = new Integer[inputArray2.length];
Integer[] inputArray33 = new Integer[inputArray3.length];
for (int i = 0; i < inputArray11.length; i++) {
if (inputArray11[i] == null){
inputArray1[i] = 0;
}
}
for (int i = 0; i < inputArray22.length; i++) {
if (inputArray22[i] == null){
inputArray1[i] = 0;
}
}
for (int i = 0; i < inputArray33.length; i++) {
if (inputArray33[i] == null){
inputArray1[i] = 0;
}
}
for (int i = 0; i < inputArray11.length; i++)
for (int j = 0; j < inputArray22.length; j++)
for (int k = 0; k < inputArray33.length; j++)
if (inputArray11[i] == inputArray22[j] && inputArray11[i] == inputArray33[k]) {
System.out.print(inputArray11[i]+" ");
}
} 
public static void main(String[] args) {
Intersection3Arrays arrays = new Intersection3Arrays();
int ar1[] = { 1, 2, 5, 10, 20, 40, 80 };
int ar2[] = { 80, 100, 6, 2, 7, 20 };
int ar3[] = {3, 4, 15, 20, 30, 70, 80, 120}; 
arrays.intersection3Arrays(ar1, ar2, ar3);
}
}

Vous pouvez trouver le intersection de deux tableaux avec:

T[] result = Arrays.stream(a1)
.filter(new HashSet<>(Arrays.asList(a2))::contains)
.toArray(T[]::new);

où T devrait être substituables par une référence de type Chaîne de caractères, Entier, etc.

bien que ce qui précède peut sembler comme il est en train de créer un nouveau jeu pour chaque élément, il est pas du tout le cas. plutôt qu'un ensemble instance est créée.

Le code ci-dessus est équivalente à:

List<T> list = new ArrayList<>();
HashSet<T> container = new HashSet<>(Arrays.asList(a2));
for (T s : a1) { 
if (container.contains(s)) list.add(s); 
}
T[] result = list.toArray(new T[0]);