Если, иначе, если еще

Question

Давайте предположим, что у меня есть две строки, которые могут быть переданы в качестве параметра:

String one = "one"; 
String two = "two"; 

Какой из следующих способов будет наиболее эффективным?

private void exampleOne(String example){ 
    if(example.equals("one"){ 
     // do this 
    }else{ 
     // do this 
    } 
} 

private void exampleTwo(String example){ 
    if(example.equals("one"){ 
     //do this 
    }else if(example.equals("two"){ 
     // do this 
    } 
} 


private void exampleThree(String example){ 
    if(example.equals("one"){ 
     // do this 
    } 
    if(example.equals("two"){ 
     // do this 
    } 
} 

Answer 1

Я бы сравнил методы эффективности, если они имеют одинаковую функциональность. В настоящее время все три метода функционально отличаются друг от друга. Поэтому нет смысла сравнивать их.

1. exampleOne() - Если пример равно "one", выполнить if. Выполните else для всех других значений.

2. exampleTwo() - Если пример равен "one", выполните if. Выполните else if, если оно равно "two", иначе для всех остальных значений сделайте ничего - (Вот одно отличие).

3. exampleThree() - Ну, этот (как он есть) более или менее такой же, как и первый, с одним дополнительным сравнением, что, кстати, не повлияет на эффективность эффективности. Однако есть вероятность, что в этом методе могут выполняться операторы if, если между двумя операциями if вы назначаете строку "two" на example, что невозможно в методе exampleOne. Чтобы быть более понятным, у вас есть два независимых блока if, а в первом методе это блок if-else (только один из них будет выполнен).

Answer 2

Тот, что, статистически говоря, делает наименьшее строку сравнивает т.е.

if (example.equals("one"){ 
    // do this 
} else { 
    // do this 
} 

Answer 3

первым один. Потому что вам не нужно проверять другое условие. В другом вам больше работать.

Наиболее эффективным: 1, 2, 3.

Но если вы должны проверить, если i==0 и вы будете ожидать, что большинство из них будет != лучше написать if (i != 0) {} else{} чем If (i==0) {...}

Держите все как просто, как можно

Answer 4

Я бы сказал, первый, только потому, что он имеет только оценить одно выражение каждый раз, когда ...

Answer 5

Я бы сказал, что первое, потому что если это просто говорит else без условия, тогда ему не нужно ничего проверять, просто перейдите прямо в 'else'

Answer 6

На мой взгляд второй один, потому что у вас есть прямой контроль на обоих сценариях. Когда Sring «один» и «два».

В примере Один, метод не заботится о том, передано ли «два» или «три».Он заботится только об одной ситуации, если «один» принят

Answer 7

Никто не является наиболее эффективным из-за того, что у вас есть только два варианта, вы должны учитывать, что значение не должно быть не одним, а не двумя, а может быть и другим (пустым? null?) SO, вы должны написать примерно так:

if(example.equals("one"){ 
    //do this 1 
}else if(example.equals("two"){ 
    // do this 2 
}else{ 
    // do this 3 
} 

Answer 8

Теоретически первое наиболее эффективно. Практически, вы должны пойти на второй, так как он обеспечивает лучшую читаемость и ремонтопригодность.

Помните, что преждевременная оптимизация есть корень всех зол :)

Answer 9

1) наиболее эффективной, но это не хорошо для ремонтопригодности.

private void exampleOne(String example){ 
    if(example.equals("one"){ 
     // do this 
    }else{ 
     // do this 
    } 
} 

2) второй эффективный, но он хорош для ремонтопригодности.

private void exampleTwo(String example){ 
    if(example.equals("one"){ 
     //do this 
    }else if(example.equals("two"){ 
     // do this 
    } 
} 

3) третий эффективный.

private void exampleThree(String example){ 
    if(example.equals("one"){ 
     // do this 
    } 
    if(example.equals("two"){ 
     // do this 
    } 
} 

Answer 10

Эти блоки нельзя сравнивать и вы не можете указать, что является лучшим из них, поскольку они текут для каждого случая.

Этот блок обеспечивает два пути положительным, а не.

private void exampleOne(String example){ 
    if("one".equals(example){ //deciosn 
     // path positive 
    }else{ 
     // path negative 
    } 
} 

Этот блок обеспечивает три пути, положительный, отрицательный, положительный, отрицательный-отрицательные

private void exampleTwo(String example){ 
    if("one".equals(example){ 
     //path positive 
    }else { 
     // path negative 
     if("two".equals(example{ 
     // path negative-positive 
     } 
    } 
} 

Этот блок обеспечивает четыре пути, положительного номера, отрицательный и положительный отрицательный.

private void exampleThree(String example){ 
    if("pne".equals(example){ 
     // path positive 
    } 
    if("two".equals(example){ 
     // path positive 
    } 
} 

Как вы видите, у вас есть четыре разных кода, которые вы не должны сравнивать, чтобы определить, что более эффективно.

Вы должны сфокусироваться на алгоритме, а не на том, как выглядеть.

Совет:

Попробуйте использовать константу на левой стороне сравнения, так что вы бы избежать таких проблем, как разыменовывает и недействительный правопреемник.

Answer 11

я не знаю, какова ваши потребности так, здесь есть ми мнение,

первая, будет делать только ВСЕГДА одну проверки .. поэтому в этом конкретном примере это будет один с меньшими СРАВНЕНИЯМИ.

второй ОДИН, сделаем в худшем случае 2 сравнения 1 для «одного» и 1 для «двух», но ... (есть всегда, но) это не будет никакая работа, если строка позволяет сказать «три »(в первом примере он перейдет к другому)

3 пример будет делать ВСЕГДА 2 СРАВНЕНИЯ, если вы не положили возвращения внутри ifs.

так, по моему мнению, информации недостаточно, чтобы сказать, что один из них более оптимален.

одно присоединение: вы можете попробовать, а не писать концы, если ...использовать случай как этот:

switch (true) { 
     case example.equals("one"): 
       break; 
     case example.equals("two"): 
       break; 

     default: 
       break; 
} 

Answer 12

По-видимому, первый способ будет наиболее эффективным по сравнению с возможными значениями параметров, так как дополнительный, если условие в других методах бесполезно и не будет иметь ничего общего в твоем случае. (проверка дополнительного состояния ==> более низкая эффективность)