Should Guava Splitters/Joiners be created each time they are used?

Question

Guava contains utilities for splitting and joining Strings, but it requires the instantiation of a Splitter/Joiner object to do so. These are small objects that typically only contain the character(s) on which to split/join. Is it a good idea to maintain references to these objects in order to reuse them, or is it preferable to just create them whenever you need them and let them be garbage collected?

For example, I could implement this method in the following two ways:

String joinLines(List<String> lines) {
  return Joiner.on("\n").join(lines);
}

OR

static final Joiner LINE_JOINER = Joiner.on("\n");

String joinLines(List<String> lines) {
  return LINE_JOINER.join(lines);
}

I find the first way more readable, but it seems wasteful to create a new Joiner each time the method is called.

Answer 1

To be honest, this sounds like premature optimization to me. I agree with @Andy Turner, write whatever is easiest to understand and maintain.

If you plan to use Joiner.on("\n") in a few places, make it a well named constant; go with option two.

If you only plan to use it in your joinLines method, a constant seems overly verbose; go with option one.

Answer 2

It depends greatly on how often you expect the code to be called and what tradeoffs you want to make between CPU time, memory consumption and readability. Since Joiner is such a small thing, it's not going to make a huge difference either way: if you make it a constant, you save the (fairly minimal) costs of allocating it and GCing it for each call, while adding the (fairly minimal) memory consumption overhead to the program.

It also depends in part on what platform you're running the code on: if you're running on the server, typically you'll have plenty of memory so keeping a constant won't be an issue. On the other hand, if you're running on Android you're more memory constrained, but you also want to avoid unnecessary allocations since garbage collection is going to be worse and more impactful to your performance.

Personally, I tend to allocate a constant unless I know it's only going to be used some fixed number of times as opposed to repeatedly throughout the program.