Verundung dynamisch gestalten

Bitte aktiviere JavaScript!
Hallo,

ich überlege derzeit, wie man verhältnismäßig dynamisch eine Verundung in Java implementieren kann. Ich will einmal weiter ausholen was ich meine:
Eine einfache Verundung wäre beispielsweise sowas A && B, hier hätte man dann zwei Parameter, Namentlich A und B. Jetzt gibt es eine größere Verundung nennen wir sie A && B && C. Ich würde diese Verundung gerne etwas dynamischer gestalten, etwa in dieser Form: Anzahl Parameter = 4, dann wäre die Verundung folgende A && B && C && D, wobei ich mir das Resultat der Verundung dann gerne speichern möchte.

Jetzt habe ich selber mal etwas überlegt und mir mehrere Methoden geschrieben. Mit einer Überladung der Parameter wähle ich dann die richtige Methode aus. Das ist vllt. eine Lösung wenn man recht statisch arbeiten möchte, aber angenommen, ich möchte das etwas flexibler gestalten, was wären dann mögliche Ansätze? Achso ganz wichtig an dieser Stelle ist zu nennen, dass die Variablen A bis D (im Beispiel) boolesche Ausdrücke sind!

Vielleicht hat hier Jemand einen guten Ratschlag für mich, ich würde mich sehr freuen :)
 
Java:
boolean and(boolean ... values) {
    for (boolean value : values) {
        if (!value) { return false; }
    }
    return true;
}
Ja sowas ist gut! Aber jetzt lege ich mal eine Schippe drauf, angenommen die && wären ||, dann ginge das beispielsweise nicht, wie würdest du dort verfahren? Nach einem unwahren Wert in der Verundung zu suchen ist gut, aber bei einer Veroderung würde das beispielsweise nicht greifen. Ich bin gespannt :)

@mrBrown ich denke das geht in Richtung dynamisch in der Anzahl der Elemente. ich stelle mir vor, ich gebe einen Parameter an und mit diesem kann ich dann x Literale Verunden oder Verodern. Also parameter = 5, würde dann A && B && bedeuten C && ... && E
 
K

kneitzel

Bei oder drehst du es nur um. Du gehst die Werte durch und bei einem wahren Wert gibst du true zurück. Ist kein wahrer Wert dabei, dann false.
 
Ja sowas ist gut! Aber jetzt lege ich mal eine Schippe drauf, angenommen die && wären ||, dann ginge das beispielsweise nicht, wie würdest du dort verfahren? Nach einem unwahren Wert in der Verundung zu suchen ist gut, aber bei einer Veroderung würde das beispielsweise nicht greifen. Ich bin gespannt :)
z.B. den Operator auch noch mitgeben: (nur am Handy getippt, könnte Fehler enthalten)

Java:
boolean function(BiPredicate<Boolean, Boolean> operator, boolean first, boolean ... rest) {
    boolean result = first;
    for (boolean value : values) {
        first = operator.test(first, value);
    }
    return result;
}
 
So zum Beispiel:

Java:
public boolean dynamicOR(boolean... params){
    boolean tmp = false; //Jaja, ich weiß, tmp ist böse...
 
    for(boolean b : params){
        tmp = tmp || b;
    }
    return tmp;
}
Edit:
Da waren andere schneller :(

Edit 2:
Da hat sich noch ein Fehler im Code eingeschlichen, tmp muß mit tmp = false; initialisiert werden. Sonst kommt immer true raus, auch wenn du nur falses in die Methode gesteckt hast.
 
So zum Beispiel:

Java:
public boolean dynamicOR(boolean... params){
    boolean tmp = true; //Jaja, ich weiß, tmp ist böse...
 
    for(boolean b : params){
        tmp = tmp || b;
    }
    return tmp;
}
Edit:
Da waren andere schneller :(
Find ich gut. Ich würde das gerne noch testen wollen! Mir gefällt die Lösung, weil du auf
BiPredicate verzichtest!

Ich bedanke mich einmal recht herzlich bei euch, das gibt mir wieder die Gelegenheit etwas dazu zu lernen! Die Antworten gefallen mir, falls und wenn Jemand anderes noch etwas dazu betragen will, ist das natürlich auch gerne gesehen. Aber bis hierhin einmal Danke!
 
K

kneitzel

z.B. den Operator auch noch mitgeben: (nur am Handy getippt, könnte Fehler enthalten)

Java:
boolean function(BiPredicate<Boolean, Boolean> operator, boolean first, boolean ... rest) {
    boolean result = first;
    for (boolean value : values) {
        first = operator.test(first, value);
    }
    return result;
}
Das dürfte nicht immer funktionieren, denn das Element first prüfst Du zwei Mal. Das kann z.B. bei xor dann zu einem falschen Ergebnis führen, so der erste Wert true ist.
 
@JavaUndC-Prog
Schön daß wir dir helfen konnten...viel Spaß beim Weitermachen.

Nenn es result oder so, dann ist jeder zufrieden :p (warum sollten temporäre Variablen grundsätzlich böse sein?
Ich hab mal irgendwo gelesen, daß tmp als Variablenname als ungünstig angesehen wird, da es meist recht nichtssagend ist. Aber zumindest in diesem Fall beschreibt tmp - im Sinne von temporär - ja eigentlich exakt die Funktion der Variable: ein Zwischenergebnis. result dagegen...würde ich in diesem Kontext eher als weniger treffend ansehen.
Aber wie so oft, wenn wir uns hier über Coding Styles unterhalten: Es kommt wohl mal wieder auf den Einzelfall an. :)

Den Namen result benutze ich allerdings (fast) immer in Unittests für das, was die Testinstanz zurückgeliefert hat.
assertEquals(result, expResult); liest sich einfach zu gut.
 
Das dürfte nicht immer funktionieren, denn das Element first prüfst Du zwei Mal. Das kann z.B. bei xor dann zu einem falschen Ergebnis führen, so der erste Wert true ist.
Oh, in der vierten Zeile sollte natürlich nur noch result stehen -.-

Java:
boolean function(BiPredicate<Boolean, Boolean> operator, boolean first, boolean ... rest) {
    boolean result = first;
    for (boolean value : values) {
        result = operator.test(result, value);
    }
    return result;
}
 
:)

Java:
	public static double strongness(Boolean... bs) {
		return Stream.of(bs).mapToInt(b -> b ? 1 : 0).average().getAsDouble();
	}

	public static boolean and(Boolean... bs) {
		return strongness(bs) == 1;
	}

	public static boolean or(Boolean... bs) {
		return strongness(bs) != 0;
	}

	public static void main(String[] args) throws Exception {
		System.out.println(and(true, true, false));
		System.out.println(or(false, true, false));
		System.out.println(and(true, true, true));
	}
 
Wtf? "strongness"?! Einfach anyMatch und allMatch nehmen:
Java:
import java.util.stream.Stream;
public class BooleanOperators {
  public static boolean and(Boolean... bs) {
    return Stream.of(bs).allMatch(Boolean.TRUE::equals);
  }
  public static boolean or(Boolean... bs) {
    return Stream.of(bs).anyMatch(Boolean.TRUE::equals);
  }
}
 
Aber das Problem ist der doppelte Code. Du hast das Problem nicht weit genug zerlegt und abstrahiert... imo

Und naja, "strongness" dachte ich mir vorhin aus :D
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben