Java에서 함수를 사용하여 2차원 배열을 탐색하는 방법은 무엇입니까?

머리말

배열 순회에 대해서는 기본적으로 모든 개발자가 이에 대해 작성했습니다. 순회 자체에 대해서는 별로 할 말이 없지만 순회 프로세스 중에 복잡한 비즈니스 로직이 있을 때 코드 수준을 알 수 있습니다.

예를 들어 간단한 경우에는 2차원 배열에서 짝수를 찾아 리스트에 저장합니다.

2차원 배열을 순회하여 각 요소가 짝수인지 판단합니다. 예:

public void getEven() {
    int[][] cells = new int[][]{{1, 2, 3, 4}, {11, 12, 13, 14}, {21, 22, 23, 24}};
    List<Integer> ans = new ArrayList<>();
    for (int i = 0; i < cells.length; i ++) {
        for (int j = 0; j < cells[0].length; j++) {
            if ((cells[i][j] & 1) == 0) {
                ans.add(cells[i][j]);
            }
        }
    }
    System.out.println(ans);
}

위의 구현에는 아무런 문제가 없지만 위의 경우에 다른 판단 조건이 있는 경우 이 코드의 깊이는 쉽게 세 가지 수준에 도달할 수 있습니다. 쉽게 증가할 수 있습니다. 3차원 배열인 경우 한 번의 순회는 약간의 논리를 사용하면 4~5단계가 몇 분이면 되지 않습니까? , 코드 레벨이 증가하면 어떤 문제가 발생합니까?

코드가 실행될 수 있다면 무엇이 문제일까요? !

1. 함수 메서드로 코드 수준 감소

다차원 배열의 순회 수준은 본질적으로 매우 깊기 때문에 이를 줄일 수 있는 방법이 있습니까?

이 문제를 해결하려면 핵심 포인트를 파악하는 것이 핵심입니다. 각 요소의 좌표를 얻으세요! 그래서 우리가 뭘 할 수 있지?

함수 메서드를 정의합니다. 입력은 함수 좌표이고 이 함수 본문에서 순회 논리를 실행합니다.

위 아이디어를 바탕으로 2차원 배열 순회 일반 메서드를 쉽게 작성할 수 있다고 믿습니다

public static void scan(int maxX, int maxY, BiConsumer<Integer, Integer> consumer) {
    for (int i = 0; i < maxX; i++) {
        for (int j = 0; j < maxY; j++) {
            consumer.accept(i, j);
        }
    }
}

주로 위 구현에서 함수 메서드는 기본적으로 JDK에서 제공하는 BiConsumer를 직접 사용합니다. 아래 표와 같이 두 매개 변수는 반환 값이 없습니다.

그렇다면 위를 어떻게 사용할까요?

위의 예도 마찬가지입니다. 변경한 후의 모습은 다음과 같습니다.

public void getEven() {
    int[][] cells = new int[][]{{1, 2, 3, 4}, {11, 12, 13, 14}, {21, 22, 23, 24}};
    List<Integer> ans = new ArrayList<>();
    scan(cells.length, cells[0].length, (i, j) -> {
        if ((cells[i][j] & 1) == 0) {
            ans.add(cells[i][j]);
        }
    });
    System.out.println(ans);
}

이전과 비교하면 레이어가 하나 줄어든 것 같고 별 문제는 아닌 것 같습니다.

그러나 배열이 3차원 또는 4차원이 되면 차원이 없을 때 이 변경의 쓰기 수준은 변경되지 않습니다.

2. 순회 중 반환 지원

이전 구현에서는 일반 순회에 문제가 없습니다. 하지만 순회 프로세스 중에 특정 조건이 발생하면 직접 Return할 수 있습니다. 지원할 수 있나요?

예를 들어, 2차원 배열을 탐색하고 그 안에 짝수가 있는지 확인하려는 경우 어떻게 반올림할 수 있나요?

귀환을 지원하기 위해 스캔 방법을 신중하게 생각해 보세요. 주요 문제는 함수 메서드가 실행된 후 계속 반복할지 아니면 직접 반환할지 어떻게 알 수 있다는 것입니다.

실행에 추가하는 것을 생각하기 쉽습니다. logic 루프를 중단하고 직접 반환할지 여부를 표시하기 위해 추가 반환 값이 사용됩니다

이 아이디어를 기반으로 간단한 데모 버전을 구현할 수 있습니다

루프의 첨자 + 반환 값을 허용하는 함수 메서드 정의

@FunctionalInterface
public interface ScanProcess<T> {
    ImmutablePair<Boolean, T> accept(int i, int j);
}

일반적인 루프 방법은 그에 따라 변경될 수 있습니다.

public static <T> T scanReturn(int x, int y, ScanProcess<T> func) {
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            ImmutablePair<Boolean, T> ans = func.accept(i, j);
            if (ans != null && ans.left) {
                return ans.right;
            }
        }
    }
    return null;
}

위 아이디어를 기반으로 실제 사용 자세는 다음과 같습니다.

@Test
public void getEven() {
    int[][] cells = new int[][]{{1, 2, 3, 4}, {11, 12, 13, 14}, {21, 22, 23, 24}};
    List<Integer> ans = new ArrayList<>();
    scanReturn(cells.length, cells[0].length, (i, j) -> {
        if ((cells[i][j] & 1) == 0) {
            return ImmutablePair.of(true, i + "_" + j);
        }
        return ImmutablePair.of(false, null);
    });
    System.out.println(ans);
}

위 구현은 우리의 요구를 충족할 수 있습니다. 항상 좀 어색하네요. 너무 우아해서 이 방법 외에는 다른 방법이 없나요?

이제 반환 값이 고려되었으므로 매개변수 전달은 어떻게 되나요? 정의된 매개변수를 사용하여 중단 여부를 결정하고 결과를 반환하는 것이 가능합니까?

이 아이디어를 바탕으로 먼저 매개변수 패키징 클래스를 정의할 수 있습니다.

public static class Ans<T> {
    private T ans;
    private boolean tag = false;

    public Ans<T> setAns(T ans) {
        tag = true;
        this.ans = ans;
        return this;
    }

    public T getAns() {
        return ans;
    }
}

public interface ScanFunc<T> {
    void accept(int i, int j, Ans<T> ans)
}

Ans 클래스를 통해 루프 결과를 기록하기를 바랍니다. 여기서 tag=true는 루프를 계속하고 직접 반환할 필요가 없음을 의미합니다. ans 결과

해당 ​​메서드 수정 및 예는 다음과 같습니다.

public static <T> T scanReturn(int x, int y, ScanFunc<T> func) {
    Ans<T> ans = new Ans<>();
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            func.accept(i, j, ans);
            if (ans.tag) {
                return ans.ans;
            }
        }
    }
    return null;
}
public void getEven() {
    int[][] cells = new int[][]{{1, 2, 3, 4}, {11, 12, 13, 14}, {21, 22, 23, 24}};
    String ans = scanReturn(cells.length, cells[0].length, (i, j, a) -> {
        if ((cells[i][j] & 1) == 0) {
            a.setAns(i + "_" + j);
        }
    });
    System.out.println(ans);
}

이전보다 좋아 보입니다

실제로 실행하여 출력이 우리의 기대와 일치하는지 확인합니다.

위 내용은 Java에서 함수를 사용하여 2차원 배열을 탐색하는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!