Java сравнить значения, лучший способ

Question

У меня есть такой метод

private boolean validGrade(final StringBuilder grade) {
   boolean isValid = false;
   String semester = "semester"; 

   if ((grade.toString().contains("2o") && grade.toString().contains(semester))
                    || (grade.toString().contains("4o") && grade.toString().contains(semester))
                    || (grade.toString().contains("6o") && grade.toString().contains(semester))
                    || (grade.toString().contains("8o") && grade.toString().contains(semester))) {
    isValid = true;
            }
    }

И я хочу заменить его следующим образом:

private boolean doValidGradoAntComp(final StringBuilder grade) {
        boolean isValid = false;

        switch (grade.toString()) {
        case "2o semester":
            isValid = true;
            break;
        case "4o semester":
            isValid = true;
            break;
        case "6o semester":
            isValid = true;
            break;
        case "8o semester":
            isValid = true;
            break;
        default:
            break;
        }

        return isValid;
    }

И я сомневаюсь: , которыйодин лучше? Оба работают одинаково?

Answer 1

Почему бы не перебрать возможности?

private boolean validGrade(final StringBuilder grade) {
    String gradeString = grade.toString();
    return List.of("2o", "4o", "6o", "8o")
        .stream()
        .map(x -> x + " semester")
        .collect(Collectors.toSet())
        .contains(gradeString);
}

В качестве альтернативы, если вы не ищете точных совпадений, выполните:

private boolean validGrade(final StringBuilder grade) {
    String gradeString = grade.toString();
    return gradeString.contains("semester") && List.of("2o", "4o", "6o", "8o")
        .stream()
        .anyMatch(gradeString::contains);
}

Наконец, если ваш набор совпадений негибкий (всегда будет "2o", "4o", "6o", "8o"),тогда вы можете просто использовать регулярное выражение:

private boolean validGrade(final StringBuilder grade) {
    return grade.toString().matches("[2468]o semester"); //exact match
//  return grade.toString().matches("[2468]o.*semester|semester.*[2468]o"); //loose match
//  return grade.toString().matches(".*([2468]o.*semester|semester.*[2468]o).*"); //equivalent to contains
}

Answer 2

Нет, оба подхода различны. В первом подходе вы используете contains для проверки двух строк, существующих в grade (например, 2o и semester в grade). Но во втором подходе вы проверяете, grade равно 2o semester. Я предпочитаю собирать все те, чтобы перечислить и использовать anyMatch

List<String> list = List.of("2o","4o","6o","8o");

if(list.stream().anyMatch(val->grade.contains(val) && grade.contains(semester))) {

Answer 3

Регулярное выражение может быть медленнее, чем if-else или switch. Но в вашем случае я бы больше оценил удобочитаемость и использовал бы регулярное выражение.

private boolean validGrade(final StringBuilder grade) {
    return grade.toString().matches("(2o|4o|6o|8o) semester");
}

Answer 4

Оба служат одной и той же цели, но у каждого есть свои отличия, слабости и сильные стороны.

Если / иначе

• Трудности с письмом и чтением(код трудно написать, потому что вам нужно включить многозначные проверки в одну инструкцию)

• Вы решаете, будет ли выполняться ваш код.

• Как и в случае с переключателем, вы можете создать оператор default, если его значение не соответствует действительности (иначе).

Переключатель

• Легко писать и читать код.

• Вы всегда будете входить в блок переключателей, если ни один регистр, который соответствует введенному вами значению, не будет установлен по умолчанию.

• Вы можете использовать только char или int в случаях.

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

Вывод:

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

Если у вас мало дел для проверки, я бы использовал if/else, но в вашем случае показанный код рекомендует использовать switch case для количества проверок, которое высделать это только в одном блоке кода.