# if- Abfrage



## MQue (16. Jan 2008)

Hi,

ich möchte eine Abfrage machen wo ich eine lange Wurst dafür brauchen würde, also:



```
if (text == "dies" || text == "das" || text == "jenes" || text == "wasanderes" usw.........
```

Wie kann man das anders machen, Ich weiß was daherkommen kann, kann ich das ganze in ein Array geben und dann irgendwie abfragen


```
if (arr.contains("dies")
{
}
else
```
Wie kann ich das am Besten machen?


----------



## ARadauer (16. Jan 2008)

arraylist würd ich nehmen

zb

```
ArrayList<String> arr = new ArrayList<String>();
		arr.add("bier");
		arr.add("schnaps");
		if(arr.contains("bier"))
			System.out.println("yeah bier");
		if(arr.contains("wein"))
			System.out.println("yeah wein");
```


----------



## The_S (16. Jan 2008)

Außerdem vergleicht man Strings (wie auch Objekte allgemein) mit == und nicht mit equals.


----------



## ms (16. Jan 2008)

Guten Morgen Hobbit  :lol:  :lol: 



			
				Hobbit_Im_Blutrausch hat gesagt.:
			
		

> Außerdem vergleicht man Strings (wie auch Objekte allgemein) mit == und nicht mit equals.


Umgekehrt natürlich.

ms


----------



## The_S (16. Jan 2008)

lol ... ja genau ... des war der Morgen :x


----------



## MQue (16. Jan 2008)

kann ich die ArrayList auch irgendwie gleich initialisieren:

z.B.:


```
ArrayList<String> descr = new ArrayList<String>() {"bier", "schnaps","wein"};
```

So wie oben gehts nicht aber ist es irgendwie möglich mit einem enum oder so?


----------



## ARadauer (16. Jan 2008)

ja equals statt == verwenden.
== ist das gleiche objekt
equals schaun nur gleich aus

ist ein häufiger fehler, wenn wenn man beim Testen, für manuelle Eingaben, Strings verwendet
 zb sowas:


```
String xx ="XXX";
if(xx=="XXX")
	System.out.println("geht");
```
funktioniert, da Java das XXX cached und beides mal, das selbe Objekt verwendet.

wenn man jedoch bei sowas XXX eingibt:

```
String xx ="XXX";
		if(xx=="XXX"){
			System.out.println("geht");
		}else{
			System.out.println("geht nicht");
		}
		BufferedReader bin = new BufferedReader(new InputStreamReader(System.in));
		 String name = bin.readLine();

		if(xx==name){
			System.out.println("geht");
		}else{
			System.out.println("geht nicht");
		}
```
klappt es nicht, da meine Eingabe nich zum selben Objekt wird. also equals verwenden


----------



## MQue (16. Jan 2008)

Kann mans gleich initialisieren??


----------



## The_S (16. Jan 2008)

nein


----------



## ARadauer (16. Jan 2008)

was initialisieren?
was nein?


----------



## The_S (16. Jan 2008)

nein, man kann nicht so initialisieren, wie er es gerne hätte.


----------



## lhein (16. Jan 2008)

Glaub ARadauer braucht auch erstmal nen Kaffee


----------



## ARadauer (16. Jan 2008)

asso! hab den Beitrag von 9:08  übersehen.
ok ich geb mir einen kaffee aus ;-)


----------



## Guest (16. Jan 2008)

Michael1234 hat gesagt.:
			
		

> kann ich die ArrayList auch irgendwie gleich initialisieren:


Klar:


```
import java.util.Arrays;
import java.util.List;
// ...
List<String> alkoholika = Arrays.asList("bier", "schnaps", "wein");
```


Fred


----------



## The_S (16. Jan 2008)

@Fred

Naja, dann haste aber ne List und keine ArrayList. Für ne ArrayList sind auch wieder mehrere Schritte notwendig


```
List<String> list = Arrays.asList(new String[] {"asdf", "aksld"});
ArrayList<String> al = new ArrayList<String>();
al.addAll(list);
```


----------



## lhein (16. Jan 2008)

oder die hardcore Variante:


```
public static enum Key
    {
        DIES("dies"),
        DAS("das"),
        JENES("jenes"),
        UNKNOWN("unbekannt");
        
        private String key;
        
        private Key(String key)
        {
            this.key = key;
        }
        
        /* (non-Javadoc)
         * @see java.lang.Enum#toString()
         */
        @Override
        public String toString()
        {
            return this.key;
        }
        
        public static Key getKeyForString(String key)
        {
            Key k = null;
            
            if (DIES.key.equals(key)) k = DIES;
            else if (DAS.key.equals(key)) k = DAS;
            else if (JENES.key.equals(key)) k = JENES;
            else k = UNKNOWN;
            
            return k;
        }
    }
    
    public static void main(String[] args)
    {
        String test = "nix";
        Key key = Key.getKeyForString(test);
        
        switch(key)
        {
        case DAS:   System.out.println("Es ist DAS...");
                    break;
        case DIES:  System.out.println("Es ist DIES...");
                    break;
        case JENES: System.out.println("Es ist JENES...");
                    break;
        default:    System.out.println("Es ist nichts von allem...");
        }
    }
```

 :bahnhof:  :autsch:  :lol:


----------



## Guest (16. Jan 2008)

Na, wenns unbedingt eine ArrayList sein muss (wobei ich nicht sehe, warum das nötig sein sollte):


```
ArrayList<String> alkoholika = new ArrayList<String>(Arrays.asList("bier", "schnaps", "wein"));
```


Fred


----------



## The_S (16. Jan 2008)

ok ok, ich geb mich geschlagen  . Schön ist es trotzdem nicht


----------



## Guest (16. Jan 2008)

Man kann auch bei den Arrays bleiben:


```
String[] alkoholika = {"bier", "schnaps", "wein"};

boolean c = Arrays.binarySearch(alkoholika, "cola") >= 0;
boolean w = Arrays.binarySearch(alkoholika, "wein") >= 0;

System.out.println("Cola: " + c);
System.out.println("Wein: " + w);
```

Da ist es bloß wichtig, dass das Array aufsteigend sortiert ist! Notfalls einmalig mit Arrays.sort sortieren.


----------



## ms (16. Jan 2008)

```
List<String> list = Arrays.asList(new String[] {"asdf", "aksld"});
ArrayList<String> al = new ArrayList<String>();
al.addAll(list);
```
Die Methode Arrays.asList(...) liefert zwar eine ArrayList, dass ist aber keine java.util.ArrayList sondern eine java.util.Arrays.ArrayList.

ms


----------



## quippy (16. Jan 2008)

Äh, ist es nicht völlig egal, ob das nun eine ArrayList oder eine PopelList ist, hauptsache, es implementiert "List" ?!

Also ehrlich, mir wäre das persönlich ja sowas von wurscht - "contains" gibt es, iterieren kann man's ... So What?


----------



## The_S (16. Jan 2008)

Was weiß ich, musst du den Threadsteller fragen


----------



## ms (16. Jan 2008)

quippy hat gesagt.:
			
		

> Äh, ist es nicht völlig egal, ob das nun eine ArrayList oder eine PopelList ist, hauptsache, es implementiert "List" ?!
> 
> Also ehrlich, mir wäre das persönlich ja sowas von wurscht - "contains" gibt es, iterieren kann man's ... So What?


Probier mal dass hier:

```
List<String> popelList = Arrays.asList(new String[] {"asdf", "aksld"});
		popelList.add("geht oder geht nicht?");
```

In diesem Fall wirft die add-Methode eine UnsupportedOperationException.

ms


----------



## quippy (16. Jan 2008)

OK, da wird das Interface nicht komplett implementiert, weil das Array hier Konstant sein soll... Der Sinn hinter Interfaces ist das aber nicht! 

Aber für die Aufgabe des Threadstarters (der brauchte das ja wohl konstant, wenn ich das richtig verstanden hatte) wäre es trotzdem egal gewesen.

Auf jeden Fall widerstreben mir solche Konstrukte:

```
private static final ArrayList<String> alkoholika = new ArrayList<String>(Arrays.asList(new String[] {"asdf", "aksld"}));
```

bei denen mehrere Objekte für die Müllhalde erzeugt werden, nur um eine ArrayList aus Konstanten zu bekommen. Da würde ich mir doch überlegen, das per Hand im Konstruktor der Klasse selbst zu formulieren (außer natürlich, der Wert muß bereits *vor* dem super(); im konstruktor gesetzt sein) - wobei ich immer noch glaube, daß bei der obigen Formulierung keiner ein "add" brauchen wird, denn das widerspricht der Intention.


----------



## Guest (16. Jan 2008)

quippy hat gesagt.:
			
		

> Auf jeden Fall widerstreben mir solche Konstrukte [...] bei denen mehrere Objekte für die Müllhalde erzeugt werden


Warum? "Short-living-objects" sind doch die Lieblingsspeise des generational garbage collectors.



			
				quippy hat gesagt.:
			
		

> Da würde ich mir doch überlegen, das per Hand im Konstruktor der Klasse selbst zu formulieren (außer natürlich, der Wert muß bereits *vor* dem super(); im konstruktor gesetzt sein)


Wieso im Konstruktor? Mach das doch im class initializer. Und wenn wir schon dabei sind, können wir auch gleich auf ein HashSet umsteigen, weil Suche im HashSet sehr viel schneller ist (O(1)) als Suche in einem sortierten (O(log n)) oder gar einem unsortierten Array (O(n)).



```
import java.util.HashSet;
import java.util.Set;

class Foo
{
	private static final Set<String> alkoholika;
	
	static
	{
		alkoholika = new HashSet<String>();
		alkoholika.add("bier");
		alkoholika.add("schnaps");
		alkoholika.add("wein");
	}

	// ...
	
	public void bar(String s)
	{
		if (alkoholika.contains(s))
		{
			// ...
		}
		else
		{
			// ...
		}
	}
}
```


Fred


----------



## Leroy42 (16. Jan 2008)

Anonymous hat gesagt.:
			
		

> Warum? "Short-living-objects" sind doch die _Lieblingsspeise_ des ... garbage collectors.



LOL

Nun überfüttert doch den armen garbage collector nicht!  :noe:


----------



## quippy (17. Jan 2008)

Anonymous hat gesagt.:
			
		

> quippy hat gesagt.:
> 
> 
> 
> ...



Das meinte ich, als ich das mit dem "*vor* super()" sagte - hatte nur keine Lust, das jetzt auszuformulieren - der Kern der Aussage war, den Kram eben auszuformulieren - egal wo!

Das mit dem HashSet ist natürlich auch richtig. Ich denke da immer nicht dran, weil ich bei einer Hashtable und Verwandtschaft immer an eine Zuordnung [key, Value] denke...  :autsch:


----------

