Okey, todos sabemos la forma normal de lanzar una IllegalArgumentException en Java:

throw new IllegalArgumentException(); // 37 characters

Pero debe haber una forma más corta (como en menos caracteres) de hacerlo. ¿Cómo podemos producir una excepción java.lang.IllegalArgumentException con aún menos código?

• El fragmento de código tiene que compilarse y ejecutarse en Java 7.
• Sin importaciones / paquetes externos (por ejemplo, sin usar java.util.Arrays.toString())
  • única excepción: java.lang porque se importa automáticamente.
• Puede agregar sus propios métodos / clases.
• Debe arrojar una java.lang.IllegalArgumentException
  • Editar: la salida de error (stacktrace) debe nombrarla java.lang.IllegalArgumentException, por lo que no hay subclases de la misma.

Para tener una base para comenzar:

class Titled {
    public static void main(String[] args) {
        throw new IllegalArgumentException();
    }
}

Todo esto se encontró haciendo grepping al código fuente en el paquete java.lang.

Todos ellos resultan en un "puro" IllegalArgumentException(es decir, no una subclase de la misma).

Los marcados *solo funcionan si agrega " throws Exception"(18 caracteres) a su maindeclaración, ya que arrojan una excepción marcada de algún tipo.

12 (30?) Caracteres *

"".wait(-1);

Esto resultará en:

java.lang.IllegalArgumentException: timeout value is negative

22 (40?) Caracteres *

new Thread().join(-1);

22 caracteres

Character.toChars(-1);

30 caracteres

Character.UnicodeBlock.of(-1);

Aquí hay una pequeña forma de hacerlo, en 17 13 caracteres :

new Long("");

Lanza un NumberFormatException, que es un IllegalArgumentException. Esto y esto lo verifican.

Equivalentemente, uno podría hacer

new Byte("");

22 caracteres:

Character.toChars(-1);

Ejecutando
Javadoc de ejemplo : java.lang.Character.toChars (int)

Algunas variantes bonitas:

Character.toChars(~4); // 22 characters, number can be any non-negative (and -0)

Character.toChars(1<<7); // 24 characters

~ies lo mismo que -1 * (i+1)porque invierte los bits. Entonces obtendremos un parámetro ilegal, porque es más pequeño que 0.
1<<7creará un número demasiado alto al cambiar el 1 siete veces. (lo mismo que multiplicarlo 7 veces por 2). El último valor aceptado parece ser 1114111, 1114112fallará. Nota: esto puede cambiar según su entorno y no siempre es confiable.

Consulte los "Operadores Bitwise y Bit Shift" y "Tipos de datos primitivos" de Oracle Docs.

28 caracteres:

Y si no te gusta usar la clase de personaje en una competencia de conteo de personajes *:

Enum.valueOf(Enum.class,""); // 28 characters

*) Solo para hacer este juego de palabras.

21 caracteres:

System.getProperty("");

Según la documentación, getPropertyy setPropertytirar IllegalArgumentExceptionsi la clave está vacía.

25 personajes

Crea un vector con una longitud no válida (negativa):

new java.util.Vector(-1);

Muestra:

Exception in thread "main" java.lang.IllegalArgumentException: Illegal Capacity: -1
    at java.util.Vector.<init>(Vector.java:129)
    at java.util.Vector.<init>(Vector.java:144)
    at Titled.main(Titled.java:3)

Aquí hay 24 caracteres:

System.out.printf("%z");

Esto arrojará un IllegalFormatException, que es un IllegalArgumentException.

19 caracteres:

String.format("%");

Lanza java.util.UnknownFormatConversionException, que hereda de IllegalFormatException, que, a su vez, hereda de IllegalArgumentException;

14 personajes

this.wait(-1);

17 personajes

Thread.sleep(-1);

En cuanto al código que arroja directamente IllegalArgumentException, estos lo harán.

From documentation: 
Thread.sleep(int millis): 
Throws:IllegalArgumentException - if the value of millis is negative
InterruptedException - if any thread has interrupted the current thread. 

así que el código directo es de 17 caracteres, si estás siendo un súper adherente y estás contando los caracteres para agregar una cláusula throws para la excepción interrumpida, puedes acortarlo simplemente lanzando la clase de excepción sin procesar