Como usar null no switch

Integer i = ...

switch (i){
    case null:
        doSomething0();
        break;    
    }

No código acima, não posso usar null na instrução switch case. Como posso fazer isso de maneira diferente? Não posso usar defaultporque então quero fazer outra coisa.

Isso não é possível com uma switchinstrução em Java. Verifique nullantes de switch:

if (i == null) {
    doSomething0();
} else {
    switch (i) {
    case 1:
        // ...
        break;
    }
}

Você não pode usar objetos arbitrários nas switchinstruções ^* . O motivo pelo qual o compilador não se queixa sobre switch (i)onde iestá um Integeré porque o Java descompacta automaticamente o arquivo Integerpara um int. Como assylias já disse, o unboxing vai lançar um NullPointerExceptionquando ié null.

^* Desde o Java 7, você pode usar Stringem switchdeclarações.

Mais informações sobre switch(incluindo exemplo com variável nula) no Oracle Docs - Switch

switch ((i != null) ? i : DEFAULT_VALUE) {
        //...
}

switch(i)lançará uma NullPointerException se for null, porque tentará descompactar o arquivo Integerem um int. Então case null, o que é ilegal, nunca teria sido alcançado.

Você precisa verificar se i não é nulo antes da switchdeclaração.

Os documentos Java declararam claramente que:

A proibição de usar null como um rótulo de opção impede que alguém escreva um código que nunca pode ser executado. Se a expressão da opção for de um tipo de referência, como um tipo primitivo em caixa ou uma enumeração, ocorrerá um erro em tempo de execução se a expressão for avaliada como nula no tempo de execução.

Você deve verificar se há nulo antes da execução da instrução Swithch.

if (i == null)

Veja a declaração Switch

case null: // will never be executed, therefore disallowed.

Dado:

public enum PersonType {
    COOL_GUY(1),
    JERK(2);

    private final int typeId;
    private PersonType(int typeId) {
        this.typeId = typeId;
    }

    public final int getTypeId() {
        return typeId;
    }

    public static PersonType findByTypeId(int typeId) {
        for (PersonType type : values()) {
            if (type.typeId == typeId) {
                return type;
            }
        }
        return null;
    }
}

Para mim, isso normalmente está alinhado com uma tabela de pesquisa em um banco de dados (apenas para tabelas raramente atualizadas).

No entanto, quando tento usar findByTypeIdem uma instrução switch (da entrada do usuário mais provável) ...

int userInput = 3;
PersonType personType = PersonType.findByTypeId(userInput);
switch(personType) {
case COOL_GUY:
    // Do things only a cool guy would do.
    break;
case JERK:
    // Push back. Don't enable him.
    break;
default:
    // I don't know or care what to do with this mess.
}

... como outros já declararam, isso resulta em um NPE @ switch(personType) {. Uma solução alternativa (isto é, "solução") que comecei a implementar foi adicionar um UNKNOWN(-1)tipo.

public enum PersonType {
    UNKNOWN(-1),
    COOL_GUY(1),
    JERK(2);
    ...
    public static PersonType findByTypeId(int id) {
        ...
        return UNKNOWN;
    }
}

Agora, você não precisa fazer a verificação nula onde é importante e pode optar por, ou não, manipular os UNKNOWNtipos. (NOTA: -1é um identificador improvável em um cenário de negócios, mas obviamente escolha algo que faça sentido para o seu caso de uso).

Você tem que fazer uma

if (i == null) {
   doSomething0();
} else {
   switch (i) {
   }
}

Algumas bibliotecas tentam oferecer alternativas à switchinstrução java embutida . O Vavr é um deles, eles o generalizam para a correspondência de padrões.

Aqui está um exemplo de sua documentação :

String s = Match(i).of(
    Case($(1), "one"),
    Case($(2), "two"),
    Case($(), "?")
);

Você pode usar qualquer predicado, mas eles oferecem muitos deles imediatamente e $(null)é perfeitamente legal. Acho isso uma solução mais elegante do que as alternativas, mas isso requer java8 e uma dependência da biblioteca vavr ...

Você também pode usar String.valueOf((Object) nullableString) como

switch (String.valueOf((Object) nullableString)) {
case "someCase"
    //...
    break;
...
case "null": // or default:
    //...
        break;
}

Veja interessante SO Q / A: Por que String.valueOf (null) lança uma NullPointerException

switch (String.valueOf(value)){
    case "null":
    default: 
}

Você não pode. Você pode usar primitivas (int, char, short, byte) e String (Strings apenas no java 7) no switch. primitivas não podem ser nulas.
Verifique iem condições separadas antes de trocar.

Considere como o SWITCH pode funcionar,

• no caso de primitivos, sabemos que pode falhar com o NPE para o boxe automático
• mas para String ou enum , pode estar invocando o método equals, que obviamente precisa de um valor LHS no qual equal está sendo invocado. Portanto, dado que nenhum método pode ser chamado em um nulo, o switch não pode manipular nulo.

Com base na resposta @tetsuo, com java 8:

Integer i = ...

switch (Optional.ofNullable(i).orElse(DEFAULT_VALUE)) {
    case DEFAULT_VALUE:
        doDefault();
        break;    
}