Effective Java! Use Varargs Judiciously

Effective Java Review (90 Part Series)

A varargs parameter is a syntactic sugar feature of Java that allows you to define a parameter that allows the caller to provide zero or more arguments of the defined type. Inside the receiving function these values are provided as an array of the specified type.

Let’s look at a quick example:

static int sum(int... args) {
  int sum = 0;
  for (int arg : args) {
    sum += arg;
  }
  return sum;
}

Enter fullscreen mode Exit fullscreen mode

This method can be called like sum(1,2) which of course would produce 3 or sum(1,2,3) which of course would produce 6 or even sum() which would produce 0.

This capability can be of great use but there are some problem areas when using varags. Let’s consider some of them and how we might overcome the challenge.

Sometimes you may want to have a minimum number of parameters that you want to accept. As pointed out above, varags by itself allows 0 to n parameters to be passed in. We could consider checking the size of the array at runtime. While this would work it does have the downside of errors being found at runtime not compile time. This solution can also be ugly and gets in the way of the true logic. There is a better way though. Consider if we wanted to take a minimum of one argument. The solution to this would be to give our method two parameters. One simply of the type and the second as the vararg parameter. This would force the caller to provide at least one parameter at compile time. That may look something like:

static int min(int firstValue, int... restOfValues) {
  int currentMin = firstValue;
  for (int value : restOfValues) {
    if ( value < currentMin) {
      currentMin = value;
    }

  }
  return currentMin;
}

Enter fullscreen mode Exit fullscreen mode

Another potential pitfall of using vararg parameters is in performance critical applications. The reason for this is every method call requires the creation of an array. If this occurs on a loop this can produce avoidable memory pressure that can hurt the performance of your application. A possible mitigation strategy to this is, if for example 95% of the callers of the function will include 3 or less parameters you can create three functions that take 1, 2, and 3 parameters of the argument type to handle the 95% and a fourth that takes three parameters and a vararg parameter to handle the rest of the 5%. This is what the EnumSet object does to help it keep its great performance. Many times this optimization won’t be appropriate but in the cases it does it can be a lifesaver.

In summary, varargs parameters are a useful feature as part of the Java language. As with all features there are some rough edges to this feature that we should be aware of. However, as we keep these things in mind we can make some great improvements to our code.

Effective Java Review (90 Part Series)

原文链接：Effective Java! Use Varargs Judiciously

文章版权声明 1、本网站名称：拾光赋
2、本站永久网址：https://www.blogs.ink
3、本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长QQ：805375623进行删除处理。
4、本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5、本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6、本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

THE END