# 2 Arrays vergleichen (Unterschiedliche Längen)



## javaRekrut (16. Aug 2016)

Guten Tag ,
ich möchte zwei Integer-Arrays miteinander vergleichen. Leider stelle ich mich etwas unglücklich bei der Forumsuche an, weshalb ich hier auf eine gescheite Antwort hoffe.


```
public class ArrayVergleich {

    public static void main(String[] args) {
        int[] liste = {1,2,3,4,5};
        int[] prüf = {1,2,3};
        //TODO: prüfe ob 'prüf' in 'liste' enthalten ist
    }
}
```

Ich möchte, dass wenn die Elemente aus `int[] prüf` in dem Array `int[] liste` enthalten sind z.B `System.out.println("Elemente sind enthalten");` dann folgt.

Danke im vorraus.


----------



## Nuiton (16. Aug 2016)

Erster Treffer.

Edit: Meine (schnelle) Umsetzung.

```
import java.util.Arrays;

public class Test
{
    public boolean isEqualArray(int []f, int[] g)
    {
        Arrays.sort(f);
        Arrays.sort(g);
        if (Arrays.equals(f, g))
            return true;
        return false;
    }

    public static void main(String args[])
    {
        Test t = new Test();
        // Arrays
        int [] a = {1,2,3,4,5,6};
        int [] b = {1,2,3,4,5};
      
        if (t.isEqualArray(a, b))
        {
            System.out.println("Gleiche Elemente");
        }

        else
        {
            System.out.println("Nicht gleiche Elemente");
        }
    }
}
```


----------



## javaRekrut (16. Aug 2016)

welcher der vielen Antworten dort präferierst du . Ich blick da ehrlich gesagt noch nicht durch. Zumal die Antworten eher darauf geschnitzt für Arrayvergleich mit gleicher Länge, wenn ich es richtig verstanden habe (mein Englisch ist autsch )

Ich dachte da an einer Lösung wie

if (prüf.equals(liste)) {
    System.out.println("Elemente sind enthalten.");
}


----------



## Nuiton (16. Aug 2016)

Ich habe meine Antwort nochmal aktualisiert.


----------



## javaRekrut (16. Aug 2016)

also bei mir spuckt dein geposteter Code "Nicht gleiche Elemente" raus. =/


----------



## Nuiton (16. Aug 2016)

if (a.equals(b)) { ... } kannst du in diesem Fall nicht benutzen.

Und die Arrays in meinem Beispiel sind nicht deine Arrays. Die muss ich doch nicht fuer dich noch ersetzen, oder?


----------



## javaRekrut (16. Aug 2016)

ne hab erstmal dein Beispiel getestet mit deinen arrays, sprich all copy and paste in ein neues Projekt. Das auswechseln der Inhalte schaff ich schon  nur gibt mir dein Code an sich mit deinen Beispielen "Nicht gleiche Elemente" obwohl da gleiche Elemente enthalten sind.

Gibt er dir "Gleiche Elemente" raus wenn du es ausführst?


----------



## Nuiton (16. Aug 2016)

Du kannst die Methode noch anpassen, um zu checken, ob eine bestimmte Anzahl an Elementen gleich sind. Je nachdem was dieser "limit" ist, kannst du dann was machen.

Beispiel:

```
import java.util.Arrays;

public class Test
{
    public void getEqualElements(int []f, int[] g)
    {
        Arrays.sort(f);
        Arrays.sort(g);
        int counter = 0;
  
        if (f.length < g.length)
        {
            int tempIndex = f.length;
      
            for (int i = 0; i < tempIndex; i++)
            {
                ...
                    counter++;
            }
            System.out.println("Arrays enthalten "+ counter +" gleiche Elemente.");
        }
  
        else if (g.length < f.length)
        {
            int tempIndex = g.length;
      
            for (int i = 0; i < tempIndex; i++)
            {
               ...
                    counter++;
            }
            System.out.println("Arrays enthalten "+ counter +" gleiche Elemente.");
        }

        else {
       ...
       }


  
    }

    public static void main(String args[])
    {
        Test t = new Test();

        ... meine Integer Arrays ...

        t.getEqualElements(a, b);
  
    }

}
```


----------



## javaRekrut (16. Aug 2016)

Danke für deine Bemühungen 
Ich glaube mein anliegen ist etwas komplexer als erwartet. Vielleicht sprengt das auch mein Beginner-Rahmen. Sowie ich den Code verstehe, sortiert er beide Listen erstmal nach Größe (Arrays.sort(bla)) und danach wird f_-_Wert mit g-Wert verglichen. Dies würde leider schon zB an solch zwei Listen scheitern:
Array1: 1,2,3,4,5
Array2: 1,3,5

Indexposition [0] ist identisch aber Indexposition [1] haben verschiedene Werte. An sich hatte ich auch erst die Idee anhand der Indexposition die Vergleiche zu machen, aber dann stieß ich auf das eben erwähnte Problem =/


----------



## Nuiton (17. Aug 2016)

Pure Arrays funktionieren in diesem speziellen Fall auch nicht mehr. Fuer mehr Funktionalitaet brauchst du ArrayLists.


----------



## tommysenf (17. Aug 2016)

```
public class Test {
 
    public static boolean contains(int[] data, int[] test) {
        for(int i : test) {
           if(!contains(data,i)) {
               return false;
            }
        }
        return true;
    }

    
    public static boolean contains(int[] data, int test) {
        for(int i : data) {
           if(i == test) {
               return true;
            }
        }
        return false;
    }

    public static void main(String args[])
    {
        
        // Arrays
        int [] a = {1,2,3,4,5,6};
        int [] b = {1,2,3,4,5};
     
        if (contains(a, b)) {
            System.out.println("Alle Elemente enthalten");
        } else {
            System.out.println("Nicht alle Elemente enthalten");
        }
    }
}
```


----------



## Nuiton (17. Aug 2016)

Benutze mal die folgenden Arrays:

```
int [] a = {1,2,3,4,5,6};
int [] b = {0,5,4,1,9};
```

3 Elemente in b welche in a sind. Ich glaube, der TE moechte wissen welche Elemente behalten sind.


----------



## tommysenf (17. Aug 2016)

javaRekrut hat gesagt.:


> Ich möchte, dass wenn die Elemente aus int[]prüf in dem Array int[]liste enthalten sind z.B System.out.println("Elemente sind enthalten"); dann folgt.





Nuiton hat gesagt.:


> Ich glaube, der TE moechte wissen welche Elemente behalten sind.



Das glaube ich nicht.


----------



## Nuiton (17. Aug 2016)

Sicher? Teste deinen Code noch ein paar mal. 

```
int [] a = {1,3,9,10,0,12,65};
int [] b = {3,10,1,9,12,4};
```
1,3,9,10,12 gehoeren zu a und b.
Gleicher Fall auch bei Arrays die gleich gross sind:

```
int [] b = {1,3,9,10,0,12,65};
int [] a = {3,10,1,9,12,4,99};
```
1,3,9,10,12 gehoeren zu a und b.


----------



## tommysenf (17. Aug 2016)

Ich hab den code nur aus dem Gedächtnis im Browser geschrieben und auch gerade nix hier zum Testen. In deinem Beispiel sollte false rauskommen, da die 4 aus dem Prüfarray nicht im Testarray enthalten ist. Er möchte doch wissen ob die Elemente aus dem Prüfarray in dem Testarray enthalten sind und das ist in deinen Beispielen halt nicht der Fall.


----------



## Nuiton (17. Aug 2016)

Hm, das sieht mir schon fast identisch aus. Naja, wie auch immer, die Loesung ist (hoechstwahrscheinlich) nicht in Form von puren Arrays.

Ausserdem kannst du int[] a und int[] b wie auch immer definieren, wenn du folgendes hast:

```
int [] a = {1,3,9,10,0,12,65};
int [] b = {3,10,1,9,12,4,99};
```
1,3,9,10 sind in a und b, ob du nun b oder a pruefst, oder a mit b wechselst, beides ergibt false.


----------



## tommysenf (17. Aug 2016)

Nuiton hat gesagt.:


> Hm, das sieht mir schon fast identisch aus. Naja, wie auch immer, die Loesung ist (hoechstwahrscheinlich) nicht in Form von puren Arrays.


1. Identisch wozu?
2. Ich habe doch eine Lösung aus puren Arrays geposted...


----------



## Nuiton (17. Aug 2016)

Dein Code ist keine Loesung, genauso wenig wie meiner, und genauso wenig wie der fast identische Code von Stackoverflow (wobei du auch nicht Stackoverflow zitiert hast, obwohl das schon Line zu Line wie reinkopiert war).


----------



## tommysenf (17. Aug 2016)

Nuiton hat gesagt.:


> 1,3,9,10 sind in a und b, ob du nun b oder a pruefst, oder a mit b wechselst, beides ergibt false.


Ja aber er will doch wissen ob ein Array in dem anderem Array KOMPLETT enthalten ist. Ich glaube du solltest noch mal den Eingangspost in Ruhe durchlesen.
Des weiteren ist der Code nicht von Stackoverflow, es ist einfach der Standardcode um ein Array zu durchlaufen, den ich sicher schon hunderte male in den letzten 20 Jahren so geschrieben habe. Die einzige Änderung daran ist durch java 5 mit foreach erfolgt. Ich wüsste auch gar nicht wie man es großartig anders schreiben sollte. wenn du mal im Netz danach suchst findest du diesen Codebaustein sicherlich ohne Ende.


----------



## Nuiton (17. Aug 2016)

tommysenf hat gesagt.:


> Ja aber er will doch wissen ob ein Array in dem anderem Array KOMPLETT enthalten ist. Ich glaube du solltest noch mal den Eingangspost in Ruhe durchlesen.


Ich hoffe, dann kann man ruhig dein Beispiel benutzen. Ansonsten ist das der letzte Albtraum.


----------



## Nuiton (17. Aug 2016)

Falls der TE sich dann (doch vielleicht) dafuer interessiert, ob es (ein, ein paar, oder nur ein Teil) eines Arrays in einem anderem Array zu finden ist, koennte man sich folgendes anschauen:

```
import java.util.ArrayList;
import java.util.Collections;

public class Test
{
    public boolean hasCommonElements(int a[], int b[])
    {
        ArrayList<Integer> s1 = new ArrayList<>();
        ArrayList<Integer> s2 = new ArrayList<>();
    
        for (int i = 0; i < a.length; i++)
            s1.add(a[i]);
        for (int j = 0; j < b.length; j++)
            s2.add(b[j]);
    
        boolean hasCommon = Collections.disjoint(s1, s2);
        return !hasCommon;
    }

    public static void main(String args[])
    {
        Test t = new Test();

        // Test 1
        int[] x = {1,2,3,4,5,6};
        int[] y = {54,99,29,4};
        // 4 in 'x' und 4 in 'y'
    
        if (t.hasCommonElements(x, y))
            System.out.println("Test 1: Elemente enthalten.");
        else
            System.out.println("Test 1: Keine Elemente enthalten.");
    
        // Test 2
       x = new int[] {102,95,483,54,12,5,65,74,37};
       y = new int[] {1,59,66,8,4,3,2,1,0};
       // nichts aehnlich
    
        if (t.hasCommonElements(x, y))
            System.out.println("Test 2: Elemente enthalten.");
        else
            System.out.println("Test 2: Keine Elemente enthalten.");
    
    
        // Test 3
       x = new int[] {1,2,3,4,5,6};
       y = new int[] {1,2,3,4,5};
       // 1,2,3,4,5 in 'x' und 1,2,3,4,5 in 'y'
    
        if (t.hasCommonElements(x, y))
            System.out.println("Test 3: Elemente enthalten.");
        else
            System.out.println("Test 3: Keine Elemente enthalten.");
    
        // Test 4
       x = new int[] {65,48,332,12};
       y = new int[] {48,493,55,49,12};
       // 12,48 in 'x' und 12,48 in 'y'
    
        if (t.hasCommonElements(x, y))
            System.out.println("Test 4: Elemente enthalten.");
        else
            System.out.println("Test 4: Keine Elemente enthalten.");

        // Test 5
       x = new int[] {0,12,4,66,9};
       y = new int[] {9,2,3,5,6,6};
       // 9 in 'x' und 9 in 'y'
      
        if (t.hasCommonElements(x, y))
            System.out.println("Test 5: Elemente enthalten.");
        else
            System.out.println("Test 5: Keine Elemente enthalten.");
    }
}
```
Output:

```
Test 1: Elemente enthalten.
Test 2: Keine Elemente enthalten.
Test 3: Elemente enthalten.
Test 4: Elemente enthalten.
Test 5: Elemente enthalten.
```
Gerne austesten und nach Fehlern suchen?


----------



## tommysenf (17. Aug 2016)

Der Code sieht gut aus. Aber nur so am Rande, das geht natürlich auch mit puren Arrays:


```
public static boolean hasCommenElements(int[] a, int[] b) {
        for(int i :b) {
           if(contains(a, i)) {
               return true;
            }
        }
        for(int i :a) {
           if(contains(b, i)) {
               return true;
            }
        }
        return false;
    }
```


----------



## Nuiton (17. Aug 2016)

Der Unterschied ist ja, dass wenn Array 1 (nur teilweise) in Array 2 ist, diese pure Array Methode auch nicht funktioniert, weshalb ich das mit ArrayLists umgesetzt habe. Die Logik basiert auf Mengenlehre.


----------



## javaRekrut (17. Aug 2016)

offtopic frage: Wie stell ich den ein, dass sich bei mir ein Code-Fenster öffnet, damit ich den Java Code reinschreiben kann wie bei euch


----------



## Joose (17. Aug 2016)

Entweder über das Dropdownmenü "Einfügen" im Editor oder du schreibst einfach Code-Tags
[code=java] ... dein code ...[/code]


----------



## javaRekrut (17. Aug 2016)

Ok danke 
Habe eine Lösung für mich gefunden. Weiss nicht ob es die schönste Variante ist, jedenfalls kontrolliert er ob liste1 Elemente besitzt welche liste2 auch hat, unabhängig von der Reihenfolge (Ja hat was mit Mengenlehre zu tun, war mir aber sicher das es mit normalen Arrays auch geht):


```
public class ArrayVergleich {
    public static void main(String[] args) {
        int[] liste1 = {1,2,3,4,5};
        int[] liste2 = {1,5};
        int a = 0;
     
        for (int i = 0; i < liste1.length; i++) {
            for (int j = 0; j < liste2.length; j++) {
                if (liste1[i] == liste2[j]) {
                    a ++;
                }
            }
        }

        if (a == liste2.length) {
            System.out.println("Alle Elemente aus 'liste2' sind in 'liste 1' enthalten.");
        } else {
            System.out.println("NICHT alle bzw. kein Elemente aus 'liste2' ist/sind in 'liste 1' enthalten.");
        }
    }
}
```


----------



## Joose (17. Aug 2016)

Kleiner Hinweis: Wenn ich "liste1" eine Zahl (zum Beispiel: 2) öfters vorkommen würde der Code vielleicht nicht mehr wie gewünscht funktionieren


----------



## javaRekrut (17. Aug 2016)

Da hast du recht ^^


----------



## tommysenf (17. Aug 2016)

Nuiton hat gesagt.:


> Der Unterschied ist ja, dass wenn Array 1 (nur teilweise) in Array 2 ist, diese pure Array Methode auch nicht funktioniert



In welchem Beispiel sollte das denn nicht funktionieren?


```
public class Test
{
    public boolean hasCommonElements(int[] a, int[] b) {
        for(int i :b) {
           if(contains(a, i)) {
               return true;
            }
        }
        for(int i :a) {
           if(contains(b, i)) {
               return true;
            }
        }
        return false;
    }
     public boolean contains(int[] data, int test) {
        for(int i : data) {
           if(i == test) {
               return true;
            }
        }
        return false;
    }

    public static void main(String args[])
    {
        Test t = new Test();

        // Test 1
        int[] x = {1,2,3,4,5,6};
        int[] y = {54,99,29,4};
        // 4 in 'x' und 4 in 'y'
   
        if (t.hasCommonElements(x, y))
            System.out.println("Test 1: Elemente enthalten.");
        else
            System.out.println("Test 1: Keine Elemente enthalten.");
   
        // Test 2
       x = new int[] {102,95,483,54,12,5,65,74,37};
       y = new int[] {1,59,66,8,4,3,2,1,0};
       // nichts aehnlich
   
        if (t.hasCommonElements(x, y))
            System.out.println("Test 2: Elemente enthalten.");
        else
            System.out.println("Test 2: Keine Elemente enthalten.");
   
   
        // Test 3
       x = new int[] {1,2,3,4,5,6};
       y = new int[] {1,2,3,4,5};
       // 1,2,3,4,5 in 'x' und 1,2,3,4,5 in 'y'
   
        if (t.hasCommonElements(x, y))
            System.out.println("Test 3: Elemente enthalten.");
        else
            System.out.println("Test 3: Keine Elemente enthalten.");
   
        // Test 4
       x = new int[] {65,48,332,12};
       y = new int[] {48,493,55,49,12};
       // 12,48 in 'x' und 12,48 in 'y'
   
        if (t.hasCommonElements(x, y))
            System.out.println("Test 4: Elemente enthalten.");
        else
            System.out.println("Test 4: Keine Elemente enthalten.");

        // Test 5
       x = new int[] {0,12,4,66,9};
       y = new int[] {9,2,3,5,6,6};
       // 9 in 'x' und 9 in 'y'
     
        if (t.hasCommonElements(x, y))
            System.out.println("Test 5: Elemente enthalten.");
        else
            System.out.println("Test 5: Keine Elemente enthalten.");
    }
}
```


----------



## javaRekrut (17. Aug 2016)

also für mein Projekt kommt in einem Array nur 1 mal das Element vor, weshalb es erstmal kein Problem darstellt. Hab auch schon des öfteren was von Hash-Codes gelesen die ja irgendwie auch wirklich nur 1 Element des gleichen Wert erlauben. Werde ich mich noch damit auseinander setzen.

Edit: An sich habe ich erstmal eine Lösung, die von mir zuletzt gepostete, für mich gefunden. Danke Leute für eure Hilfe


----------



## tommysenf (17. Aug 2016)

Du kannst es auch ganz einfach so machen:


```
public class ArrayVergleich {
    public static void main(String[] args) {
        int[] liste1 = {1,2,3,4,5};
        int[] liste2 = {1,5};

        if (Arrays.asList(liste1).containsAll(Arrays.asList(liste2))) {
            System.out.println("Alle Elemente aus 'liste2' sind in 'liste 1' enthalten.");
        } else {
            System.out.println("NICHT alle bzw. kein Elemente aus 'liste2' ist/sind in 'liste 1' enthalten.");
        }
    }
}
```


----------



## javaRekrut (17. Aug 2016)

wenn ich deins runne, kommt "NICHT alle..." ,


----------



## JCODA (17. Aug 2016)

Ja, das hat damit zu tun, dass "int" primitiver Typ ist und es "Probleme" bei den Generics gibt. 
So gehts:

```
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Integer[] liste1 = {1,2,3,4,5};
        Integer[] liste2 = {1,5};
        if (Arrays.asList(liste1).containsAll(Arrays.asList(liste2))) {
            System.out.println("Alle Elemente aus 'liste2' sind in 'liste 1' enthalten.");
        } else {
            System.out.println("NICHT alle bzw. kein Elemente aus 'liste2' ist/sind in 'liste 1' enthalten.");
        }
    }
}
```

https://repl.it/CoAA/0


----------



## Xyz1 (17. Aug 2016)

Je nach Definition, ob die Arrays sortiert ist, ob doppelte Elems. vorkommen oder was in den Arrays befindlich ist, sprechen wir hier von unterschiedlichen asymptotischen Laufzeiten des optimal-effizienten Algorithmusses.


----------



## Nuiton (17. Aug 2016)

Das funktioniert nur mit String-Arrays (warum auch immer). Am besten entscheidest du dich einfach, was du benutzen moechtest. 

ArrayLists (Logik basiert auf Mengenlehre, findet alle Subsets von Array 1 in Array 2 und vice versa).

```
import java.util.ArrayList;
import java.util.Collections;

public class Test 
{
    public boolean hasCommonElements(int a[], int b[])
    {
        ArrayList<Integer> s1 = new ArrayList<>();
        ArrayList<Integer> s2 = new ArrayList<>();
       
        for (int i = 0; i < a.length; i++)
            s1.add(a[i]);
        for (int j = 0; j < b.length; j++)
            s2.add(b[j]);
       
        boolean hasCommon = Collections.disjoint(s1, s2); 
        return !hasCommon;
    }

    public static void main(String args[])
    {
        Test t = new Test();
        int[] x = {1,2,3,4,5};
        int[] y = {1,2,3};
       
        // ArrayLists  
        if (t.hasCommonElements(x, y))
            System.out.println("Elemente enthalten.");
        else
            System.out.println("Keine Elemente enthalten."); 
    }  
}
```
Geht mit Strings sowohl auch mit Integers, oder was auch immer du benutzen moechtest.


----------



## tommysenf (17. Aug 2016)

Ja hab ich auch gerade ausgetestet. Arrays#asList  erzeugt ein List<int[]> statt einem List<Integer>. Wirklich dummer Fehler.


----------



## Nuiton (17. Aug 2016)

Die Methode scheitert jedoch auch, einzelne Subsets eines Arrays in einem anderem Array zu finden (wenn NICHT ein ganzer Array in einem anderen zu finden ist). Naja, egal, was auch immer man halt vorhat.


----------



## Xyz1 (17. Aug 2016)

#containsAll ist Best current practice, btw.


----------



## javaRekrut (17. Aug 2016)

*JCODA's* Version ist in meinen Augen für mein aktuelles Problem wahrscheinlich die Attraktivste.


----------



## Flown (17. Aug 2016)

Es sind jetzt schon alle Lösungen gepostet, bis auf die Java 8 Lösung, damit es noch etwas spannender wird:

```
public class Test {
  public static void main(String... args) {
    int[] x = { 1, 2, 3, 4, 5 };
    int[] y = { 1, 2, 3 };
    if (Arrays.stream(y).allMatch(i -> Arrays.stream(x).anyMatch(j -> i == j))) {
      System.out.println("Elemente enthalten.");
    } else {
      System.out.println("Elemente nicht enthalten.");
    }
  }
}
```

Oder natürlich auch noch mit sortiertem Daten-Array:

```
import java.util.Arrays;

public class Test {
  public static void main(String... args) {
    int[] x = { 1, 2, 3, 4, 5 };
    Arrays.sort(x);
    int[] y = { 1, 2, 3 };
    if (Arrays.stream(y).allMatch(i -> Arrays.binarySearch(x, i) >= 0)) {
      System.out.println("Elemente enthalten.");
    } else {
      System.out.println("Elemente nicht enthalten.");
    }
  }
}
```


----------



## javaRekrut (17. Aug 2016)

Der Administrator hat gewonnen


----------



## Flown (17. Aug 2016)

Man sollte jetzt auch sagen, dass man die Lösungen auch verstehen sollte. Denn die Lösung für Anfänger wäre mMn:

```
import java.util.Arrays;

public class Test {
  public static void main(String... args) {
    int[] x = { 1, 2, 3, 4, 5 };
    int[] y = { 1, 2, 3 };
    if (containsAll(x, y)) {
      System.out.println("Elemente enthalten.");
    } else {
      System.out.println("Elemente nicht enthalten.");
    }
  }
  
  private static boolean containsAll(int[] data, int[] candidates) {
    Arrays.sort(data);
    for (int candidate : candidates) {
      if (Arrays.binarySearch(data, candidate) < 0) {
        return false;
      }
    }
    return true;
  }
}
```


----------



## javaRekrut (17. Aug 2016)

Ich find es verständlich. Ich muss mich noch reinfummeln, bin aber sehr zuversichtlich, da hier viele Anregungen gegeben wurden und gewisse Begriffe mir neu sind, die ich nach recherchieren darf. Java macht Laune .


----------

