Tuple assignment in Java

Question

Unlike Python, Java doesn't natively support tuples. Therefore, is doesn't provide such a useful possibility as tuple assignment.

How would you implement it? Your solution should:

1. Be as universal as possible.
2. Be as readable as possible.
3. Contain no temporary variables at the place of assignment.
4. Utility methods are allowed, but only static ones. No Tuple classes should be created or imported. No arrays or collections should be used.

I'll give a simple example. Don't pay much attention to contents of the *Func() methods. They may be inlined or depend on less variables or on other variables additionally.

public class TupleAssignment {
    static String sFunc(String s, int i, double d) {
        return i + s + d;
    }

    static int iFunc(String s, int i, double d) {
        return i + s.length() - (int) d;
    }

    static double dFunc(String s, int i, double d) {
        return (double) i / s.length() + d;
    }

    public static void main(String[] args) {
        String s = "ABCDE";
        int i = 2;
        double d = 0.6;

        String s1 = sFunc(s, i, d);
        int i1 = iFunc(s, i, d);
        double d1 = dFunc(s, i, d);
        s = s1;
        i = i1;
        d = d1;

        System.out.println(s + ", " + i + ", " + d);
    }
}

This produces the right result:

2ABCDE0.6, 7, 1.0

but requires additional variables s1, i1, d1. If you try to get rid of them this way:

s = sFunc(s, i, d);
i = iFunc(s, i, d);
d = dFunc(s, i, d);

you'll get the wrong result:

2ABCDE0.6, 11, 1.8222222222222224

How to get previous result complying with the above four requirements? If you see a nice partial solution, add it as an answer too.

Note that this question is not about making Tuples. You don't need to implement tuple return values. You don't even need to know what a tuple is. It is about multiple-assignment (call this simultaneous assignment or vector-assignment, if you prefer).

Answer 1

I wouldn't. They are a terrible idea. Just make yourself a tiny second class inside the same class as the method that wants to return the value.

public Class ReturnValue{public int age; public String name;}

or if you are paranoid

public Class ReturnValue{
    public final int age; 
    public final String name;
    public ReturnValue(int pAge, String pName){age=pAGe;name=pName;}
}

but if it's REALLY just replacing a tuple, that's a bit verbose

Chances are that once you have created this little class you may find it useful and end up adding methods to it, making the public variables private (or final with a good constructor) and moving it into it's own file--before you know it it's a full-fledged working class that you were missing all along and wouldn't have even KNOWN you were missing if java supplied tuples.

Normally I'd have an issue with mutable public variables, but IF the class is simply being used as a tuple then it's fine, the values will be immediately extracted. If it's not then you have recognized the utility of the class and should refactor it to be a real class.

In your example you are definitely missing a class. I'd suggest:

class Func(String s, int i, double d) {
    final String s;
    final int i;
    final double d;

    public String sFunc() {
        return i + s + d;
    }
    public int iFunc() {
        return i + s.length() - (int) d;
    }

    public double dFunc() {
        return (double) i / s.length() + d;
    }
}

public class TupleAssignment {
    public static void main(String[] args) {
    private func=new Func("ABCDE", 2, 0.6);

    String s = sFunc();
    int i = iFunc();
    double d = dFunc();

    System.out.println(s + ", " + i + ", " + d);
}

The point is that when you want to interact with a group of variables they are likely related and if you put them into a class you will probably end up leaving them there and expanding that class with additional functionality.

If you have a crutch you might not create the new class you need and might try to do everything in one class