2024.04.09团队开发完成

完成了团队地铁查询系统的开发，以下是部分代码展示

package subway;

import java.io.*;
import java.util.Scanner;

public class AddLine {
public void login() {
String password;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入管理员登录密码：");
password = scanner.nextLine();
if (password.equals("123")) {
try {
addLine();
} catch (IOException e) {
e.printStackTrace();
}
}
}

public void addLine() throws IOException {
String f = "subway.txt";
Scanner scanner = new Scanner(System.in);

String line;
String lineName;
System.out.println("请输入线路名称:");
lineName = scanner.nextLine();
FileReader fileReader = new FileReader(f);
BufferedReader bufferedReader = new BufferedReader(fileReader);
//判断该线路名称是否已存在
boolean isexist = false;
while ((line = bufferedReader.readLine()) != null) {
if (line.contains(lineName)) {
isexist = true;
break;
}
}
if (!isexist)
inputtxt("\n" + lineName + "/");
else {
System.out.println("输入的线路名已存在，请重新输入");
addLine();
}
System.out.println("请输入该线路的票价:");
inputtxt(scanner.nextLine() + "%");
System.out.println("请输入该线路的首班时间:");
inputtxt(scanner.nextLine() + "%");
System.out.println("请输入该线路的末班时间:");
inputtxt(scanner.nextLine() + "- ");

boolean flag = true;
int i = 1;
while (flag) {
System.out.println("请输入该线路第" + i + "个站点名称：");
i++;
String stationName;
stationName = scanner.nextLine();
lineName = delete(lineName);
System.out.println("请输入" + stationName + "是否可以换乘，若可换乘则输入Y，不能则输入N。");
if (scanner.nextLine().equals("Y")) {
String oldTransfer = " "+stationName+addTransferStation(stationName, lineName);
inputtxt(oldTransfer);
}
else {
inputtxt(" #"+stationName);
}
System.out.println("是否继续输入站点？Y：N");
if (scanner.nextLine().equals("N")) {
flag = false;
}
}
}

public String addTransferStation(String stationName, String lineName) throws IOException {
String f = "subway.txt";
FileReader fileReader = new FileReader(f);
BufferedReader bufferedReader = new BufferedReader(fileReader);

String line;
String new_subaway = "";
String oldTransfer = "";
// 用 new_subway 重新编写subway.txt文件
while ((line = bufferedReader.readLine()) != null) {
if (line.contains(stationName)) {

String[] tokens = line.split(stationName);
String[] tokens1 = tokens[0].split("/", 2);
oldTransfer += "#"+tokens1[0];
String Line;
if (tokens.length > 1) {
Line = tokens[0] + stationName + "#" + lineName + tokens[1];
/*String[] tokens1 = tokens[1].split(" ", 2);

if (tokens1.length > 1) {
String[] tokens2 = tokens[0].split("/",2);
String atLineName = tokens2[0];
Line = tokens[0] + stationName + tokens1[0] + "#" +lineName + " " + tokens1[1];
oldtransfer += tokens2[0];
}
else {
String[] tokens2 = tokens[0].split("/",2);
String atLineName = tokens2[0];
oldtransfer = tokens2[0];
Line = tokens[0] + stationName + tokens1[0] + "#" +lineName;
}*/

} else {
Line = tokens[0] + stationName + "#" + lineName;
}
new_subaway += Line + "\n";
} else {
new_subaway += line + "\n";
}
}
new_subaway = new_subaway.substring(0,new_subaway.length()-2);

File file = new File(f);
Writer writer = new FileWriter(file);
writer.write(new_subaway);
writer.flush();
writer.close();
return delete(oldTransfer);
}

public String delete(String lineName) {
String newLineName = "";
for (int i = 0; i < lineName.length(); ++i) {
if ((lineName.charAt(i) != '号') && (lineName.charAt(i) != '线')) {
newLineName += lineName.charAt(i);
}
}
return newLineName;
}
public void inputtxt(String string) throws IOException{
String f = "subway.txt";
File file = new File(f);
FileOutputStream fos = new FileOutputStream(file, true);
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
osw.write(string);
osw.flush();
fos.flush();
fos.close();
osw.close();
}
}

复制代码
package subway;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;

public class Dijkstra {
    // 最短路径集合
    private static HashMap<Station, Result> shortestPath = new HashMap<>();
    // 已经分析过的站点集合
    private static List<Station> visitedStations = new ArrayList<>();

    public static Result calculate(Station startStation, Station endStation) {
        // 第一次使用calculate方法时将起点站添加到已分析集合里去
        if (!visitedStations.contains(startStation)) {
            visitedStations.add(startStation);
        }
        // 如果起点站和终点站相同，则返回经过0站
        if (startStation.equals(endStation)) {
            Result result = new Result();
            result.setDistance(0);
            result.setStartStation(startStation);
            result.setEndStation(startStation);
            return shortestPath.put(startStation, result);
        }
        // 第一次使用calculate方法时shortestPath集合才为空，此时将起点站的临近站点全加入到shortestPath集合
        if (shortestPath.isEmpty()) {
            List<Station> linkStations = getLinkStations(startStation);
            for (Station s : linkStations) {
                Result result = new Result();
                result.setStartStation(startStation);
                result.setEndStation(s);
                result.setDistance(1);
                result.getPassStations().add(s);
                shortestPath.put(s, result);
            }
        }
        // 获取下一个最佳站点
        Station nextStation = getNextStation();
        if (nextStation == null) {
            System.out.println("这种情况绝对不可能出现！");
        }
        // 最佳站点是终点站的时候，代表最短路径已经搞定了
        if (nextStation.equals(endStation)) {
            return shortestPath.get(nextStation);
        }
        // 获取最佳站点的临近站点，并将最佳站点加入到shortestPath集合里，更新最短路径
        List<Station> nextStationLinkStations = getLinkStations(nextStation);
        for (Station linkStation : nextStationLinkStations) {
            if (visitedStations.contains(linkStation)) {
                continue;
            }
            // 因为在原路径上加入最佳站点，所以距离+1
            int distance = shortestPath.get(nextStation).getDistance() + 1;
            // 获取最佳点经过的站点
            List<Station> nextStationPassStations = shortestPath.get(nextStation).getPassStations();
            Result linkStationResult = shortestPath.get(linkStation);
            // linkStationResult非空的意思是，现最短路径中有最佳点的邻接站点
            // 举个例子：现最短路径为：startStation->...->linkStation
            if (linkStationResult != null) {
                // 接上例子，startStation->...->linkStation这条路径长度为9，startStation->...->nextStation的长度为7
                // 则更新最短路径:startStation->...->nextStation->linkStation
                if (linkStationResult.getDistance() > distance) {
                    linkStationResult.setDistance(distance);
                    linkStationResult.getPassStations().clear();
                    linkStationResult.getPassStations().addAll(nextStationPassStations);
                    linkStationResult.getPassStations().add(linkStation);
                }
            }
            // 如果最近路径中无最佳站点的临近站点，则把最近站点添加到最短路径中。startStation->...->nextStation
            else {
                linkStationResult = new Result();
                linkStationResult.setDistance(distance);
                linkStationResult.setStartStation(startStation);
                linkStationResult.setEndStation(linkStation);
                linkStationResult.getPassStations().addAll(nextStationPassStations);
                linkStationResult.getPassStations().add(linkStation);
            }
            shortestPath.put(linkStation, linkStationResult);
        }
        // 将最佳点添加到已分析的集合中
        visitedStations.add(nextStation);
        return calculate(startStation, endStation);
    }

    // 获取所有的邻接站点
    public static List<Station> getLinkStations(Station station) {
        List<Station> linkStations = new ArrayList<>();

        for (SubwayLine line : GetInfo.lines) {
            for (int i = 0; i < line.stations.size(); i++) {
                if (station.equals(line.stations.get(i))) {
                    if (i == 0) //i=0的时候是总站，若想最短路径不要经过总站，改为i==1即可
                        linkStations.add(line.stations.get(i + 1));
                    else if (i == (line.stations.size() - 1))
                        linkStations.add(line.stations.get(i - 1));
                    else {
                        linkStations.add(line.stations.get(i - 1));
                        linkStations.add(line.stations.get(i + 1));
                    }
                }
            }
        }
        return linkStations;
    }
复制代码
package subway;

import java.io.*;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

public class GetInfo {
    // 存储线路上的站点信息
    public static List<SubwayLine> lines = new ArrayList<>();
    // 存储相邻站点
    public static List<Station> stations = new ArrayList<>();

    // 解析 subway.txt 获取地铁图信息
    public static void subwayMap() {
        String f = "subway.txt";
        try (
                // FileReader用于读取文件字符流
                FileReader r = new FileReader(f);
                // BufferedReader类从字符输入流中读取文本并缓冲字符
                BufferedReader br = new BufferedReader(r);
        ) {
            String line;
            // 分离每一条线路
            while((line = br.readLine()) != null) {
                // 分离线路名称
                String[] tokens = line.split("/",2);
                SubwayLine s1 =  new SubwayLine();
                // tokens[0]是线路名称
                s1.name = tokens[0];
                // 分离票价
                String[] tokens1 = tokens[1].split("%",2);
                s1.fare = Double.parseDouble(tokens1[0]);
                // 分离首末班时间
                String[] ftime = tokens1[1].split("%",2);
                s1.FirstTime = s1.simpleDateFormat.parse(ftime[0]);
                String[] ltime = ftime[1].split("-",2);
                s1.LastTime = s1.simpleDateFormat.parse(ltime[0]);
                // 分离各个站点
                String[] tokens2 = ltime[1].split(" ");
                // forEach循环，字符串s每次获取一个站点信息
                for(String s: tokens2) {
                    Station station = new Station();
                    // 判断该站点是否可换乘
                    boolean isTransfer = s.contains("#");
                    if(isTransfer) {
                        station.isTransferStation = true;
                        // 分离换乘站信息
                        String[] tokens3 = s.split("#");
                        station.name = tokens3[0];
                        // 解析该站点可换成的线路
                        for(int i = 1; i < tokens3.length; i++) {
                                if(tokens3[i].equals("1"))
                                    station.lines.add("1号线");
                                else if(tokens3[i].equals("2"))
                                    station.lines.add("2号线");
                                else if(tokens3[i].equals("4"))
                                    station.lines.add("4号线");
                                else if(tokens3[i].equals("5"))
                                    station.lines.add("5号线");
                                else if(tokens3[i].equals("6"))
                                    station.lines.add("6号线");
                                else if(tokens3[i].equals("7"))
                                    station.lines.add("7号线");
                                else if(tokens3[i].equals("8北"))
                                    station.lines.add("8号线北");
                                else if(tokens3[i].equals("8南"))
                                    station.lines.add("8号线南");
                                else if(tokens3[i].equals("9"))
                                    station.lines.add("9号线");
                                else if(tokens3[i].equals("10"))
                                    station.lines.add("10号线");
                                else if(tokens3[i].equals("13"))
                                    station.lines.add("13号线");
                                else if(tokens3[i].equals("14西"))
                                    station.lines.add("14号线西");
                                else if(tokens3[i].equals("14东"))
                                    station.lines.add("14号线东");
                                else if(tokens3[i].equals("15"))
                                    station.lines.add("15号线");
                                else if(tokens3[i].equals("16"))
                                    station.lines.add("16号线");
                                else if(tokens3[i].equals("八通"))
                                    station.lines.add("八通线");
                                else if(tokens3[i].equals("房山"))
                                    station.lines.add("房山线");
                                else if(tokens3[i].equals("昌平"))
                                    station.lines.add("昌平线");
                                else if(tokens3[i].equals("亦庄"))
                                    station.lines.add("亦庄线");
                                else if(tokens3[i].equals("燕房"))
                                    station.lines.add("燕房线");
                                else if(tokens3[i].equals("S1"))
                                    station.lines.add("S1线");
                                else if(tokens3[i].equals("西郊"))
                                    station.lines.add("西郊线");
                                else if(tokens3[i].equals("首都机场"))
                                    station.lines.add("首都机场线");
                            }
                        }
                        else {
                            if(s.contains("!")) {
                                continue;
                            }
                            station.isTransferStation = false;
                            station.name = s;
                        }
                    // 该站点所在线路
                    station.line = tokens[0];
                    // 添加途径站点
                    stations.add(station);
                    // 为该线路添加站点
                    s1.stations.add(station);
                    }
                lines.add(s1);
                }

            } catch (IOException | ParseException ex) {
            ex.printStackTrace();
        }
    }
    /*
    public static String getLineName(Station station) {
        for(SubwayLine s : lines) {
            for(Station st : s.stations) {
                if(st.name.equals(station.name)) {
                    return st.line;
                }
            }
        }
        return "";
    }
    */
}
复制代码


复制代码


package subway;

import java.util.Scanner;

import static java.lang.System.exit;

public class GetShortestPath {
    public void getShortPath() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入起点站名称");
        String start = scanner.nextLine(); //起点站名称
        System.out.println("请输入终点站名称");
        String end = scanner.nextLine(); //终点站名称

        boolean isStart = false;
        boolean isEnd = false;
        for (Station s : GetInfo.stations) {
            if (start.equals(s.name))
                isStart = true;
            if (end.equals(s.name))
                isEnd = true;
            if (isStart && isEnd)
                break;
        }

        if (!isStart) {
            System.out.println("起点站不存在");
            exit(0);
        }

        if (!isEnd) {
            System.out.println("终点站不存在");
            exit(0);
        }

        Result result = Dijkstra.calculate(new Station(start), new Station(end));
        String str = "共经过" + result.getPassStations().size() + 1 + "站\n";
        str += "所在线路：" + result.getPassStations().get(0).line + " " + result.getStartStation().name + "->";
        String atLineName = result.getPassStations().get(0).line;
        Boolean isTransfer = false;

        for (int i = 0; i < result.getPassStations().size(); i++) {
            if (!atLineName.equals(result.getPassStations().get(i).line)) {
                isTransfer = true;
                atLineName = result.getPassStations().get(i).line;
            } else
                isTransfer = false;
            if (result.getPassStations().get(i).name.equals(""))
                str += "总站->";
            else if (isTransfer)
                str += "换乘到" + atLineName + "线路 " + result.getPassStations().get(i).name + "->";
            else
                str += result.getPassStations().get(i).name + "->";
        }
        str = str.substring(0, str.length() - 2);
        System.out.println(str);
        Dijkstra.reset();

    }

    public static String getLineName(Station station) {
        for (SubwayLine s : GetInfo.lines) {
            for (Station st : s.stations) {
                if (st.name.equals(station.name))
                    return st.line;
            }
        }
        return "";
    }
}


复制代码


 


// 获取下一个最佳站点
    public static Station getNextStation() {
        int min = 10000;
        Station nextStation = null;
        Set<Station> stations = shortestPath.keySet();
        for (Station s : stations) {
            if (visitedStations.contains(s))
                continue;
            Result r = shortestPath.get(s);
            // 比较最短路径中没有被分析过的点，找出路径最短的站点
            if (r.getDistance() < min) {
                min = r.getDistance();
                nextStation = s;
            }
        }
        return nextStation;
    }

    public static void reset() {
        visitedStations.clear();
        shortestPath.clear();
    }
}


复制代码


 






            

            
posted @ 
 
new菜鸟 
阅读(5) 
评论(0) 
编辑 
收藏 
举报


        

        
        




    
    

    
    



    

        
    

        

            
                
                
            
        

    



    相关博文：

    

            

                ·
                4.3号团队开发
            

            

                ·
                3.1日javaweb
            

            

                ·
                地铁系统PC端代码
            

            

                ·
                三月二十日结对
            

            

                ·
                2023.3.20课后作业
            

    





    

    阅读排行：
    

 ·          全程不用写代码，我用AI程序员写了一个飞机大战
        

 ·          DeepSeek 开源周回顾「GitHub 热点速览」
        

 ·          记一次.NET内存居高不下排查解决与启示
        

 ·          MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
        

 ·          .NET10 - 预览版1新功能体验（一）
        



    

    



    



            

        


        
        

    

    

    




    

    
    








  

  
点击右上角即可分享

  微信分享提示