java 写个路径规划

好的，你需要一个简单的路径规划算法，还是需要一个比较复杂的算法？一般来说，路径规划算法可以分为两类，一类是基于图的搜索算法，如Dijkstra、A*等；另一类是基于规则的算法，如反向链接、前向星等。你可以根据具体的需求选择最适合你的算法。

如果你需要一个简单的路径规划算法，我可以给你一个基于A*算法的实现示例，代码如下：

import java.util.*;

public class AStarAlgorithm {

    public static void main(String[] args) {
        int[][] map = new int[][]{
                {0, 1, 0, 0, 0, 0},
                {0, 0, 1, 0, 0, 0},
                {0, 0, 0, 1, 0, 0},
                {0, 0, 0, 0, 1, 0},
                {0, 0, 0, 0, 0, 1},
                {1, 0, 0, 0, 0, 0}
        };
        int start = 0;
        int end = 5;
        List<Integer> path = aStar(map, start, end);
        System.out.println("The path from " + start + " to " + end + " is: " + path);
    }

    public static List<Integer> aStar(int[][] map, int start, int end) {
        List<Integer> path = new ArrayList<>();
        PriorityQueue<Node> openList = new PriorityQueue<>();
        Set<Integer> closeList = new HashSet<>();
        openList.offer(new Node(start, 0, getHeuristic(start, end)));
        while (!openList.isEmpty()) {
            Node currentNode = openList.poll();
            if (currentNode.id == end) {
                while (currentNode != null) {
                    path.add(currentNode.id);
                    currentNode = currentNode.parent;
                }
                Collections.reverse(path);
                return path;
            }
            closeList.add(currentNode.id);
            for (int i = 0; i < map.length; i++) {
                if (map[currentNode.id][i] == 1 && !closeList.contains(i)) {
                    Node successor = new Node(i, currentNode.g + 1, getHeuristic(i, end));
                    successor.parent = currentNode;
                    if (openList.contains(successor)) {
                        Iterator<Node> it = openList.iterator();
                        while (it.hasNext()) {
                            Node node = it.next();
                            if (node.equals(successor) && node.g > successor.g) {
                                it.remove();
                                break;
                            }
                        }
                    }
                    openList.offer(successor);
                }
            }
        }
        return path;
    }

    public static int getHeuristic(int start, int end) {
        return Math.abs(start - end);
    }

    static class Node implements Comparable<Node> {

        int id;
        int g;
        int h;
        Node parent;

        public Node(int id, int g, int h) {
            this.id = id;
            this.g = g;
            this.h = h;
        }

        @Override
        public int compareTo(Node o) {
            return Integer.compare(this.g + this.h, o.g + o.h);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node node = (Node) o;
            return id == node.id;
        }

        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
    }
}

这个示例使用了一个6x6的二维数组来表示地图，其中1表示两个节点之间存在通路，0表示两个节点之间没有通路。你可以根据实际情况修改这个地图。在代码中，我们定义了一个`Node`类来表示每个节点，其中`id`表示节点的编号，`g`表示从起点到达该节点的实际代价，`h`表示从该节点到达终点的估计代价，`parent`表示该节点的父节点。我们使用`PriorityQueue`来存储待处理的节点，根据f值（g+h）的大小进行排序，每次取出f值最小的节点进行处理。我们使用`HashSet`来存储已经处理过的节点，避免重复处理。在处理每个节点时，我们遍历它的所有邻居节点，如果该邻居节点没有被处理过，则将其加入到待处理列表中，并计算其f值。如果该邻居节点已经在待处理列表中，且新的路径代价更小，则将其更新。最终，当我们处理到终点节点时，我们可以通过回溯每个节点的父节点，从而得到一条从起点到终点的路径。

希望这个示例对你有所帮助！