Java版飞机订票系统

最新推荐文章于 2024-04-06 15:50:25 发布

壹言

最新推荐文章于 2024-04-06 15:50:25 发布

阅读量7.5k

点赞数 27

分类专栏： “系统” Java 数据结构文章标签：迪克斯特拉 java 数据结构订票系统课程设计

本文链接：https://blog.csdn.net/vcx08/article/details/76336111

版权

Java 同时被 3 个专栏收录

13 篇文章 0 订阅

订阅专栏

数据结构

9 篇文章 0 订阅

订阅专栏

“系统”

8 篇文章 1 订阅

订阅专栏

数据结构课程设计题目：

【飞机订票系统】

通过此系统可以实现如下功能：

录入：可以录入航班情况（数据存储在一个数据文件中，数据结构和具体数据自定）

查询：可以查询某个航线的情况（如：输入航班号，查询起降时间、起飞抵达城市、航班票价、票价折扣、确定航班是否满仓）

订票：订票情况可以存在一个数据文件中，结构自己设定，可以订票，如果该航班已经无票，可以提供相关可选择航班

退票：可退票，退票后修改航班数据文件

基本要求：

根据以上功能说明，设计航班信息，订票信息的存储结构，设计程序完成功能；

设计分析：

1.作为数据结构课程设计，因为题目限制只能是在原有经典算法的基础上进行改造。飞机订票系统，因为涉及到查询，所以考虑利用图结构进行存储。每一个城市作为图中的一个节点，利用邻接矩阵结构进行表示图结构，两节点之间用定义的航班信息结构体进行表示。如果为NULL 则表示没有两城市之间没有航线。然后输入两城市名称后，可以利用改写后的迪克斯特拉 或者弗洛伊德算法进行查询。

2.然后作为订票系统，则应该可以预定三十日以内的飞机票。所以我建立三个文件夹，

flight_record 用来存储城市间的航班信息；

month_flight_information 用来存储三十日内每天的航班信（每日打开软件会根据flight_record文件夹中的信息进行自动更新）息；

booking_record 用来存放订票记录；

3.为方便管理使用，该系统一个登陆界面根据登陆人群不同分为两个使用界面，分别是用户界面和管理界面。用户在注册的时候，系统会先进行身份证号是否合法验证和查重，如果已经存在则让其联系管理员。如下图

图1-登陆界面

图2-注册界面

图3-管理界面

图4-用户界面

4.为了体现系统的保密性，我对用户的密码进行用MD5 算法进行加密，使后台管理人员不能够得到用户真正的密码。另外对用户的账户状态设定了两种状态，可以进行注销不能使用但不删除，还可以删除记录。

图5-用户管理界面

操作演示：

1⃣️根据出发到达城市查询航班：

2⃣️根据航班号查询航班信息

3⃣️用户订票后在用户界面查询到的订票记录

4⃣️退票操作

5⃣️退票结果（在管理员界面仍能查到）

6⃣️航班价格修改（使用正则表达式做了过滤）

等。。。。

还有很多操作例如：

航班信息数据结构：

public class HangBan {
    public String HangBanHao;     //航班号
    public double price;          //价格
    public int    seatNumber;     //座位数
    public String discount;       //折扣
    public String startTime;      //起飞时间
    public String lendTime;       //到达时间
    public long    timeLength=0;  //飞行时长
    public HangBan(String HangBanHao,double price,int seatNumber,String discount,String startTime,String lendTime){
        this.HangBanHao = HangBanHao;
        this.price = price;
        this.seatNumber = seatNumber;
        this.discount = discount; 
        this.startTime = startTime;
        this.lendTime  = lendTime;
        this.timeLength=Tool.getPlayTime(startTime, lendTime);
        //System.out.println(this.timeLength);
        
    }

部分代码：

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ytu.cx.store;

import ytu.cx.io.FileIOImp;
import ytu.cx.util.Tool;

/**
 *
 * @author changxuan
 */
public class CityNode {
    private String[] mapping;
    private HangBan[][] matrix;
    /**
     * 初始化图的顶点
     * @param vertexes  顶点数组
     */
    public CityNode(String[] vertexes){
        
        int length = vertexes.length;
        mapping = new String[length];
        matrix = new HangBan[length][length];
        for(int i = 0; i < length; i++){
            //System.out.println(vertexes[i]);
            mapping[i] = vertexes[i];
            for(int j = 0; j < length; j++){          //初始化为NULL
                matrix[i][j]=null;
                
            }
        }
        
    }
    /**
     * 添加具有具有直达航班的边
     * @param start
     * @param end
     * @param hang_ban 
     */
    public String  addEdge(String start,String end,HangBan hang_ban){
        int x = -1;
        int y = -1;
      //寻找坐标
     
      for(int i = 0; i < mapping.length; i++){
      
          if(x != -1 && y != -1){
              break;
          }
          if(mapping[i].equals(start)){
              x = i;
          
          }
          if(mapping[i].equals(end)){
              y = i;
             
          }
       }
          if (x == -1 || y == -1 || x > mapping.length -1 || y > mapping.length - 1){
              return ("边的顶点不存在！");
              
          }
       if(matrix[x][y]!=null)
           return "城市间已存在航班，航班号为："+matrix[x][y].HangBanHao+"请去修改页面进行修改！";
       matrix[x][y]=hang_ban;
       return "录入成功！";
        
    }
    /**
     * Dijkstra 算法求得用时最少路线
     * @param start 
     * @param  end
     */
    public String dijkstraTime(String start,String end){
        
        //System.out.println("开始寻路！");
        //System.out.println("起点："+start+"终点："+end);
        int length = mapping.length;
        int x = -1;
        for(int i = 0; i < length; i++){
            if(mapping[i].equals(start)){
                x = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (x == -1){
            return "未找到起点！";
            //throw new RuntimeException("未找到起点");
            
        }
        int y = -1;
        for(int i = 0; i < length; i++){
            if(mapping[i].equals(end)){
                y = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (y == -1){
            return "未找到终点！";
            //throw new RuntimeException("未找到起点");
            
        }
        int[] S = new int[length];                       //S[]
        long[][] distance = new long[length][length];    //存储权值  即时间
        for(int i=0; i < length; i++){
            for(int j = 0; j <length; j++){
                if(matrix[i][j] != null){
                    distance[i][j]=matrix[i][j].timeLength;
                }
                else
                    distance[i][j]=0;
            }
        }
        int[] path = new int[length];
        //初始化path数组
        for(int i = 0; i < length; i++){
            //如果可达就赋值
            if(matrix[x][i]!=null){
                path[i] = x;
            }else{
                //不可达，赋值前一个顶点下标为 -1
                path[i] = -1;
            }
        }
        //先把起点加入S
        S[x] = 1;
        
            //System.out.println("首先寻找start到到各顶点的最短路径");
            //首先需要寻找start顶点到各顶点最短的路径
            long min = Integer.MAX_VALUE;
            int v = 0;
            for(int j=0; j < length; j++){
                
                if(S[j] != 1 && x != j&& distance[x][j] != 0 && distance[x][j]<min){       //当此节点不在S[]中，且和出发点有直达航班 并且航班时间小于
                    min = distance[x][j];        
                    v = j;
                }
            }
            //v 是目前写到各顶点最短的
            S[v] = 1;
            //修正最短距离distance及最短距离path
            //System.out.println("是否进行了修正");
            for(int j = 0; j < length; j++){
                //1.只修正未找到最短路径的
                //2.修正后新顶点需要可达
                //3.如果使用新得最短路径比原有路径短，或者以前不可达，使用新的最短路径可达了
                //符合面三点要求的可以修正路径******************************************************************************if语句判断条件可能会出错
                boolean b1= (S[j] != 1 );
                if(b1 && distance[v][j] != 0 && ((min + distance[v][j] < distance[x][j]) || distance[x][j] == 0)){
                    //说明加入了中间顶点之后找到了更短的路径
                    distance[x][j] = min + distance[v][j];
                    path[j] = v;
                }
            }
        
        //System.out.println("判断是否到达此处");
        // System.out.println("起点："+start+"终点："+end);
        for (int i = 0; i < length; i++){
           
            //System.out.println("起点："+start+"终点："+end);
            if(distance[x][i] != 0 && mapping[i].equals(end)){
               
               // System.out.println(mapping[x] + "--->" + mapping[i] + "最短用时:" + distance[x][i]);
                int index = i;
                String timeName="||";
                //System.out.println();
                while (index != -1){
                   // System.out.println(mapping[index]);
                    timeName=timeName+","+mapping[index];
                    int indexs=index;
                   
                    index = path[index];
                    if(index!=-1){
                     String   strTishi="(已晚点，推荐订购次日航班！)";
                     if(Tool.getPlayTime(matrix[index][indexs].startTime,Tool.getTimes())>0)
                         timeName=timeName+","+matrix[index][indexs].HangBanHao+" 起飞时间："+matrix[index][indexs].startTime;
                     else 
                         timeName=timeName+","+matrix[index][indexs].HangBanHao+" 起飞时间："+matrix[index][indexs].startTime+strTishi;
                    }
                }
                String[] timename=timeName.split(",");
                long timehour=distance[x][i]/60;
                long timeMini=distance[x][i]%60;
                String timeStr="用时最短："+timehour+"时"+timeMini+"分"+"\n路线为：\n";
                for(int j=timename.length-1;j>=0;j--)
                    timeStr=timeStr+" "+timename[j];
                return timeStr;
            }
        }
        return "没有可推荐路线！";
    }
    public void dijkstraTime1(String start,String end){
        //System.out.println("开始寻路！");
        //System.out.println("起点："+start+"终点："+end);
        int length = mapping.length;
        int x = -1;
        for(int i = 0; i < length; i++){
            if(mapping[i] == start){
                x = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (x == -1){
            throw new RuntimeException("未找到起点");
            
        }
        int[] S = new int[length];
        long[][] distance = new long[length][length];
        for(int i=0; i < length; i++){
            for(int j = 0; j <length; j++){
                if(matrix[i][j] != null){
                    distance[i][j]=matrix[i][j].timeLength;
                }
                else
                    distance[i][j]=0;
            }
        }
        int[] path = new int[length];
        //初始化path数组
        for(int i = 0; i < length; i++){
            //如果可达就赋值
            if(matrix[x][i]!=null){
                path[i] = x;
            }else{
                //不可达，赋值前一个顶点下标为 -1
                path[i] = -1;
            }
        }
        //先把起点加入S
        S[x] = 1;
        for(int i = 0; i < length; i++){
            //System.out.println("首先寻找start到到各顶点的最短路径");
            //首先需要寻找start顶点到各顶点最短的路径
            long min = Integer.MAX_VALUE;
            int v = 0;
            for(int j=0; j < length; j++){
                //System.out.println("难道是死循环？");
                //S[j]==1 说明已经找到最短的距离
                //下面过滤掉不可达的情况
                if(S[j] != 1 && x != j&& distance[x][j] != 0 && distance[x][j]<min){
                    min = distance[x][j];
                    v = j;
                }
            }
            //v 是目前写到各顶点最短的
            S[v] = 1;
            //修正最短距离distance及最短距离path
            //System.out.println("是否进行了修正");
            for(int j = 0; j < length; j++){
               
                boolean b1= (S[j] != 1 );
                if(b1 && distance[v][j] != 0 && ((min + distance[v][j] < distance[x][j]) || distance[x][j] == 0)){
                    //说明加入了中间顶点之后找到了更短的路径
                    distance[x][j] = min + distance[v][j];
                    path[j] = v;
                }
            }
        }
        //System.out.println("判断是否到达此处");
        // System.out.println("起点："+start+"终点："+end);
        for (int i = 0; i < length; i++){
           
            //System.out.println("起点："+start+"终点："+end);
            if(distance[x][i] != 0 && mapping[i] == end){
               
               // System.out.println(mapping[x] + "--->" + mapping[i] + "最短用时:" + distance[x][i]);
                int index = i;
                String timeName="||";
                //System.out.println();
                while (index != -1){
                   // System.out.println(mapping[index]);
                    timeName=timeName+","+mapping[index];
                    int indexs=index;
                   
                    index = path[index];
                    if(index!=-1){
                     //System.out.print(matrix[index][indexs].HangBanHao);
                     timeName=timeName+","+matrix[index][indexs].HangBanHao;
                    }
                }
                String[] timename=timeName.split(",");
                String timeStr="用时最短推荐路线为：";
                for(int j=timename.length-1;j>=0;j--)
                    timeStr=timeStr+" "+timename[j];
                System.out.println(timeStr);
                
            }
        }
        System.out.println("没有可推荐路线！"); 
    }
    /**
     * DijkstraPrice 算法找到费用最少路线
     * @param start
     * @param end
     * @return 
     */
    public String dijkstraPrice(String start,String end){
        //System.out.println("开始寻路！");
        //System.out.println("起点："+start+"终点："+end);
        int length = mapping.length;
        int x = -1;
        for(int i = 0; i < length; i++){
            if(mapping[i].equals(start)){
                x = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (x == -1){
            return ("未找到起点！");
            
        }
         int y = -1;
        for(int i = 0; i < length; i++){
            if(mapping[i].equals(end)){
                y = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (y == -1){
            return ("未找到终点！");
            
        }
        int[] S = new int[length];
        double[][] distance = new double[length][length];
        for(int i=0; i < length; i++){
            for(int j = 0; j <length; j++){
                if(matrix[i][j] != null){
                    distance[i][j]=matrix[i][j].price;
                }
                else
                    distance[i][j]=0;
            }
        }
        int[] path = new int[length];
        //初始化path数组
        for(int i = 0; i < length; i++){
            //如果可达就赋值
            if(matrix[x][i]!=null){
                path[i] = x;
            }else{
                //不可达，赋值前一个顶点下标为 -1
                path[i] = -1;
            }
        }
        //先把起点加入S
        S[x] = 1;
        for(int i = 0; i < length; i++){
            //System.out.println("首先寻找start到到各顶点的最短路径");
            //首先需要寻找start顶点到各顶点最短的路径
            double min = Integer.MAX_VALUE;
            int v = 0;
            for(int j=0; j < length; j++){
                //System.out.println("难道是死循环？");
                //S[j]==1 说明已经找到最短的距离
                //下面过滤掉不可达的情况
                if(S[j] != 1 && x != j&& distance[x][j] != 0 && distance[x][j]<min){
                    min = distance[x][j];
                    v = j;
                }
            }
            //v 是目前写到各顶点最短的
            S[v] = 1;
            //修正最短距离distance及最短距离path
            //System.out.println("是否进行了修正");
            for(int j = 0; j < length; j++){
                //1.只修正未找到最短路径的
                //2.修正后新顶点需要可达
                //3.如果使用心得最短路径比原有路径短，或者以前不可达，使用新的最短路径可达了
                //符合面三点要求的可以修正路径
                boolean b1= (S[j] != 1 );
                if(b1 && distance[v][j] != 0 && ((min + distance[v][j] < distance[x][j]) || distance[x][j] == 0)){
                    //说明加入了中间顶点之后找到了更短的路径
                    distance[x][j] = min + distance[v][j];
                    path[j] = v;
                }
            }
        }
        //System.out.println("判断是否到达此处");
        // System.out.println("起点："+start+"终点："+end);
        for (int i = 0; i < length; i++){
           
            //System.out.println("起点："+start+"终点："+end);
            if(distance[x][i] != 0 && mapping[i].equals(end)){
               
               // System.out.println(mapping[x] + "--->" + mapping[i] + "费用最少:" + distance[x][i]);
                int index = i;
                String feeName="||";
                System.out.println();
                while (index != -1){
                   // System.out.println(mapping[index]);
                    feeName=feeName+","+mapping[index];
                    int indexs=index;
                   
                    index = path[index];
                    if(index!=-1){
                      String   strTishi="(已晚点，推荐订购次日航班！)";
                     //System.out.print(matrix[index][indexs].HangBanHao);
                     if(Tool.getPlayTime(matrix[index][indexs].startTime,Tool.getTimes())>0)
                         feeName=feeName+","+matrix[index][indexs].HangBanHao+" 起飞时间："+matrix[index][indexs].startTime;
                     else 
                         feeName=feeName+","+matrix[index][indexs].HangBanHao+" 起飞时间："+matrix[index][indexs].startTime+strTishi;
                    }
                }
                String[] feename=feeName.split(",");
                String feeStr="费用最少:"+distance[x][i]+"￥\n路线为：\n";
                for(int j=feename.length-1;j>=0;j--)
                    feeStr=feeStr+" "+feename[j];
                return feeStr;
            }
        }
        return "无费用最少推荐路线！";
    }
    public void dijkstraPrice1(String start,String end){
        //System.out.println("开始寻路！");
        //System.out.println("起点："+start+"终点："+end);
        int length = mapping.length;
        int x = -1;
        for(int i = 0; i < length; i++){
            if(mapping[i] == start){
                x = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (x == -1){
            throw new RuntimeException("未找到起点");
            
        }
        int[] S = new int[length];
        double[][] distance = new double[length][length];
        for(int i=0; i < length; i++){
            for(int j = 0; j <length; j++){
                if(matrix[i][j] != null){
                    distance[i][j]=matrix[i][j].price;
                }
                else
                    distance[i][j]=0;
            }
        }
        int[] path = new int[length];
        //初始化path数组
        for(int i = 0; i < length; i++){
            //如果可达就赋值
            if(matrix[x][i]!=null){
                path[i] = x;
            }else{
                //不可达，赋值前一个顶点下标为 -1
                path[i] = -1;
            }
        }
        //先把起点加入S
        S[x] = 1;
        for(int i = 0; i < length; i++){
            //System.out.println("首先寻找start到到各顶点的最短路径");
            //首先需要寻找start顶点到各顶点最短的路径
            double min = Integer.MAX_VALUE;
            int v = 0;
            for(int j=0; j < length; j++){
                //System.out.println("难道是死循环？");
                //S[j]==1 说明已经找到最短的距离
                //下面过滤掉不可达的情况
                if(S[j] != 1 && x != j&& distance[x][j] != 0 && distance[x][j]<min){
                    min = distance[x][j];
                    v = j;
                }
            }
            //v 是目前写到各顶点最短的
            S[v] = 1;
            //修正最短距离distance及最短距离path
            //System.out.println("是否进行了修正");
            for(int j = 0; j < length; j++){
                //1.只修正未找到最短路径的
                //2.修正后新顶点需要可达
                //3.如果使用心得最短路径比原有路径短，或者以前不可达，使用新的最短路径可达了
                //符合面三点要求的可以修正路径
                boolean b1= (S[j] != 1 );
                if(b1 && distance[v][j] != 0 && ((min + distance[v][j] < distance[x][j]) || distance[x][j] == 0)){
                    //说明加入了中间顶点之后找到了更短的路径
                    distance[x][j] = min + distance[v][j];
                    path[j] = v;
                }
            }
        }
        //System.
        for (int i = 0; i < length; i++){
           
          
            if(distance[x][i] != 0 && mapping[i] == end){
               
                System.out.println(mapping[x] + "--->" + mapping[i] + "费用最少:" + distance[x][i]);
                int index = i;
                String feeName="||";
                System.out.println();
                while (index != -1){
                   // System.out.println(mapping[index]);
                    feeName=feeName+","+mapping[index];
                    int indexs=index;
                   
                    index = path[index];
                    if(index!=-1){
                     //System.out.print(matrix[index][indexs].HangBanHao);
                     feeName=feeName+","+matrix[index][indexs].HangBanHao;
                    }
                }
                String[] feename=feeName.split(",");
                String feeStr="费用最少推荐路线为：";
                for(int j=feename.length-1;j>=0;j--)
                    feeStr=feeStr+" "+feename[j];
                System.out.println(feeStr);
            }
        }
    }
    /**
     * 判断两城市之间是否存在直达航班
     * @param start
     * @param end
     * @return 
     */
    public String judgeThrough(String start,String end){
        int length = mapping.length;
        int x = -1;
        //判断两点是否存在
        for(int i = 0; i < length; i++){
            if(mapping[i].equals(start)){
                x = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (x == -1){
            return ("未找到起点！");
            
        }
         int y = -1;
        for(int i = 0; i < length; i++){
            if(mapping[i].equals(end)){
                y = i;                    //找到起始点的下标
                //System.out.println("起始点坐标为："+i);
                break;
            }
        }
        if (y == -1){
            return ("未找到终点！");
            
        }
        if(matrix[x][y]!=null){
            String tishi="已晚点，请选择其他航班！";
            if(Tool.getPlayTime(matrix[x][y].startTime,Tool.getTimes())>0)
            return "直达航班为："+matrix[x][y].HangBanHao+"["+matrix[x][y].startTime+"\n";
             else
            return "直达航班为："+matrix[x][y].HangBanHao+"["+matrix[x][y].startTime+"]"+tishi+"\n";

        }
       
        
      return "无直达航班！\n";
    }
    /**
     * 查询航班详细资料
     * @param hangban
     * @return 
     */
    public  String InquiryHangBan(String hangban){
        String result="航班信息：\n航班号   价格  余量  折扣   起飞时间    到达时间     时长(分钟)\n";
        int length = mapping.length;
        int i,j;
        for(i = 0; i < length; i++){
            for(j = 0;j < length; j++){
              
                if(matrix[i][j]!=null){
                    if(matrix[i][j].HangBanHao.equals(hangban)){
                        String lines=" | ";
                        result=result+matrix[i][j].HangBanHao+lines+matrix[i][j].price+lines+matrix[i][j].seatNumber+lines
                                +matrix[i][j].discount+lines+matrix[i][j].startTime+lines+matrix[i][j].lendTime+lines+matrix[i][j].timeLength;
                        return result;
                   }
                }
            }
        }
        return "无此航班信息！";
    }
    /**
     * 将订票后的数据重新存到文件中
     * @param riqi 
     */
    public void storeToFile(String riqi){
        int i,j;
        String str="";
        String lines="-";
        int length = mapping.length;
        for(i=0; i<length;i++){
            for(j=0;j<length;j++){
                if(matrix[i][j]!=null){
                    str=str+matrix[i][j].HangBanHao+lines+matrix[i][j].price+lines+matrix[i][j].seatNumber+lines
                     +matrix[i][j].discount+lines+matrix[i][j].startTime+lines+matrix[i][j].lendTime+lines+mapping[i]+lines+mapping[j]+"\n";
                }
            }
        }
        FileIOImp.write("./month_flight_information/", str, false, riqi);
    }
    /**
     * 深度优先搜索 遍历节点 找到节点后 将此城市的航班信息打印出来
     * @param hangbanhao
     * @return 
     */
    public String depthFirstTravel(String City){
        String city="";
        Stack stack = new Stack(mapping.length);
        //初始化各顶点的访问状态
        int[] visited = new int[mapping.length];
        //从未访问顶点中选择一个顶点作为起始顶点
        int unvisited = getUnVisited(visited);
        while(unvisited >= 0){
            //访问起始顶点 并入栈
            visited[unvisited] = -1;
            stack.push(unvisited);
            //System.out.println(mapping[unvisited]+",");
            if(mapping[unvisited].equals(City)){
                city = cityAllHangban(unvisited);
                return city;
            }
            
            while(!stack.isEmpty()){
                //获取栈顶元素，不出栈
                int index = stack.peek();
                //遍历找到未被访问的节点
                boolean found = false;
                for (int i = 0;i < mapping.length; i++){
                    //不能是自己、未被访问、可到达
                    if(index != i && visited[i] == 0 && matrix[index][i] != null){
                        //如果找到未被访问的节点则访问并入栈
                        visited[i] = 1;
                        stack.push(i);
                        //System.out.println(mapping[i] + ",");
                        if(mapping[i].equals(City)){
                            city = cityAllHangban(i);
                            return city;
                        }
                        found = true;
                        break;
                    }
                }
                //如果未找到 则出栈元素
                if (!found)
                {
                    stack.pop();
                }
                
            }
            unvisited = getUnVisited(visited);
            
        }
        //System.out.println("\n");
        
        return "此城市无航班信息！";
    }
    private int getUnVisited(int[] visited){
        int index = -1;
        for(int i = 0; i <visited.length; i++){
            if(visited[i] == 0){
                index = i;
                break;
            }
        }
        return index;
    }
    private String cityAllHangban(int index){
        int i = 0;
        String result = "";
        for(i = 0; i < mapping.length; i++){
            if(matrix[index][i] != null)
            {
                result = result+"航班号："+matrix[index][i].HangBanHao+"   目的地："+mapping[i]+"\n";
            }
        }
        return result;
    }
    /**
     * 订票函数
     * @param hangban
     * @return 
     */
    public String DingPiao(String hangban){
        int i,j;
        int length = mapping.length;
        for(i = 0; i < length; i++){
            for(j = 0;j < length; j++){
              
                if(matrix[i][j]!=null){
                  
                    if(matrix[i][j].HangBanHao.equals(hangban)){
                        if( matrix[i][j].seatNumber>0){
                             matrix[i][j].seatNumber--;
                             return "订票成功！";
                        }
                        else
                           return "无票或距起飞时间不到半小时\n，请选择其他日期或者路线进行订票！";
                               
                   }
                }
            }
        }
        return "此航班不存在，请核实后再进行订票！";
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ytu.cx.util;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.DateFormat;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.logging.Level;
import java.util.logging.Logger;
import ytu.edu.server.Operation;

 
import java.io.InputStreamReader;  
import java.util.regex.Matcher;  
import java.util.regex.Pattern;
/**
 *
 * @author changxuan
 */
public  class Tool {
    /**
      * 某文件中有几条记录
      * @param FILEPATH
      * @param filename
      * @return 
      */
     public static int readToLines(String FILEPATH,String filename) {
		int n=0;
		String lineString="";
		try {
			//测试语句System.out.println("文件名"+filename);
			File  file=new File(FILEPATH+filename);
			FileReader fr =new FileReader(file);
			BufferedReader br=new BufferedReader(fr);
			while((lineString=br.readLine())!=null){
				n++;
			}
			fr.close();
			br.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return n;
	}
    
    /**
     * 获得当前日期
     * @return 
     */
    public static String getTime(){                                       
		Date now=new Date();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		return sdf.format(now);
		
	}
    public static String getTimes(){                                       
		Date now=new Date();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return sdf.format(now);
		
	}
    /**
     * 产生订单编号
     * @param hangBanHao
     * @return 
     */
    public static String getDingDanID(String hangBanHao){                 
        int countDingDan=readToLines("./booking_record/","booking.txt");
        String count = "0";
        if(countDingDan<10){
            count = count+count+count+countDingDan;
        }else if(countDingDan < 1000){
            count = count+ count +countDingDan;
        }else if(countDingDan < 10000){
            return (hangBanHao+Tool.getTime()+countDingDan);
        }else{
            countDingDan = 0;
            count = count+count+count+countDingDan;
        }
        return (hangBanHao+Tool.getTime()+count);
    }
    
    /**
     * 返回飞行时间差，作为权值
     * @param startTime
     * @param endTime
     * @return 
     */
    public static long getPlayTime(String startTime,String endTime){      
        long timeLen=0;
        DateFormat df = new SimpleDateFormat("HH:mm:ss");
        try{   
        
        Date d1 = df.parse(endTime);   
        Date d2 = df.parse(startTime);   
        long diff = d1.getTime() - d2.getTime();   
        long days = diff / (1000 * 60 );
        timeLen=days;
        }catch (Exception e){
        }
        return timeLen;
    }
     /**
     * 判断当日文件是否存在，存在则
     * @param file
     * @return 
     */
     public static boolean judeFileExists(File file) {

        if (file.exists()) {
            return true;
        } else {
            try {
                file.createNewFile();
            } catch (IOException ex) {
                Logger.getLogger(Operation.class.getName()).log(Level.SEVERE, null, ex);
            }
            return false;
        }
     }
     

  /**
     * 判断文件夹中是否存在文件
     * @param path
     * @return 
     */
    public static boolean testDir(String path)
  {
    File f = new File(path);
     if (f.exists())
     {
         
            //System.out.println("文件夹中存在文件");
           return true;
       }
       else{
            //System.out.println("文件夹中不存在文件");
            return false;
     }
  }
    /**
     * 获取n天前的日期
     * @param n
     * @return 
     */
    public static String getBeforetime(int n){
        Date now=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
	return sdf.format(new Date(now.getTime() -  n*24 * 60 * 60 * 1000));
    }
     /**
      * 获取n天后的日期
      * @param n
      * @return 
      */
    public static String getAftertime(int n){
        Date now=new Date();
        GregorianCalendar gc=new GregorianCalendar(); 
        gc.setTime(new Date()); 
        gc.add(5,n); 
        gc.set(gc.get(Calendar.YEAR),gc.get(Calendar.MONTH),gc.get(Calendar.DATE));
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(gc.getTime());
       // 单纯的使用Data类进行加运算时容易出错
       // return sdf.format(new Date(now.getTime() +  n*24 * 60 * 60 * 1000));
    }
    /**
     * 删除某路径下的文件
     * @param fileName 
     */
    public static void deleteFile(String fileName) {
        File file = new File(fileName);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists() && file.isFile()) {
            //此处应该做异常处理，可是我不想处理
            file.delete();
                //System.out.println("删除单个文件" + fileName + "成功！");
              
        } else {
            //System.out.println("删除单个文件失败：" + fileName + "不存在！");
            System.out.println("程序删除文件异常！");
        }
    }
    public static void deleteFiles(String fileName){
        File file = new File(fileName);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists()) {
            //此处应该做异常处理，可是我不想处理
            file.delete();
           System.out.println("删除单个文件" + fileName + "成功！");
              
        } else {
            //System.out.println("删除单个文件失败：" + fileName + "不存在！");
            System.out.println("程序删除文件异常！");
        }
    }
   public static void recurDelete(File f){
    for(File fi:f.listFiles()){
        if(fi.isDirectory()){
            recurDelete(fi);
        }
        else{
            fi.delete();
        }
    }
    f.delete();
}
    /**
     * 将file1 中的文件拷贝到file2 文件夹中
     * 例      copy("./flight_information/flight_record.txt","./month_flight_information");
     * @param file1
     * @param file2 
     */
    public static void copy(String file1, String file2) {


    System.out.println(file1);
    System.out.println(file2);
    File src=new File(file1);
    File dst=new File(file2);
    if(!dst.exists()){
         dst.mkdirs();
    }
    InputStream in = null;
    OutputStream out = null;
    //System.out.println(file1.substring(file1.lastIndexOf("/"),file1.length()));//获取单个文件的源文件的名称
    try {
            in = new BufferedInputStream(new FileInputStream(src), 16 * 1024);
            FileOutputStream f= new FileOutputStream(dst+file1.substring(file1.lastIndexOf("/"),file1.length()));//一定要加上文件名称
            out = new BufferedOutputStream(f, 16 * 1024);
            byte[] buffer = new byte[16 * 1024];
            int len = 0;
            while ((len = in.read(buffer)) > 0) {
            out.write(buffer, 0, len);
            }
    } catch (Exception e) {
            e.printStackTrace();
    } finally {
    if (null != in) {
    try {
    in.close();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    if (null != out) {
    try {
    out.close();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }
}
    /**
     * 将Path路径下的oldname文件重命名为newname
     * @param Path
     * @param oldname
     * @param newname 
     */
    public static void renameFile(String Path,String oldname,String newname){ 
        if(!oldname.equals(newname)){//新的文件名和以前文件名不同时,才有必要进行重命名 
            File oldfile=new File(Path+"/"+oldname); 
            File newfile=new File(Path+"/"+newname); 
            if(!oldfile.exists()){
                return;//重命名文件不存在
            }
            if(newfile.exists())//若在该目录下已经有一个文件和新文件名相同，则不允许重命名 
                System.out.println(newname+"已经存在！"); 
            else{ 
                oldfile.renameTo(newfile); 
            } 
        }else{
            System.out.println("新文件名和旧文件名相同...");
        }
    }
    
    /**
     * 检查文件夹及其路径是否存在，否，则创建文件
     * @param FILEPATH
     * @param filename 
     */
     public static void checkFile(String FILEPATH,String filename) {
                File  file=new File(FILEPATH+filename);
		
		File fileDir= new File(FILEPATH);
		 file=new File(FILEPATH+filename);
		if(!fileDir.exists()){
			fileDir.mkdirs();
		}
		if(!file.exists()){
			try {
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
     /**
      * 判断身份证号是否符合格式
      * @param idCard
      * @return 
      */
     public static boolean checkID(String idCard){
         /* BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));  
            String idNum=null;  
            try {  
                idNum= consoleReader.readLine();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }
         */ 
            //定义判别用户身份证号的正则表达式（要么是15位，要么是18位，最后一位可以为字母）  
            Pattern idNumPattern = Pattern.compile("(\\d{14}[0-9a-zA-Z])|(\\d{17}[0-9a-zA-Z])");  
            //通过Pattern获得Matcher  
            Matcher idNumMatcher = idNumPattern.matcher(idCard);  
            //判断用户输入是否为身份证号  
            if(idNumMatcher.matches()){  
                return true;
            }else{  
                //如果不是，输出信息提示用户  
                return false; 
            }  
     }
      public static boolean compare_date(String DATE1, String DATE2) {
        
        
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date dt1 =df.parse(DATE1);
            Date dt2 =df.parse(DATE2);
            if (dt1.getTime() >= dt2.getTime()) {
               return true;
            } else if(dt1.getTime() < dt2.getTime()) {
               return false;
            }

       } catch (Exception exception) {
           exception.printStackTrace();
        }
        return false;
     }
     
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ytu.edu.server;

import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import ytu.cx.util.Tool;

/**
 *
 * @author changxuan
 */
public class Operation {
    /*思路：当打开软件是执行构造函数，然后判断是否是今天第一天打开软件，如是则创建以当天日期为命名的
    的txt文件，用来存储当日订票数据，并且创建一个文件用来存储当日航班情况信息。
    
    一个文件用来存储航班信息，如果判断是当天第一次打开软件，则从此文件中读取信息存储到图结构中
    若不是第一次打开此软件，则从存储当日航班请况信息文件中读取数据到图结构中
    
    */
    public Operation(){
       
        //返回TRUE 说明曾经使用过此软件，但，是当日第一次打开软件，在flight_information文件夹中存在 flight_record.txt用来记录
        //航班信息的文件 
        if( Tool.testDir("./flight_information/flight_record.txt")&&Tool.testDir("./month_flight_information/"+Tool.getBeforetime(1)+".txt")){
            //删除 记录昨天全部航班票量的信息文件
            Tool.deleteFile("./month_flight_information/"+Tool.getBeforetime(1)+".txt");
            //增加 以flight_information文件夹中的文件为模板向month_flight_information文件夹中拷贝一份
            Tool.copy("./flight_information/flight_record.txt", "./month_flight_information");
            //然后将拷贝过来的文件重命名为29天后的一个txt文件 
            Tool.renameFile("./month_flight_information", "flight_record.txt", Tool.getAftertime(29)+".txt");
            
        }else if(!Tool.testDir("./flight_information/flight_record.txt")){//返回FALSE 说明是第一次使用软件
            //创建 flight_information 文件夹及其存储航班信息的 flight_record.txt 文件 
            Tool.checkFile("./flight_information/", "flight_record.txt");
            //创建30个txt文件用于记录近三十天内的售票情况
            for(int i=0;i<30;i++){
                Tool.checkFile("./month_flight_information/", Tool.getAftertime(i)+".txt");
            }
            Tool.checkFile("./booking_record/", "booking.txt");
        }else
            System.out.println("表示当日使用过此软件！");
        
    }
    
   
     
}

   

/*
 public static void judeFileExists(File file) {
17 
18         if (file.exists()) {
19             System.out.println("file exists");
20         } else {
21             System.out.println("file not exists, create it ...");
22             try {
23                 file.createNewFile();
24             } catch (IOException e) {
25                 // TODO Auto-generated catch block
26                 e.printStackTrace();
27             }
28         }
29  }
*/

/*

  // 判断文件夹是否存在
33     public static void judeDirExists(File file) {
34 
35         if (file.exists()) {
36             if (file.isDirectory()) {
37                 System.out.println("dir exists");
38             } else {
39                 System.out.println("the same name file exists, can not create dir");
40             }
41         } else {
42             System.out.println("dir not exists, create it ...");
43             file.mkdir();
44         }
45 
46     }

*/

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ytu.cx.util;

import java.security.MessageDigest;

/**
 *
 * @author changxuan
 */
public class MD5password {
     public final static String MD5(String s){
        char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        try{
            byte[] btInput = s.getBytes();
            MessageDigest mdInst = MessageDigest.getInstance("MD5");
            mdInst.update(btInput);
            byte[] md=mdInst.digest();
            int j = md.length;
            char str[] = new char[j*2];
            int k=0;
            for(int i=0;i<j;i++){
                byte byte0=md[i];
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            
            }
            return new String(str);
        }catch(Exception e){
            e.printStackTrace();
            return null;
        }
        
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ytu.cx.store;
import java.util.Arrays;
/**
 *
 * @author changxuan
 */
public class Stack {
    private int size = 0;
    private int[] array;
    /**
     * 构造函数
     */
   /* public Stack(){
        this(10);
    }*/
    public Stack(int init){
        if(init <= 0){
            init = 10;
        }
        array = new int[init];
    }
    /**
     * 入栈
     * @param item 
     */
    public void push (int item){
        if(size == array.length){
            array = Arrays.copyOf(array, size*2);
        }
        array[size++] = item;
    }
    /**
     * 获取栈顶元素，但是没有出栈
     * @return 
     */
    public int peek(){
        if (size == 0){
            throw new IndexOutOfBoundsException("栈里已经空！");
            
        }
        return array[size -1];
    }
    /**
     * 出栈，同时获取栈顶元素
     * @return 
     */
    public int pop(){
        int item = peek();
        size --;         //直接使元素个数剪一，不需要真的清除元素，下次入栈自动覆盖元素的值
        return item;
    }
    /**
     * 判断栈是否满了
     * @return 
     */
    public boolean isFull(){
        return size == array.length;
    }
    /**
     * 栈是否为空
     * @return 
     */
    public boolean isEmpty(){
        return size == 0;
    }
    public int size(){
        return size;
    }
    
}

由于代码量太大，不全部放出。如有需要可以关注微信公众号：worldhello（左侧扫码可以关注哟！），根据提示获取！或者直接联系微信后台管理人员。

壹言

关注

27
点赞
踩
103

收藏

觉得还不错? 一键收藏
23
评论
Java版飞机订票系统

数据结构课程设计题目：【飞机订票系统】通过此系统可以实现如下功能：录入：可以录入航班情况（数据存储在一个数据文件中，数据结构和具体数据自定）查询：可以查询某个航线的情况（如：输入航班号，查询起降时间、起飞抵达城市、航班票价、票价折扣、确定航班是否满仓）订票：订票情况可以存
复制链接

扫一扫