Simple GCD utility in Java

Instead of throwing an Error, an AssertionError would be better. An Error is too broad. An AssertionError conveys better that instantiating is an error by the programmer, violating a precondition. (The only way this error will be triggered is if you try to create an instance within this class.)

private GCD() {
    throw new AssertionError("Instantiation not allowed.");
}

As this class has only private constructors, it cannot be extended: derived classes would need to call a constructor in the super-class, but none are available. To make the intention perfectly clear that this class is not designed to be extended, it's good to make it final.

1. Mark the class final to make it obvious there are no and never will be any derived classes.

2. While your comments insist that the domain of gcd is non-negative integers, that doesn't conform to your code (which takes the absolute values), which gets it mostly right:

   • Only the absolute value is relevant for the gcd. Unfortunately, you cannot negate the most-negative input-value (Long.MIN_VALUE), so you are forced to diagnose a domain-error there (throw an ArithmeticException).

   • If one argument is 0, the result is abs(theother), not theother.

3. You could simplify the second function by only asking for a single fixed argument (or even no fixed arguments, with a result of 0).

   What is \$gcd(0,a)\$, where a is a positive integer?
   What is \$gcd(0,0)\$?

   That probably doesn't improve performance though:

   public static long of(long a, long... others) {
       for (long number : others)
           a = of(a, number);
       return a;
   }
   

   Or:

   // The added iteration probably adds a really small penalty
   public static long of(long... others) {
       long a = 0;
       for(long number : others)
           a = of(a, number);
   }
   

I think there's a bug in your method. If I call GCD.of(0,0); You'd return b, which equals 0. But 0 isn't the GCD of 0. Zero can't ever be a greatest common divisor. Because, you can't divide by zero. You should consider throwing a DivideByZeroException, because once you're there there's nothing else you can do! Edit : Thanks to @Deduplicator's comment which pointed at a question on Math.SE You should return 0 if one of the parameter is 0!

To push on Deduplicator's idea, I think you should only receive one argument.

public static long of(long... numbers)
//See the rest of the review

• Now, what if the user passes zero arguments? Throw an exception, the user decided, by him(her)self, to pass zero arguments to a GCD function, it's dumb and the user will have to deal with the consequences of his(her) acts.
• What if the user passes only one argument. Well that's an easy job for you, you return the same number. The user decided to ask for the GCD of one number, give it to him.
• The user passes more than 1 long, good, now the real work begins!

public static long of(long... numbers) {
    if(numbers.length == 0) {
        throw new InvalidArgumentException("Input is too small to compute GCD");
    }

    if(numbers.length == 1) {
        return numbers[0];
    }

    long gcd = numbers[0];
    //Note that the index starts at one because we use [0] for the first variable.
    for(int index = 1; index < numbers.length;index++){

        long number = numbers[index];
        if(number == 0) {
            return 0;
        }

        gcd = of(gcd, number);
    }

    return gcd;
}

This is only a mild improvement, and whether or not you call it an improvement is subjective.

Your second function:

public static long of(long a, long b, long... others) {
    long gcd = of(a, b);
    for (long number : others) {
        gcd = of(gcd, number);
    }
    return gcd;
}

Can be rewritten using Java 8's stream operators:

public static long of(long a, long... others) {
    return LongStream.concat(
               LongStream.of(a),
               LongStream.of(others)
           ).reduce(0, GCD::of);
}

And if you are fine with the user being able to call GCD.of(), you could do:

public static long of(long... values) {
    return LongStream.of(values)
                     .reduce(0, GCD::of);
}

This has the advantage of being easily parallelizable (which is actually only beneficial if you anticipate having a very large amount of values to find the gcd of):

public static long of(long... values) {
    return LongStream.of(values).parallel()
                     .reduce(0, GCD::of);
}