Returning a result with several values the Java way

Question

I am used to developing in Python, but for work reasons have to do it in Java. I am facing a task that would be trivial in Python, and I'd like some advice on how to handle this in Java the proper way.

I need to parse a duration string. It can be in milliseconds (235ms) or seconds (32s). And it can also be "< 1ms" as a special case.

The parsing happens at least three times in the code so I'd like to separate it into a method. But my code does need to know, not just the resulting value in ms, but also whether it was in ms or s and whether it was <1ms (0 is a different value).

In Python I would just return a tuple:

return (value_in_milliseconds,is_in_seconds,is_under_1ms)

In C I would define a struct of these three values and return it. In Pascal I'd define a record.

In Java I can't return a tuple and I can't define a record so what do I do?

The only thing I can think of is creating a class representing a duration value. The constructor would take the string and parse it. The class would have fields: int milliseconds, boolean inSeconds, boolean under 1ms .

But this sounds terribly heavyweight - is there a better solution?

Answer 1

Don't pass around a set of flags that must be consistent between them to make a sensible state. What if is_in_seconds and is_under_1ms are both true? And why would a variable that contains the word milliseconds ever be interpreted as seconds? How wrong-looking that will be in the code. Wrong-looking code is not good if you can do anything about it--we're supposed to write code whose appearance of rightness/wrongness matches reality—the Principle of Least Astonishment applied to code, and perhaps even the Pit of Success for subsequent developers whose brains will explode on that.

This sounds like maybe a bit of the Primitive Obsession code smell/antipattern, perhaps from your Python background? (I know next to nothing about Python so feel free to disregard this guess.)

Solution: make a real domain-level object that represents the idea of an approximate duration.

One possible implementation of that:

1. Create a DurationScale enum that has members Second, Millisecond, SubMillisecond.

2. Create a class ApproximateDuration, that takes a duration integer and a durationScale enum value.

3. Now consume this object in your other code. If you need to sum a series of these durations, make a class that knows how to interpret each one and add them together. Or add methods to this class.

An alternative to some concept like DurationScale could be MarginOfError which can be expressed in some arbitrary number of milliseconds, itself. This could allow you to use a strict mathematical formula to increase the margin of error appropriately as you sum different ApproximateDuration objects together into a new ApproximateDuration object.

Note: You can see some further discussion on why I recommend this approach.

The implementation you settled on is also a good way to handle it, where you explicitly state the lower and upper bounds:

public final class ApproximateDuration {
   private final int lowMilliseconds;
   private final int highMilliseconds;

   public ApproximateDuration(int lowMilliseconds, int highMilliseconds) {
      this.lowMilliseconds = lowMilliseconds;
      this.highMilliseconds = highMilliseconds;
   }

   public int getLowMilliseconds() {
      return lowMilliseconds;
   }

   public int getHighMilliseconds() {
      return highMilliseconds;
   }
}

Note that putting the word Milliseconds in the variables and property names is important, as is the immutability of this class.

Answer 2

It's no different than a C struct but you'll somehow at the least end up inheriting from Object

class Blah {
   public String value_in_milliseconds;
   public String is_in_seconds;
   public String is_under_1ms;
}

Answer 3

Define your own class or use for example apache commons:

return Triple.of(value_in_milliseconds, is_in_seconds, is_under_1ms);

Answer 4

I tried with a below example of passing a Object[] instead, keeping it simple:

public class MultiWayTest
{
    public static Object[] send() {
        return new Object[] { 1002322, false, true };
    }

    public static void main(String[] arg) {
        Object[] recieve=send();
    }
}

You may have noticed the statement return new Object[] { 1002322, false, true };

Hope that helps

Answer 5

Personally, I'd do:

class Duration {
    final int millis;
    final boolean specifiedInSeconds;
    final boolean under1ms;

    Duration(String s) {
        // parsing logic
    }
}

This solution is reasonably short, allows the compiler to detect typos in field names, encapsulates the invariant that the booleans may not both be set, and may safely be shared with other code without risking aliasing bugs.

Answer 6

You've hit exactly upon the Java way of handling this: You create a class to represent the answer, usually called a POJO (Plain Old Java Object). It's just a class with private members to hold each field, a constructor, getters, and optionally, setters.

That said, there are libraries that introduce Tuples or Tuple-esque abstractions, but they all work on POJO implementations.

Scala, which I also develop in, runs on the JVM, can interop with Java libraries, and has tuples among its many many other features.

Answer 7

Separation of concerns

Your method returns a duration. It should not care whether the caller wants to have a special flag for <1ms durations, (which would be 0ms, I assume?) or to have to test if you return seconds or milliseconds.

I assume you have a flow that looks like this:

def main():
  val, is_s, is_0 = get_duration()
  if is_0:
    print "Less than 1 ms"
  elif is_s:
    print str(val) + " s"
  else:
    print str(val) + " ms"

def get_duration():
  # ...
  ms = # some value computed elsewhere, presumably in ms
  if ms > 1000:
    return (ms / 1000, true, false)
  elif ms < 1:
    return (ms, false, true)
  else:
    return (ms, false, false)

What you are doing here is putting your presentation logic in your getting method.

I would rewrite it like that:

def main():
  ms = get_duration()
  if ms > 1000:
    str(val / 1000) + " s"
  elif ms < 1:
    print "Less than 1 ms"
  else:
    print str(ms) + " ms"


def get_duration():
  # ...
  ms = # some value computed elsewhere, presumably in ms
  return ms

That way get_duration doesn't have to presume how the information is going to be used by the caller.

What if someone needs minutes and hours, too? You would have to re-write all your calling methods to accomodate for the change in the shape of the tuple. Better to just let the caller handle that.

Answer 8

I have Three ways in which you can solve this problem. As you mentioned you don't want the correct method which is my first choice. Using POJO (Plain Old Java Objects). And I know you will like third choice because that's my favorite.

1. Using POJO

Using pojo you say that you are strongly suggesting to return only specified properties in Class and nothing more.

public class DataObjectClass {

private String value_in_milliseconds;

private boolean is_in_seconds;

private boolean is_under_1ms;

public String getValue_in_milliseconds() {
    return value_in_milliseconds;
}

public void setValue_in_milliseconds(String value_in_milliseconds) {
    this.value_in_milliseconds = value_in_milliseconds;
}

public boolean Is_in_seconds() {
    return is_in_seconds;
}

public void setIs_in_seconds(boolean is_in_seconds) {
    this.is_in_seconds = is_in_seconds;
}

public boolean Is_under_1ms() {
    return is_under_1ms;
}

public void setIs_under_1ms(boolean is_under_1ms) {
    this.is_under_1ms = is_under_1ms;
}

public static void main(String[] args) {
    DataObjectClass dataObjectClassFromMethod = anyMethod();
    System.out.println(dataObjectClassFromMethod.getValue_in_milliseconds());
    System.out.println(dataObjectClassFromMethod.Is_in_seconds());
    System.out.println(dataObjectClassFromMethod.Is_under_1ms());
}

public static DataObjectClass anyMethod() {
    DataObjectClass dataObjectClass = new DataObjectClass();
    dataObjectClass.setValue_in_milliseconds("value");
    dataObjectClass.setIs_in_seconds(true);
    dataObjectClass.setIs_under_1ms(true);
    return dataObjectClass;
}
}

In above code snippet, I have created another class DataObjectClass, which will hold combined data. Now whenever I need multiple data from any method. I will create Object of that class in that method. I will set properties of object. Now I will return that object from method. Obviously return type of method is DataObjectClass. Even though it sounds heavy this is correct way to do it. For example you might need more information then you can't use tuple. You can also use Lombok annotation to reduce your code. You can get Lombok.jar and include it in your build path.

@Data
public class DataObjectClass {
    private String value_in_milliseconds;

    private boolean is_in_seconds;

    private boolean is_under_1ms;
}
public static void main(String[] args) {
        DataObjectClass dataObjectClassFromMethod = anyMethod();
    }

    public static DataObjectClass anyMethod() {
        DataObjectClass dataObjectClass = new DataObjectClass();
        dataObjectClass.setValue_in_milliseconds("value");
        dataObjectClass.setIs_in_seconds(true);
        dataObjectClass.setIs_under_1ms(true);
        return dataObjectClass;
    }
}

2. JSONObject

There is one more way to do it, you can use JSONObject.

public class JSONExample {

    public static void main(String[] args) throws JSONException {
        JSONObject data = anyMethod();
    }

    public static JSONObject anyMethod() throws JSONException {
        JSONObject data = new JSONObject();
        data.put("value_in_milliseconds","value");
        data.put("is_in_seconds",true);
        data.put("is_under_1ms",true);
        return data;
    }
}

3. HashMap

You can also use HashMap of String and Object, read more about accessing HashMap, HashMap is part of JDK so no external jar required. With HashMap you can do cool things. And this is the easiest way.

public class HashMapExample {

    public static void main(String[] args) {
        Map<String,Object> data = anyMethod();
    }

    public static Map<String,Object> anyMethod()  {
        Map<String,Object> data = new HashMap<>();
        data.put("value_in_milliseconds","value");
        data.put("is_in_seconds",true);
        data.put("is_under_1ms",true);
        return data;
    }
}

Answer 9

You wrote:

The only thing I can think of is creating a class representing a duration value. The constructor would take the string and parse it. The class would have fields: int milliseconds, boolean inSeconds, boolean under1ms .

This is close to what I'd do by not exactly what I'd do.

I'd introduce a parameter object whose constructor is ParseResult(String valInMS, boolean isInSeconds, boolean isUnder1MS). Then I'd add a public static ParseResult parse(String) method that calls the constructor and returns the result.

By the way, in your example it looks like you want to consider using a java.util.Duration object.

Answer 10

Creating a new class here is indeed annoying, but this is mostly forced on you by the fact that Java is statically typed and Python is not. (EDIT: not quite, see comment below.) If you're willing to give up the benefits of static typing, then one of the answers given here (the array of Objects) gives you pretty much what you had in Python. The ergonomics are not quite as nice as Python because callers of your method will need to use explicit casts, but if there are only 3 callers then maybe in some situations it's worth it to avoid defining a class. I don't think this is one of those situations, because if you actually count how many lines things take, most of the lines are taken by parsing, in both languages. To wit:

def duration(d):
  if d == '<1ms': return 0, False, True
  if d.endswith('ms'): return int(d[:-2]), False, False
  return int(d[:-1])*1000, True, False

4 Lines of code to deal with 3 cases. Not bad. I'm not sure I like this from a caller's perspective since I have to keep straight the order that Booleans go in, so you probably want to spend an extra line or two on a good docstring. Now let's do Java.

class Duration{
  int ms;
  boolean isInSeconds, isUnder1ms;
  Duration(String d){
    if(d.equals("<1ms")) isUnder1ms = true;
    else if(d.endsWith("ms")) ms = new Integer(d.substring(0, d.length()-2));
    else {
      isInSeconds = true;
      ms = 1000 * new Integer(d.substring(0, d.length()-1));
  }
}

Okay, that took 11 lines instead of 4. Clearly, Java is more verbose than Python. But let's try a detailed cost breakdown. Two of those lines are just braces, since Java doesn't use indentation. The last else clause took 3 lines because Java doesn't have Python's delicious string slicing features. Finally, there is the overhead of creating a class. That's another 3 lines or so. But notice that those 3 lines actually buy us a benefit over the Python code: the code sites are now self documenting! Compare:

dur = duration(d)
if d[2]: print 'it was in seconds' # or was it d[1]?  I forget.

with

Duration dur = Duration(d);
if(dur.isInSeconds) System.out.println("It was in seconds");

If you don't care about the benefit of self-documenting callers, you can use roshan mathew's answer. But note how little code it saves you, and how much you still have to write.