Arrays vergleichen

[DuffCola]

Was ist der beste Algorithmus, wenn ich 2 String Arrays habe,
im 1. steht "aaa", "bbb", "ccc",
im 2. steht "fff", "ccc", "hhh", "aaa", "bbb",
ich will jetzt eine Methode haben, die true zurückgibt wenn das 2. Array die Elemente vom 1. Array beinhaltet, egal welche Rhein folge und das 2. Array kann noch zusätzlich irgendwelche anderen Elemente beinhalten.
Das beispiel oben sollte true zurückgeben.
Wenn ich das verscuhe, habe ich einen föllig unübersichtlichen und Fehleranfälligen Block mit Code.
Gibts da nicht schon eine Hilfsklasse?

 

[stg]

Dann zeig doch mal deinen Block. Du musst doch nur für jedes Element des ersten Arrays alle Elemente des zweiten Arrays einmal anschauen, und prüfen, ob du es dort irgendwo findest.
Im wesentlichen sind das einfach zwei ineinander geschachtelte Schleifen.

 

[Ruzmanz]

Es gibt keinen "besten" Algorithmus für solche Probleme. Es hängt immer von den Daten ab und ob die Lösung schnell oder Speichereffizient sein sollte.

Wenn die Anzahl der zu vergleichenden Wörter egal ist, dann lohnt sich ein HashSet. Bsp:

arr1: "aaa", "aaa"
arr2: "aaa", "bbb"

Dabei packst du alle Daten von arr2 in ein HashSet und gehst in einer Schleife dein erstes Array durch und prüfst dann, ob die Daten im HashSet drinnen sind.

Wenn die Anzahl der vergleichenden Wörter nicht egal ist, dann lohnt sich eine HashMap. Dabei ist dein Schlüssel das Wort und dein Value die Häufigkeit.

Bei einer kleinen Datenmenge lohnt es sich nicht. Ich habe die beiden Algorithmen schnell runtergetippt:

Spoiler: Quellcode

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class Sample {
	
	public static void main(String[] args) {
		System.out.println("Doppelte prüfen:");
	    System.out.println(check1(new String[] {"AAA", "AAA", "BBB"}, new String[] {"AAA", "BBB", "CCC"}));
	    System.out.println(check1(new String[] {"AAA", "AAA", "BBB"}, new String[] {"AAA", "AAA", "BBB", "CCC"}));
	    System.out.println(check1(new String[] {"AA2"}, new String[] {"AA3"}));

	    System.out.println("\nDoppelte nicht prüfen:");
	    System.out.println(check2(new String[] {"AAA", "AAA", "BBB"}, new String[] {"AAA", "BBB", "CCC"}));
	    System.out.println(check2(new String[] {"AAA", "AAA", "BBB"}, new String[] {"AAA", "AAA", "BBB", "CCC"}));
	    System.out.println(check2(new String[] {"AA2"}, new String[] {"AA3"}));
	}
	
	public static boolean check1(String[] arr1, String[] arr2) {
		boolean retval = true;
		Map<String, Integer> hashMap = new HashMap<>();
		Integer i;
		
		for(String s: arr2) {
			i = hashMap.get(s);
			
			if(i == null) {
				hashMap.put(s, 1);
			} else {
				hashMap.put(s, ++i);
			}
		}
		
		for(String s: arr1) {
			i = hashMap.get(s);
			if(i != null && i > 0) {
				hashMap.put(s, --i);
			} else {
				retval = false;
				break;
			}
		}
		
		return retval;
	}
	
	public static boolean check2(String[] arr1, String[] arr2) {
		boolean retval = true;
		
		Set<String> hasSet = new HashSet<>();
		
		for(String s: arr2) {
			hasSet.add(s);
		}
		
		for(String s: arr1) {
			if(!hasSet.contains(s)) {
				retval = false;
                                break;
			}
		}
		
		return retval;
	}
  }

 

[eRaaaa]

Wenn die Arrays wirklich nur so klein sind und man keine wirklichen Performanceprobleme o.ä. hat, reicht evtl. auch ein Einzeiler (je nachdem wie nun doppelte behandelt werden sollen):

System.out.println(Arrays.asList(arr2).containsAll(Arrays.asList(arr1)));

(oder eben direkt Listen verwenden )

@Ruzmanz: Du kannst übrigens auch einfach ein return false; zurückgeben in deinen Methoden, das erspart dir im ersten Fall das eklige break und in deiner zweiten Methoden das unnötige weiteriterieren

 

[Ruzmanz]

@Ruzmanz: Du kannst übrigens auch einfach ein return false; zurückgeben in deinen Methoden, das erspart dir im ersten Fall das eklige break und in deiner zweiten Methoden das unnötige weiteriterieren

Break ist jetzt ergänzt. Hatte zuerst überlegt, aber mich dann spontan dagegen entschieden. Mehrere returns sind mMn genau so Code Smell wie breaks. Da ich jetzt nicht unbedingt meine Zeit damit verbringen wollte nach eine dritten Lösung zu suchen, habe ich das so gelassen

PS: Ausnahmen bestätigen die Regel. Sofern z.B. die Methode nicht mehr geändert wird und die Lesbarkeit gegen ist, würde ich das auch machen. Gegen containsAll ist z.B. nichts auszusetzen:

    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

Ich gehe aber davon aus, dass der TE noch ein paar Kriterien in die Methoden reinpackt ...