Here's a Java program that generates a random maze using the depth-first search algorithm and finds the shortest path from the top-left corner to the bottom-right corner using the breadth-first search algorithm:

```java
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;

public class MazeGenerator {
    private static final int WALL = 0;
    private static final int PATH = 1;
    private static final int VISITED = 2;
    private static final int[] DX = {-1, 0, 1, 0};
    private static final int[] DY = {0, 1, 0, -1};

    public static void main(String[] args) {
        int rows = 10;
        int columns = 10;
        int[][] maze = generateMaze(rows, columns);
        printMaze(maze);
        List<int[]> shortestPath = findShortestPath(maze);
        System.out.println("Shortest Path:");
        for (int[] point : shortestPath) {
            System.out.printf("(%d, %d)%n", point[0], point[1]);
        }
    }

    private static int[][] generateMaze(int rows, int columns) {
        int[][] maze = new int[rows][columns];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                maze[i][j] = WALL;
            }
        }
        Random random = new Random();
        dfs(random, maze, 1, 1);
        return maze;
    }

    private static void dfs(Random random, int[][] maze, int x, int y) {
        maze[x][y] = PATH;
        List<Integer> directions = new ArrayList<>(4);
        for (int i = 0; i < 4; i++) {
            directions.add(i);
        }
        Collections.shuffle(directions, random);
        for (int direction : directions) {
            int nx = x + DX[direction] * 2;
            int ny = y + DY[direction] * 2;
            if (isValid(maze, nx, ny)) {
                maze[nx - DX[direction]][ny - DY[direction]] = PATH;
                dfs(random, maze, nx, ny);
            }
        }
    }

    private static boolean isValid(int[][] maze, int x, int y) {
        return x >= 1 && x < maze.length - 1 && y >= 1 && y < maze[x].length - 1 && maze[x][y] == WALL;
    }

    private static void printMaze(int[][] maze) {
        for (int[] row : maze) {
            for (int cell : row) {
                System.out.print(cell == WALL ? "#" : " ");
            }
            System.out.println();
        }
    }

    private static List<int[]> findShortestPath(int[][] maze) {
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{1, 1, 0});
        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int x = current[0];
            int y = current[1];
            int distance = current[2];

            if (x == maze.length - 2 && y == maze[x].length - 2) {
                List<int[]> path = new ArrayList<>(distance + 1);
                while (current != null) {
                    path.add(0, new int[]{current[0], current[1]});
                    current = current[3] >= 0 ? maze[current[0] + DX[current[3]]][current[1] + DY[current[3]]] : null;
                }
                return path;
            }

            for (int direction = 0; direction < 4; direction++) {
                int nx = x + DX[direction];
                int ny = y + DY[direction];
                if (isValidForBfs(maze, nx, ny)) {
                    maze[nx][ny] = VISITED;
                    queue.offer(new int[]{nx, ny, distance + 1, (direction + 2) % 4});
                }
            }
        }
        return Collections.emptyList();
    }

    private static boolean isValidForBfs(int[][] maze, int x, int y) {
        return x >= 0 && x < maze.length && y >= 0 && y < maze[x].length && maze[x][y] == PATH;
    }
}
```

This program first generates a random maze using the depth-first search algorithm. Then it finds the shortest path from the top-left corner to the bottom-right corner using the breadth-first search algorithm and prints both the maze and the shortest path.

You can change the `rows` and `columns` variables in the `main` method to generate mazes of different sizes.
다음은 깊이 우선 검색 알고리즘을 사용하여 무작위 미로를 생성하고, 넓이 우선 검색 알고리즘을 사용하여 왼쪽 상단 모서리에서 오른쪽 하단 모서리까지 최단 경로를 찾는 Java 프로그램입니다:

```java
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;

public class MazeGenerator {
    private static final int WALL = 0;
    private static final int PATH = 1;
    private static final int VISITED = 2;
    private static final int[] DX = {-1, 0, 1, 0};
    private static final int[] DY = {0, 1, 0, -1};

    public static void main(String[] args) {
        int rows = 10;
        int columns = 10;
        int[][] maze = generateMaze(rows, columns);
        printMaze(maze);
        List<int[]> shortestPath = findShortestPath(maze);
        System.out.println("Shortest Path:");
        for (int[] point : shortestPath) {
            System.out.printf("(%d, %d)%n", point[0], point[1]);
        }
    }

    private static int[][] generateMaze(int rows, int columns) {
        int[][] maze = new int[rows][columns];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                maze[i][j] = WALL;
            }
        }
        Random random = new Random();
        dfs(random, maze, 1, 1);
        return maze;
    }

    private static void dfs(Random random, int[][] maze, int x, int y) {
        maze[x][y] = PATH;
        List<Integer> directions = new ArrayList<>(4);
        for (int i = 0; i < 4; i++) {
            directions.add(i);
        }
        Collections.shuffle(directions, random);
        for (int direction : directions) {
            int nx = x + DX[direction] * 2;
            int ny = y + DY[direction] * 2;
            if (isValid(maze, nx, ny)) {
                maze[nx - DX[direction]][ny - DY[direction]] = PATH;
                dfs(random, maze, nx, ny);
            }
        }
    }

    private static boolean isValid(int[][] maze, int x, int y) {
        return x >= 1 && x < maze.length - 1 && y >= 1 && y < maze[x].length - 1 && maze[x][y] == WALL;
    }

    private static void printMaze(int[][] maze) {
        for (int[] row : maze) {
            for (int cell : row) {
                System.out.print(cell == WALL ? "#" : " ");
            }
            System.out.println();
        }
    }

    private static List<int[]> findShortestPath(int[][] maze) {
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{1, 1, 0});
        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int x = current[0];
            int y = current[1];
            int distance = current[2];

            if (x == maze.length - 2 && y == maze[x].length - 2) {
                List<int[]> path = new ArrayList<>(distance + 1);
                while (current != null) {
                    path.add(0, new int[]{current[0], current[1]});
                    current = current[3] >= 0 ? maze[current[0] + DX[current[3]]][current[1] + DY[current[3]]] : null;
                }
                return path;
            }

            for (int direction = 0; direction < 4; direction++) {
                int nx = x + DX[direction];
                int ny = y + DY[direction];
                if (isValidForBfs(maze, nx, ny)) {
                    maze[nx][ny] = VISITED;
                    queue.offer(new int[]{nx, ny, distance + 1, (direction + 2) % 4});
                }
            }
        }
        return Collections.emptyList();
    }

    private static boolean isValidForBfs(int[][] maze, int x, int y) {
        return x >= 0 && x < maze.length && y >= 0 && y < maze[x].length && maze[x][y] == PATH;
    }
}
```

이 프로그램은 먼저 깊이 우선 검색 알고리즘을 사용하여 무작위 미로를 생성합니다. 그런 다음 폭 우선 검색 알고리즘을 사용하여 왼쪽 상단 모서리에서 오른쪽 하단 모서리까지 최단 경로를 찾아 미로와 최단 경로를 모두 출력합니다.

`main` 메서드에서 `rows` 및 `column` 변수를 변경하여 다양한 크기의 미로를 생성할 수 있습니다.