2 Arrays vergleichen (Unterschiedliche Längen)

[javaRekrut]

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]

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]

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]

Ich habe meine Antwort nochmal aktualisiert.

 

[javaRekrut]

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

 

[Nuiton]

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]

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]

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]

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]

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

 

[tommysenf]

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]

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]

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.

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

Das glaube ich nicht.

 

[Nuiton]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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

 

[javaRekrut]

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]

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

 

[javaRekrut]

Da hast du recht ^^

 

[tommysenf]

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]

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]

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]

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

 

[JCODA]

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]

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]

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]

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

 

[Nuiton]

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]

#containsAll ist Best current practice, btw.

 

[javaRekrut]

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

 

[Flown]

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]

Der Administrator hat gewonnen

 

[Flown]

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]

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 .