O que é melhor ? Múltiplas instruções if, ou uma se com múltiplas condições

Para o meu trabalho eu tenho que desenvolver um pequeno aplicativo Java que analisa arquivos XML muito grandes (~ 300k linhas) para selecionar dados muito específicos (usando Pattern ), então estou tentando otimizá-lo um pouco. Eu queria saber o que era melhor entre esses dois trechos:

 if(boolean_condition && matcher.find(string)) { ... } 

OU

 if(boolean_condition) { if(matcher.find(string)) { ... } } 

Mais precisões:

  • Estas instruções if são executadas em cada iteração dentro de um loop (~ 20k iterações)
  • O boolean_condition é um boolean calculado em cada iteração usando uma function externa
  • Se o valor boolean estiver definido como false , não preciso testar a expressão regular para correspondências

Obrigado pela ajuda

Uma regra de ouro que eu sigo é evitar o aninhamento , tanto quanto eu puder. Mas se for ao custo de tornar minha condição de se único muito complexa, não me importo de aninhar isso.

Além disso, você está usando o operador de curto-circuito && . Então, se o booleano é falso, ele nem sequer tentará corresponder!

Assim,

 if(boolean_condition && matcher.find(string)) { ... } 

é o caminho a percorrer!

Os dois methods a seguir:

 public void oneIf(boolean a, boolean b) { if (a && b) { } } public void twoIfs(boolean a, boolean b) { if (a) { if (b) { } } } 

produza exatamente o mesmo código de byte para o corpo do método, de modo que não haverá qualquer diferença de desempenho, significando que é puramente uma questão estilística que você usa (pessoalmente eu prefiro o primeiro estilo).

Ambas as formas são OK e a segunda condição não será testada se a primeira for falsa.

Use o que torna o código mais legível e compreensível. Por apenas duas condições, a primeira maneira é mais lógica e legível. Pode não ser mais o caso com 5 ou 6 condições ligadas a && , || e ! .

Java usa curto-circuito para esses operadores booleanos, portanto ambas as variações são funcionalmente idênticas. Portanto, se a condição boolean_condition for falsa, ela não continuará na correspondência

Em última análise, o problema é que você acha mais fácil ler e depurar, mas o aninhamento profundo pode se tornar pesado se você acabar com uma quantidade enorme de chaves no final.

Uma maneira de melhorar a legibilidade, caso a condição se torne mais longa, é simplesmente dividi-la em várias linhas:

 if(boolean_condition && matcher.find(string)) { ... } 

A única escolha nesse ponto é se colocar o && e || no final da linha anterior ou no início da corrente.

O primeiro. Eu tento evitar se aninhando assim, eu acho que é um estilo pobre / código feio e o && irá shortcircuit e só testarei com matcher.find () se o booleano for verdadeiro.

Em termos de desempenho, eles são os mesmos.

  • Mas mesmo se eles não estivessem

O que é quase certo que dominar o tempo neste código é matcher.find(string) porque é uma chamada de function.

Se você gosta de ser compatível com o squid da regra do Sonar: S1066 você deve recolher se as instruções evitar o aviso desde que declara:

Declarações “if” recolhíveis devem ser mescladas

Eu costumo ver muitos && e || amarrados juntos em uma sopa de lógica e muitas vezes são a fonte de insetos sutis.

É muito fácil simplesmente adicionar outro && ou || para o que você acha que é o ponto certo e quebrar a lógica existente.

Devido a isso, como regra geral, tento não usar nenhum deles para evitar a tentação de adicionar mais conforme os requisitos mudam.