Java의 점프 연산자

안녕하세요! 오늘은 Java의 점프 연산자에 대해 이야기하겠습니다.

• return
• break
• continue
• goto

먼저 그것이 실제로 무엇인지 정의합시다. 아시다시피, 정상적인 상황에서 프로그램은 명령별로 위에서 아래로 선형적으로 실행됩니다. 프로그램의 선형 흐름은 소위 제어 구조(예: 분기( if) 및 루프( for등 while))에 의해 변경될 수 있습니다. 제어 구성 외에도 점프 문을 통해 프로그램의 선형 실행을 수정할 수 있습니다. 그들은 컨텍스트와 특정 명령문에 따라 프로그램 실행을 특정 위치로 리디렉션하는 역할을 담당합니다. 4명의 연산자 각각에 대해 자세히 살펴보겠습니다.

반품

초보자가 가장 먼저 익숙해지는 것은 바로 이 연산자입니다. 명령문은 return호출된 메소드를 종료하고 프로그램 실행은 메소드가 호출된 위치로 돌아갑니다. 여기 return에는 두 가지 형태가 있습니다.

1. 메소드 실행을 즉시 종료합니다.
2. 메서드 실행을 즉시 종료하고 메서드 결과로 일부 값을 반환합니다.

두 형식의 구문은 다음과 같습니다.

return;
return value; // где value — некоторое возвращаемое meaning

return값을 반환하는 메서드 에는 호출이 보장되는 반환 값이 있는 연산자가 하나 이상 있어야 하며 , return반환 값이 없는 연산자가 있어서는 안 됩니다. 아래 예를 살펴보겠습니다.

public int sum(int a, int b) {
    return a + b;
}

public String getGreetings(String name) {
    return "Hello " + name;
}

public int max(int x, int y) {
    if (x > y) {
        return x;
    } else {
        return y;
    }
}

값을 반환하지 않는 메서드(methods )에서는 반환 값이 없는 문이 하나 이상 있고 반환 값이 있는 문이 하나도 없는 것이 void허용되지만 필수는 아닙니다 . 아래 예를 통해 이를 살펴보겠습니다. returnreturn

public void print(String s) {
    // наличие return в void методах не обязательно
    System.out.println(s);
}

//Метод выведет в консоль число, если оно нечетное
public void printIfOdd(int number) {
    if (number % 2 == 0) {
        // Если число четное, метод завершит свою работу
        // Наличие return в void методах опционально
        return;
    }

    System.out.println(number);
}

// Метод выведет в консоль наибольшее meaning из массива
private void printMaxInArray(int[] array) {
    if (array == null || array.length == 0) {
        /*
         Если массив пуст, метод завершит свою работу.
         Иногда полезно проверять подобным образом аргументы метода вначале и прерывать выполнение метода, если аргументы не подходят для дальнейшей корректной работы
        */
        System.out.println("Empty array");
        return;
    }

    int max = array[1];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    System.out.println(max);
}

라벨

break및 연산자를 살펴보기 전에 continueJava의 레이블에 대해 이야기하고 싶습니다. 일부 상황에서는 break및 연산자가 continue레이블과 함께 사용되기 때문에 이는 중요합니다. 하지만 먼저 이 코드가 컴파일되는지 여부에 대한 질문에 답해 보세요.

public static void main(String[] args) {
    https://www.google.com/
    System.out.println("Interesting...");
}

레이블은 명명된 코드 조각입니다. 레이블 자체는 어떤 기능도 제공하지 않습니다. 이는 프로그래머가 나중에 사용하려는 코드의 북마크와 같은 것입니다. 코드의 레이블은 이름과 콜론을 통해 매우 간단하게 정의됩니다. 예를 들어:

• labelName:
• outerLoop:
• printing:
• anyWordYouLike:

Java 코드 내부의 레이블은 다음과 같습니다.

public static void main(String[] args) {
    definePrintName:
    System.out.println("Таблица Умножения");

    loop1:
    for (int i = 1; i <= 10; i++) {
        loop2:
        for (int j = 1; j <= 10; j++) {
            System.out.printf("%4d", i * j);
        }
        System.out.println();
    }
}

메서드의 출력은 main다음과 같습니다.

Таблица Умножения
   1   2   3   4   5   6   7   8   9   10
   2   4   6   8   10  12  14  16  18  20
   3   6   9   12  15  18  21  24  27  30
   4   8   12  16  20  24  28  32  36  40
   5   10  15  20  25  30  35  40  45  50
   6   12  18  24  30  36  42  48  54  60
   7   14  21  28  35  42  49  56  63  70
   8   16  24  32  40  48  56  64  72  80
   9   18  27  36  45  54  63  72  81  90
  10  20  30  40  50  60  70  80  90  100

Process finished with exit code 0

위의 예에서 definePrintName및 loop1:는 loop2:라벨입니다. 외부 및 내부의 두주기를 "표시"합니다 loop1:. loop2:아래 섹션에서 라벨을 사용하는 방법을 살펴보겠습니다. 그동안 이 코드가 컴파일될지 여부에 대한 질문에 "아니요"라고 대답했다면 다음과 같습니다.

public static void main(String[] args) {
      https://www.google.com/
      System.out.println("Interesting...");
  }

IDE를 사용하여 다시 응답해 보세요.

부서지다

연산자는 break두 가지 경우에 사용됩니다.

1. 스위치 케이스 블록의 실행 분기를 완료합니다.
2. 루프 실행을 중단합니다.

연산자에는 표시(라벨)가 있는 것과 없는 것의 두 가지 형태가 있습니다. 두 형식의 구문은 다음과 같습니다.

break labelName; // Синтаксис оператора с меткой
break; // Синтаксис оператора без метки

스위치 케이스 블록에서는 연산자가 break레이블 없이 사용됩니다.

public static void main(String[] args) {
    int dayOfWeekInt = 4;
    String dayOfWeek;
    switch (dayOfWeekInt) {
        case 1:
            dayOfWeek = "Monday";
            break;
        case 2:
            dayOfWeek = "Tuesday";
            break;
        case 3:
            dayOfWeek = "Wednesday";
            break;
        case 4:
            dayOfWeek = "Thursday";
            break;
        case 5:
            dayOfWeek = "Friday";
            break;
        case 6:
            dayOfWeek = "Saturday";
            break;
        case 7:
            dayOfWeek = "Sunday";
            break;
        default:
            dayOfWeek = "Неизвестный день";
            break;
    }

    System.out.println("Сегодня " + dayOfWeek);
}

루프에서는 특정 조건이 충족된 후 추가 반복을 중단하는 데 명령문이 break사용됩니다. 이는 배열 또는 요소 컬렉션을 반복하고 필요한 조건을 충족하는 일부 요소를 찾아야 할 때 종종 찾을 수 있습니다. 이 예를 고려해 봅시다. 배열이 있고 배열에 음수 요소가 포함되어 있는지 확인해야 합니다.

int a[] = {1,2,234,-123,12,-2,312,0,412,433};
boolean arrayHasNegativeElements = false;

for (int i = 0; i < a.length; i++) {
   if (a[i] < 0) {
       /*
        Как только найдется
        хотя бы один отрицательный элемент,
        мы прервем цикл с помощью
        оператора break, потому что
        мы выяснor то, что нас интересовало,
        и дальнейший перебор элементов не имеет смысла.
        */
       arrayHasNegativeElements = true;
       break;
   }
}

다른 루프를 사용하여 동일한 예를 살펴보겠습니다. 주기 for-each:

public static void main(String[] args) {
    int a[] = {1,2,234,-123,12,-2,312,0,412,433};
    boolean arrayHasNegativeElements = false;

    for (int number : a) {
        if (number < 0) {
            arrayHasNegativeElements = true;
            break;
        }
    }
}

주기 while:

public static void main(String[] args) {
    int a[] = {1,2,234,-123,12,-2,312,0,412,433};
    boolean arrayHasNegativeElements = false;

    int counter = 0;
    while (counter < a.length) {
        if (a[counter] < 0) {
            arrayHasNegativeElements = true;
            break;
        }
        counter ++;
    }
}

주기 do-while:

public static void main(String[] args) {
    int a[] = {1,2,234,-123,12,-2,312,0,412,433};
    boolean arrayHasNegativeElements = false;

    int counter = 0;
    do {
        if (a[counter] < 0) {
            arrayHasNegativeElements = true;
            break;
        }
        counter ++;
    } while (counter < a.length);
}

루프 문에 대한 또 다른 예는 break특정 조건이 충족될 때 무한 루프를 중단하는 것입니다. 다음은 사용자가 "stop"이라는 단어를 입력할 때까지 사용자가 입력한 줄을 표시하는 프로그램의 예입니다.

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String line;

    while (true) {
        line = scanner.nextLine();
        if ("stop".equals(line)){
            /*
             Прерываем бесконечный цикл,
             при достижении
             определенного условия
             */
            break;
        }
        System.out.println("Пользователь ввел: " + line);
    }
}

break연산자를 레이블과 함께 사용하는 것을 고려해 보겠습니다 . 레이블이 있는 인터럽트는 여러 사이클이 있고 하나가 다른 사이클 내에 중첩된 경우에 사용됩니다. 이 경우 주기 중 하나(또는 모든 주기)에 라벨이 표시됩니다. 다음으로 작업자는 break라벨 표시와 함께 원하는 사이클을 중단합니다. 음수 요소가 있지만 배열이 아닌 행렬에 있는지 이해해야 하는 예를 고려해 보겠습니다.

public static void main(String[] args) {
   int[][] a = {
           {1, 2, 3},
           {-412, 12, 0},
           {1223, 474, -54}
   };

   boolean hasNegative = false;

   searchNegative:
       for (int i = 0; i < a.length; i++) {
           for (int j = 0; j < a[i].length; j++) {
               if (a[i][j] < 0) {
                   /*
                       Если использовать break без метки,
                       тогда прервется вложенный цикл for,
                       но внешний продолжит выполнять свои итерации
                       и поиск продолжится.

                       Поэтому мы "помечаем" внешний цикл меткой `searchNegative`
                       и прерываем внешний цикл оператором break совместно с нужной меткой.
                    */
                   hasNegative = true;
                   break searchNegative;
               }
           }
       }
}

연속성

연산자에는 continue레이블이 있는 형식과 없는 형식의 두 가지 형식도 있습니다.

continue; // форма оператора без метки
continue labelName; // форма оператора с меткой

break루프의 나머지 모든 반복을 중단하는 연산자와 달리 연산자는 continue현재 반복을 중단하고 다음 반복이 시작되도록 합니다. 이는 특정 조건을 만족하는 요소에 대해 일부 작업을 수행해야 하는 경우 유용할 수 있습니다. 문자열이 있고 문자 "m"으로 시작하는 단어 수를 세고 싶다고 가정해 보겠습니다.

public static void main(String[] args) {
    String sentence = "Мама мыла раму";
    String[] words = sentence.split(" ");

    int mWordsCount = 0;

    for (int i = 0; i < words.length; i++) {
        if ( ! words[i].toLowerCase().startsWith("м")) {
            /*
             Если слово не начинается с буквы м,
             то текущая итерация прервется и цикл
             ПРОДОЛЖИТ выполнение со следующей итерации
             */
            continue;
        }

        mWordsCount ++;
    }

    System.out.println("Кол-во слов, начинающихся с буквы М в предложении: " + "[" + sentence + "] = " + mWordsCount);
}

이 코드를 실행하면 콘솔에 다음과 같은 출력이 표시됩니다.

Кол-во слов, начинающихся с буквы М в предложении: [Мама мыла раму] = 2

continue레이블과 함께 연산자는 요소를 반복할 때도 사용됩니다. 음수 요소가 있는 행 수를 계산해야 하는 행렬을 상상해 보겠습니다.

public static void main(String[] args) {
    int[][] a = {
            {1, 23, -1, 23, -12},
            {21, 21, 0, 23, 123, 45},
            {123, 3},
            {123, -5, 4, -3},
            {-1, -2, -3}
    };

    int rowsWithNegativeElementsCount = 0;

    rowsLoop:
    // Проходим по каждой строке
        for (int[] arr : a) {
            for (int number : arr) {
                if (number < 0) {
                    /*
                     Если в текущей строке найдется
                     хотя бы 1 отрицательный элемент,
                     тогда мы увеличим переменную счетчик,
                     и с помощью оператора continue rowsLoop
                     прервем текущую итерацию внешнего цикла и
                     принудительно начнем следующую
                     */
                    rowsWithNegativeElementsCount ++;
                    continue rowsLoop;
                }
            }
        }

    System.out.println("Rows With Negative Elements Count = " + rowsWithNegativeElementsCount);
}

이 코드의 출력은 다음과 같습니다.

Rows With Negative Elements Count = 3

동일한 기능을 달성하기 위해 연산자 break, continue및 를 다양한 방법으로 사용할 수 있다는 점은 주목할 가치가 있습니다. return따라서 마지막 예제를 다시 작성하고 다음을 continue사용할 수 있습니다 break.

public static void main(String[] args) {
    int[][] a = {
            {1, 23, -1, 23, -12},
            {21, 21, 0, 23, 123, 45},
            {123, 3},
            {123, -5, 4, -3},
            {-1, -2, -3}
    };

    int rowsWithNegativeElementsCount = 0;

    for (int[] arr : a) {
        for (int number : arr) {
            if (number < 0) {
                rowsWithNegativeElementsCount ++;
                break;
            }
        }
    }

    System.out.println("Rows With Negative Elements Count = " + rowsWithNegativeElementsCount);
}

레이블 break과 레이블의 차이점은 레이블이 작성된 루프의 반복을 완료하는 것입니다. 그리고 레이블을 사용하면 레이블이 표시된 주기의 현재 반복을 건너뜁니다. 어떤 상황에서는 하나를 다른 것으로 교체할 수 있으며 프로그램 기능의 모든 것이 동일하게 유지됩니다. 아래에서 최선의 선택(스포일러: 코드 가독성)에 대해 이야기하겠습니다. 연산자는 with 레이블뿐만 아니라 로도 대체될 수 있습니다 . 이 직전에 중첩 루프를 별도의 메서드로 이동해야 합니다. continuebreakcontinuebreakcontinuereturn

public static void main(String[] args) {
    int[][] a = {
            {1, 23, -1, 23, -12},
            {21, 21, 0, 23, 123, 45},
            {123, 3},
            {123, -5, 4, -3},
            {-1, -2, -3}
    };

    int rowsWithNegativeElementsCount = 0;

    for (int[] arr : a) {
        if (arrayHasNegativeElements(arr)) {
            rowsWithNegativeElementsCount ++;
        }
    }

    System.out.println("Rows With Negative Elements Count = " + rowsWithNegativeElementsCount);
}

static boolean arrayHasNegativeElements(int[] array) {
    for (int number : array) {
        if (number < 0) {
            return true;
        }
    }

    return false;
}

같은 것을 쓰는 방법은 다양합니다. 어느 것을 선택할까요? 산업용 프로그래밍에서는 코드 이해의 용이성에 따라 이 문제가 결정됩니다. 간단하게 작성할수록 좋습니다. 중첩된 루프가 많을수록 코드를 인식하기가 더 어려워집니다. 특히 루프가 인터럽트 및 연속( break및 continue)에 사용되는 다른 표시로 표시되는 경우. 태그를 사용하지 않는 것이 가능하다면 사용하는 것이 좋습니다. 그렇지 않으면 가능한 한 명확하고 아름답게 쓰도록 노력하십시오.

이동

일부 프로그래밍 언어에는 연산자가 있습니다 goto. 일반적으로 코드 실행을 레이블이 표시된 프로그램의 일부 부분으로 리디렉션합니다. 하지만 Java에서는 ' goto그렇다', '그렇지 않다'라고 말할 수도 있습니다. 그것을 알아 봅시다. Java의 키워드 목록에는 단어가 포함됩니다 goto. 그러나 이 명령문은 사용되지 않은 것으로 표시됩니다. 사실 Java 언어의 창시자인 James Gosling은 처음에 JVM에 연산자 지원을 포함시켰습니다 goto. 그러나 이 기능은 나중에 삭제되었습니다. 그 이유 중 하나는 연산자가 포함된 코드 블록이 동일한 기능을 수행했지만 , 없이 대체 접근 방식( , 메서드에 코드 블록 배치)을 수행한 goto코드 블록만큼 읽기가 어려웠기 때문입니다 . 실제로 다음과 같은 것들도 있었습니다.gotobreakcontinue

• 연산자가 포함된 코드를 읽고 이해하는 데 어려움이 있습니다 goto.
• 컴파일러에 대한 코드 최적화가 복잡해지고 때로는 불가능하기도 합니다.
• 코드에 미묘한 오류가 발생할 가능성이 높아집니다.

일부 프로그래밍 언어에서는 연산자가 매우 성공적으로 작동한다는 것은 많은 사람들에게 비밀이 아닙니다 goto. 그러나 프로그래머는 이를 사용하지 않습니다. Habré에 관한 한 기사에서 그 이유를 읽을 수 있습니다 . goto그런데 왜 예약어 목록에 남겨두나요 ? 간단합니다. 미래를 위한 것입니다. 예를 들어 전 세계 개발자의 Java 코드에서 변수, 메서드 또는 클래스가 호출되는 goto경우 이 명령문이 향후 Java 버전에서 반환되면 이전 코드가 모두 손상됩니다. 이러한 시나리오를 방지하기 위해 gotoJava 키워드 목록에 남아 있지만 어떤 기능도 수행하지 않습니다. 아마도 언젠가 goto그는 우리 대열로 돌아올 것이지만 그럴 가능성은 낮습니다.

결과

우리는 Java의 다양한 점프 연산자를 살펴보았습니다:

1. return— 메소드 완료, 메소드에서 값 반환.
   • 반환 값 포함: 값을 반환하는 메서드
   • 반환 값 없음: void메서드.
2. break- 사이클 중단, 스위치 케이스 블록.
   • 태그 있음: 다양한 중첩 주기;
   • 라벨 없음: 블록의 스위치 케이스 분기; 호출된 루프를 중단합니다.
3. continue.
   • 태그 있음: 다양한 중첩 주기;
   • 레이블 없음: 호출된 루프의 연속입니다.
4. goto.
   • 키워드 목록에 있지만 사용되지 않습니다.

이 모든 것의 결론은 간단합니다. 코드를 더 쉽게 읽을 수 있도록 가장 간단한 접근 방식을 선호하는 것이 좋습니다. 풍부한 표시, 중단 및 연속으로 서로 중첩된 다중 레벨 루프로 코드를 오버로드하지 마십시오.