public class Operacion {

public int sumar(Integer... valores) {
return sumar(Arrays.asList(valores));
}

public int sumar(List<Integer> valores) {
int suma = 0;
suma = valores.stream().map((Integer item) -> item).reduce(suma, Integer::sum);
return suma;
}

public int sumar(int... valores) {
int suma = 0;
for (int item : valores) {
suma += item;
}
return suma;
}
}

Sigue un test que comprueba los métodos de Operacion, y que muestra su flexibilidad.

public class OperacionTest {

/**
@param args the command line arguments
*/
public static void main(String[] args) {

Operacion operacion = new Operacion();

int suma1 = operacion.sumar(new Integer[]{1, 2, 3, 4, 5});

int suma2 = operacion.sumar(Arrays.asList(1, 2, 3, 4, 5, 6, 7));

List<Integer> valores = new ArrayList<>(10);
for (int i = 1; i <= 10; i++) {
valores.add(i);
}
int suma3 = operacion.sumar(valores);

int suma4 = operacion.sumar(1, 2, 3, 4, 5, 6, 7, 8, 9);

int suma5 = operacion.sumar(new int[]{1, 2, 3});

System.out.println("suma1= " + suma1);
System.out.println("suma2= " + suma2);
System.out.println("suma3= " + suma3);
System.out.println("suma4= " + suma4);
System.out.println("suma5= " + suma5);
}

}

Puesto que las operaciones con enteros pueden provocar resultados erróneos, debido al overflow por encima, o por debajo, de los valores Integer.MAX_VALUE o Integer.MIN_VALUE, siguen la clase rectificada y un nuevo test.

public class Operacion {

public BigInteger sumar(BigInteger... valores) {
return sumar(Arrays.asList(valores));
}

public BigInteger sumar(List<BigInteger> valores) {
BigInteger suma = BigInteger.ZERO;
for (BigInteger item : valores) {
suma = suma.add(item);
}
return suma;
}
}

public class OperacionTest {

/**
@param args the command line arguments
*/
public static void main(String[] args) {

Operacion operacion = new Operacion();

BigInteger suma1 = operacion.sumar(new BigInteger[]{BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3), BigInteger.valueOf(4), BigInteger.valueOf(5)});

BigInteger suma2 = operacion.sumar(Arrays.asList(BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3), BigInteger.valueOf(Integer.MAX_VALUE)));

List<BigInteger> valores = new ArrayList<>(10);
for (int i = 1; i <= 100; i++) {
valores.add(BigInteger.valueOf(i));
}
BigInteger suma3 = operacion.sumar(valores);

System.out.println("suma1= " + suma1);
System.out.println("suma2= " + suma2);
System.out.println("suma3= " + suma3);

}
}

Todas son correctas y todas reducen el código.

Tal y como se ha planteado, esa clase solo permite sumar 2, 3 o 4 números, nada más, y con métodos diferentes. Si se desean sumar más números, es inevitable añadir más métodos, con diferentes signaturas.

Cada solución planteada permite sumar cualquier secuencia de números indeterminada, con un único método.

"Reducir código" no consiste solamente en "contar menos líneas", aún menos cuando se empaqueta el código en una única línea, al margen de cualquier recomendación de legibilidad, con el objeto de contar menos.

La clase planteada, como API, con tres métodos sobrecargados que hacen lo mismo, y que se limita a tres operaciones, es un ejemplo de redundancia y limitación inaceptables.

Por si no queda claro, sigue la clase propuesta debidamente formateada.

public class Operacion {

public int sumar(int a, int b) {
return a + b;
}

public int sumar(int a, int b, int c) {
return a + b + c;
}

public int sumar(int a, int b, int c, int d) {
return a + b + c + d;
}
}

Esta es la reducción propuesta, usando JavaSE 1.8

public class Operacion {

public int sumar(int... valores) {
int suma = 0;
suma = Arrays.stream(valores).reduce(suma, Integer::sum);
return suma;
}
}

Y esta otra, usando versiones anteriores

public class Operacion {

public int sumar(int... valores) {
int suma = 0;
for (int item : valores) {
suma += item;
}
return suma;
}
}

Hay algunas otras cosas "graciosas" sobre este asunto.
En esta misma página hay otra entrada reciente, con exactamente la misma cuestión: una "fotocopia" perfecta.
En ningún caso, los autores de las entradas se han dignado hacer ningún comentario, ni explicar tal curiosa "coincidencia".
Y ahora, aparece un comentario, a una entrada de hace un mes, que se limita a descalificar las respuestas.