Okey, todos sabemos a maneira normal de lançar uma IllegalArgumentException em Java:

throw new IllegalArgumentException(); // 37 characters

Mas deve haver maneiras mais curtas (como em menos caracteres) de fazer isso. Como podemos produzir uma java.lang.IllegalArgumentException com ainda menos código?

• O fragmento de código deve ser compilado e executado no java 7.
• Sem importações / pacotes externos (por exemplo, não usando java.util.Arrays.toString())
  • única exceção: java.lang porque é importado automaticamente.
• Você pode adicionar métodos / classes próprios.
• Ele deve lançar um java.lang.IllegalArgumentException
  • Edit: a saída de erro (stacktrace) deve chamá-la de java.lang.IllegalArgumentException, portanto, nenhuma subclasse dela.

Para ter uma base para começar:

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

Todos foram encontrados através do grepping do código-fonte no pacote java.lang.

Todos eles resultam em uma "pura" IllegalArgumentException(isto é, não uma subclasse dela).

Os marcados *funcionam apenas se você adicionar " throws Exception"(18 caracteres) à sua maindeclaração, pois eles lançam uma exceção marcada de algum tipo.

12 (30?) Caracteres *

"".wait(-1);

Isso resultará em:

java.lang.IllegalArgumentException: timeout value is negative

22 caracteres (40?) *

new Thread().join(-1);

22 caracteres

Character.toChars(-1);

30 caracteres

Character.UnicodeBlock.of(-1);

Aqui está uma maneira curta e agradável de fazer isso, em 17 13 caracteres :

new Long("");

Ele lança a NumberFormatException, que é um IllegalArgumentException. Isso e isso verificam.

Equivalentemente, alguém poderia fazer

new Byte("");

22 caracteres:

Character.toChars(-1);

Exemplo de execução
Javadoc: java.lang.Character.toChars (int)

Algumas variantes interessantes:

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

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

~ié o mesmo que -1 * (i+1)porque inverte os bits. Portanto, obteremos um parâmetro ilegal, porque é menor que 0.
1<<7criará um número muito alto, deslocando o 1 sete vezes. (o mesmo que multiplicá-lo 7 vezes por 2). O último valor aceito parece ser 1114111, 1114112falhará. Nota: isso pode mudar dependendo do seu ambiente e nem sempre é confiável.

Consulte o Oracle Docs "Operadores bit a bit e deslocamento de bits" e "Tipos de dados primitivos"

28 caracteres:

E se você não gosta de usar a classe de personagem em uma competição de contagem de caracteres *:

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

*) Apenas para fazer esse trocadilho.

21 caracteres:

System.getProperty("");

Conforme a documentação, getPropertye setPropertyjogue IllegalArgumentExceptionse a chave estiver vazia.

25 caracteres

Cria um vetor com um comprimento (negativo) inválido:

new java.util.Vector(-1);

Exibe:

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)

Aqui estão 24 caracteres:

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

Isso jogará um IllegalFormatException, que é um IllegalArgumentException.

19 caracteres:

String.format("%");

Lança java.util.UnknownFormatConversionException, que herda de IllegalFormatException, que, por sua vez, herda de IllegalArgumentException;

14 caracteres

this.wait(-1);

17 caracteres

Thread.sleep(-1);

Quanto ao código que lança diretamente IllegalArgumentException, eles o farão.

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

Portanto, o código direto é de 17 caracteres, se você estiver sendo um super-defensor e contando os caracteres para adicionar uma cláusula throws à exceção interrompida, você pode abreviá-lo apenas lançando a classe Exception bruta