Okey, conosciamo tutti il ​​modo normale di lanciare una IllegalArgumentException in Java:

throw new IllegalArgumentException(); // 37 characters

Ma ci devono essere modi più brevi (come in meno personaggi) per farlo. Come possiamo produrre un java.lang.IllegalArgumentException con ancora meno codice?

• Il frammento di codice deve essere compilato ed eseguito in Java 7.
• Nessuna importazione / pacchetto esterno (ad es. Non utilizzo java.util.Arrays.toString())
  • unica eccezione: java.lang perché viene importato automaticamente.
• È possibile aggiungere i propri metodi / classi.
• Deve generare un java.lang.IllegalArgumentException
  • Modifica: l'output dell'errore (stacktrace) deve chiamarlo java.lang.IllegalArgumentException, quindi nessuna sottoclasse di esso.

Per avere una base da cui partire:

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

Questi sono stati tutti trovati grepeseguendo il ping del codice sorgente nel pacchetto java.lang.

Tutti danno come risultato un "puro" IllegalArgumentException(cioè non una sua sottoclasse).

Quelli contrassegnati *funzionano solo se aggiungi " throws Exception"(18 caratteri) alla tua maindichiarazione, poiché generano un'eccezione controllata di qualche tipo.

12 (30?) Caratteri *

"".wait(-1);

Ciò comporterà:

java.lang.IllegalArgumentException: timeout value is negative

22 (40?) Caratteri *

new Thread().join(-1);

22 caratteri

Character.toChars(-1);

30 caratteri

Character.UnicodeBlock.of(-1);

Ecco un bel modo breve per farlo, in 17 13 caratteri :

new Long("");

Genera a NumberFormatException, che è un IllegalArgumentException. Questo e questo lo verificano.

Equivalentemente, si potrebbe fare

new Byte("");

22 caratteri:

Character.toChars(-1);

Esempio di esecuzione
Javadoc: java.lang.Character.toChars (int)

Alcune varianti carine:

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

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

~iè lo stesso -1 * (i+1)perché inverte i bit. Quindi avremo un parametro illegale, perché è inferiore a 0.
1<<7creeremo un numero troppo alto spostando 1 sette volte. (uguale a moltiplicarlo 7 volte per 2). L'ultimo valore accettato sembra essere 1114111, 1114112fallirà. Nota: questo potrebbe cambiare in base al proprio ambiente e potrebbe non essere sempre affidabile.

Consulta i documenti Oracle "Bitwise e Bit Shift Operators" e "Primitive Data Type"

28 caratteri:

E se non ti piace usare la classe di personaggi in una competizione di conteggio dei personaggi *:

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

*) Solo per fare questo gioco di parole.

21 caratteri:

System.getProperty("");

Come da documentazione, getPropertye setPropertylancia IllegalArgumentExceptionse la chiave è vuota.

25 personaggi

Crea un vettore con una lunghezza (negativa) non valida:

new java.util.Vector(-1);

Displays:

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)

Ecco 24 caratteri:

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

Questo genererà un IllegalFormatException, che è un IllegalArgumentException.

19 caratteri:

String.format("%");

Lancia java.util.UnknownFormatConversionException, che eredita da IllegalFormatException, che, a sua volta, eredita da IllegalArgumentException;

14 personaggi

this.wait(-1);

17 personaggi

Thread.sleep(-1);

Per quanto riguarda il codice che genera direttamente IllegalArgumentException, lo faranno.

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

quindi il codice diretto è di 17 caratteri, se sei un super stickler e conti i caratteri per aggiungere una clausola di lancio per l'eccezione interrotta, puoi accorciarla semplicemente lanciando la classe di eccezione grezza