Java版飞机订票系统

数据结构课程设计题目:

         【飞机订票系统】

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

           录入:可以录入航班情况(数据存储在一个数据文件中,数据结构和具体数据自定)

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

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

            退票:可退票,退票后修改航班数据文件


            基本要求:

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


设计分析:

        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(左侧扫码可以关注哟!),根据提示获取!或者直接联系微信后台管理人员。

转载于:https://www.cnblogs.com/chxuan/p/8232098.html

相关资源:飞机订票系统
表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
相关推荐
网上订票系统 用到的技术为:javabean-servlet-jsp sql server 2000 数据库文件在WebRoot的DB文件中! 本系统实现了会员注册,会员登录,密码修改,以及会员信息的修改! 初步实现了在线订购,订单查询,班次查询以及系统管理--对火车信息的添加等。 操作过程: 首先,应导入到myeclipse中,将该系统发布到tomcat中,并启动tomcat! 接着在360浏览器中输入http://localhost:8080/bookonline/login.jsp 管理员的帐号为:guanliyuan 密码为:123456789 用户帐号为:987654321 密码为:987654321 当然可以在登录界面中点击注册链接,跳转到注册页面中进行注册(注:只能注册用户的,没有管理员注册!这是该系统中的一个问题)。 登录进去后进入主界面main.jsp中。在该界面中,可以点击修改用户信息,密码等链接,管理员还可以点击添加火车信息的链接。当然还可以查看火车信息。(注:只有在查询后,才能进行订票)。 注: 用到的页面 login.jsp——登录界面,可以链接到注册用户的界面。用admi n字段来标识是否为管理员。其中有一个用户为987654321密码为987654321,另一个为管理员guanliyuan密码为123456789 register.jsp——用户注册页面,默认的所有注册方式为用户,即所有的用户admin为0。而管理员事先设置好了,即admin为1。 registerfailed.jsp registersuccess.jsp——为注册成功或失败时用到的页面 main.jsp——为系统主页面,在这里可以链接到订票,查询,修改信息,修改密码,管理员添加火车信息等。该页面用到了专题咨询里面的主框架结构,和部分代码。 queryfailed.jsp——当查询失败时所连接到的界面 addtrain.jsp——管理员添加火车信息时的页面 adderror.jsp——用户点击添加火车信息时产生的错误界面 showticket.jsp——显示火车票信息,此时可以进行订票。 bookfailes.jsp booksuccess.jsp——订票成功或失败时所链接的界面。 view.jsp——浏览火车票信息。 modifyinfo.jsp——修改用户信息,在这里不可能更改密码,以及权限。 passwordmodify.jsp——修改密码!
目 录 前 言 1 第1章 需求分析 2 §1.1 开发必要性 2 §1.2 可行性分析 2 §1.2.1 经济可行性分析 2 §1.2.2 技术可行性分析 3 §1.2.3 现有系统的分析 3 第2章 系统分析 4 §2.1 系统逻辑模型的提出 4 §2.2 系统的功能介绍 4 §2.3 系统开发工具和开发语言 5 §2.3.1 开发工具 5 §2.3.2 开发语言 6 第3章 总体设计 7 §3.1 系统功能设计 7 §3.2 系统功能模块简介 7 第4章 数据库设计 10 §4.1 概念结构设计 10 §4.2 逻辑结构设计 11 §4.3 物理结构设计 12 第5章 详细设计 14 §5.1 关键业务流程描述 14 §5.1.1 航空售票管理 14 §5.1.2 管理员管理流程 14 §5.2 系统界面设计 15 §5.2.1 主功能界面 15 §5.2.2 其他功能界面 16 §5.3 模块代码实现 18 §5.3.1 航空订票查询模块 18 §5.3.2 航空售票管理模块 19 第6章 系统测试 21 §6.1 软件测试的目标 21 §6.2 具体测试 21 结 论 24 参考文献 25 致 谢 27 §5.3.1 航空订票查询模块 航空订票查询主要实现对票据信息种类的添加、修改和删除功能。票据信息种类是系统内容的最高级别,所以在添加、修改或删除票据信息时,也必须选择该票据信息所属的票据信息种类。下面是票据信息种类的添加、修改和删除功能的主要实现代码。 public void actionPerformed(ActionEvent e) { this.flightNumber = flightField.getText().trim(); if (flightNumber.length() == 0) //未输入信息 { JOptionPane.showMessageDialog(null,"请输入航班号或者从列表中选择", "错误信息",JOptionPane.ERROR_MESSAGE); return; } executeFlightQuery(); } public void executeFlightQuery() { String sqlString = "SELECT DISTINCT * FROM " +"flight " + "WHERE flight=" + "\'" + flightNumber + "\'"; ResultSet rs = sqlBean.executeQuery(sqlString); if (rs != null) showResult(rs); else JOptionPane.showMessageDialog(null,"没有连接上数据库!", "错误信息",JOptionPane.ERROR_MESSAGE); } 以上是对数据添加的程序代码,该段代码实现了获得用户数据输入,并把数据插入到数据库当中的功能。 。。。。。。。。。。。。。。。。。。。。。。。。。。。
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页