# Array durchsuchen - aber richtig



## Tonipasta (24. Jul 2009)

Hallo wie finde ich am besten/schnellsten heraus, ob ein Array 2 bestimmte Strings enthält? Ich habe das so gemacht:


```
boolean status = false;

for (int i = 0; a.length; i++) {
   if ( a[i].equals("String1") )
      status = true;

   if ( status && a[i].equals("String2") )
      System.out.println("Beide Strings im Array enthalten")
}
```

Gibt es in JAVA z.B. eine find(String1, String2)-Methode die man auf's Array anwenden kann?


----------



## Schandro (24. Jul 2009)

Deine Methode ist falsch. Bsp:
[0] = "String2";
[1] = "String1";
Deine Methode wird nicht ausgeben, dass beide String vorhanden sind. Liegt dadran das du nur ein einziges mal das Arrray durchgehst und das boolean-Flag nur auf eines der beiden Strings reagiert.

Ansonsten: bitte immer angewöhnen nach if-Abfragen { und } zu setzen, auch wenn danach nur eine Anweisung folgt. Der Code lässt sich dann leichter lesen, es verhindert Tippfehler wenn man beim schreiben des 2. Ausdrucks vergisst die { } nachträglich zu setzen, und es steht so in der Java Language Convention.


----------



## Painii (25. Jul 2009)

```
boolean status = false;

for (int i = 0; a.length; i++) {
   if ( a[i].equals("String1") ){
      status = true;
      i=0;
  }
   if ( status && a[i].equals("String2") )
      System.out.println("Beide Strings im Array enthalten")
}
```

Sollte dann so eigentlich klappen (Wenn String1 gefunden laufe von vorne nochmal durch und suche String2)


----------



## Marco13 (25. Jul 2009)

Probier's mal aus 

Aber selbst wenn man den Fehler beheben würde, würde dadurch der eventuelle Vorteil, der vielleicht der Grund für die ursprüngliche Methode war, zunichte gemacht. Man könnte ja einfach eine Methode machen

```
private static boolean contains(String array[], String string)
{
    for (String s : array)
    {
        if (s.equals(string))
        {
            return true;
        }
    }
    return false;
}
```
und die dann aufrufen mit

```
if (contains(a, "String1") && contains(a, "String2")) { ... }
```

Das wäre einfach, sauber und leicht nachvollziehbar - KANN aber einen "Nachteil" haben: Wenn der Array SEHR groß ist, und die beiden gesuchten Strings zufällig ganz am Ende stehen, dann muss der Array u.U. ZWEI mal fast komplett durchlaufen werden. Und das wäre bei deiner neuen Lösung ja genauso. (Abgesehen davon, dass ich es nicht so schön finde, den Schleifenzähler "i" zu verändern)

Der Array müßte schon SEHR groß sein, damit das eine Rolle spielen könnte, aber falls dem so ist, würde eine KISS-Lösung vielleicht so aussehen:

```
boolean foundA = false;
boolean foundB = false;
for (int i=0; i<a.length; i++)
{
    if (a[i].equals("String1"))
    {
        foundA = true;
    }
    if (a[i].equals("String2"))
    {
        foundB = true;
    }
    if (foundA && foundB)
    {
        System.out.println("Jo, passt...")
        break;
    }
}
```


----------



## Ark (25. Jul 2009)

Mal was ganz anderes: Kann es sein, dass es sich bei deinem Array um eine Menge handelt, also jeder String nur einmal vorkommt?

Ark


----------



## JohannisderKaeufer (25. Jul 2009)

Geht man davon aus, das die gesuchten Strings nicht doppelt vorhanden sind. 
Könnte man eine RegExp verwenden String1|String2.
Pro Fund einen zähler hochzählen und bei der korrekten Anzahl die Schleife abbrechen.


----------



## JohannisderKaeufer (25. Jul 2009)

Marco13 hat gesagt.:


> Probier's mal aus
> 
> 
> ```
> ...



Wie aufwendig ist eine Überprüfung auf equals?
Wenn String1 sehr weit vorne und String2 sehr weit hinten im Array platziert sind, könnte man sich viele Überprüfungen auf a_.equals("String1") sparen._


----------



## Ark (25. Jul 2009)

JohannisderKaeufer hat gesagt.:


> Wie aufwendig ist eine Überprüfung auf equals?


Laufzeittechnisch ist sie höchstwahrscheinlich günstiger als Regex.

Ark


----------

