Da ich seit nunmehr einem Jahr bei meinem neeun Arbeitgeber beschäftigt und damit seit ungefähr derselben Zeit für Geld mit Python arbeite, haben sich gewisse Antipathien gegenüber Python vertieft (ich kann mit typlosen Sprachen einfach nicht umgehen) - aber auch einige meiner Gründe, Python zu lieben sind ebenso stärker geworden. Einer davon ist der Fakt, dass eine Methode in Python mehr als einen Wert zurückgeben kann.

Ich wollte diese Python-Eigenschaft auch mit Java erreichen und sehen, wie sehr man dazu schlechtes Java programmieren muss. Eine Idee (weil die Rückgabe mehrerer Werte aus einer Funktion in Java nun einmal nicht funktioniert) war, zunächst eine Liste von Items zurückzugeben.

Wenn man es jetzt noch schaffen könnte, diese Liste schnell in einzelne Variablen zu vereinzeln, wäre ja eigentlich schoiin so etwas ähnliches geschafft, wie das, was Python hier bietet. Mir schwebte also etwa so etwas hier vor:

List l=someMethod(/*maybe some parameters here*/);
BigInteger a=null;
BigInteger b=null;
unpack(l,a,b);

So etwas funktioniert natürlich zunächst erst einmal nicht weil Call-by-Reference in Java nicht vorgesehen ist. Es existieren auch keine general-purpose-Value-Objects, die man für so etwas einspannen könnte - also habe ich mir solche Wrapper selber hergestellt:

public static class W<E> extends java.lang.Object
{
	E ref;
	public W( E e ){
		super();
		ref = e;
	}
	public synchronized E g() { return ref; }
	public synchronized void s( E e ){ this.ref = e; }

	public String toString() {
		return Objects.toString(ref);
	}

	@Override
	public int hashCode()
	{
		return ref!=null?ref.hashCode():super.hashCode();
	}

	@Override
	public boolean equals(Object obj)
	{
		return ref!=null?ref.equals(obj):super.equals(obj);
	}
}

Damit konnte ich dann so etwas ähnliches wei das angestrebte Python-Vorbild erreichen:

static void unpack(Iterable iterable,W... items)
{
	java.util.Iterator iter=iterable.iterator();
	for(int i=0; i < items.length ; ++i)
	{
		items[i].s(iter.next());
	}
}

Ein Beispiel für die Benutzung sähe dann wie folgt aus:

public static java.util.List method()
{
	return Arrays.asList(java.math.BigInteger.valueOf(5),"huhu");
}
public static void main(java.lang.String[] args)
{
	W<java.math.BigInteger> bi=new W(java.math.BigInteger.valueOf(3));
	System.out.println(bi);
	W<java.lang.String> s=new W(null);
	unpack(method(),bi,s);
	System.out.println(bi+" "+s);
}

Aber bei diesem ganzen Aufwand - vielleicht ist es doch besser, die von Java vorgegebenen Grenzen zu beachten und - wenn es denn wirklich erforderlich ist, mehr als einen Wert zurückzugeben - einfach die Records benutzen - schließlich arbeiten wir alle ja mindestens mit Java in der Version 14?

Leider ist die Einführung der Records in Java wiedermal dermaßen verk... worden, dass ich mich wunder, welcher Halbwüchsige hier eigentlich wieder mal mit dem Startknopf der Atomraketen gespielt hat? Java ist synonym mit JavaBeans - Records erzeugen zwar automatisch "Getter" - nur leider halten sie sich nicht an die Namenskonventionen von JavaBeans - ein Getter für ein Element eines Records namens name heißt nicht getName() sondern lediglich name() - und damit funktioniert XMLEncoder nicht - nicht einmal, wenn man mittels @ConstructorProperties helfen möchte.

Möchte man Records mit Bordmitteln nach XML serialisieren, muss nan diese Abnormität zusammencoden - und dafür kann ich dann auch gleich bei JavaBeans bleiben...

public record XMLRecord (String name, String address) {
    @ConstructorProperties({"name", "address"})
    public XMLRecord {}
    public java.lang.String getName()
    {
        return name();
    }
    public java.lang.String getAddress()
    {
        return address();
    }
}