关注微信公众号：Worldhello 回复 飞机订票系统 可获得系统源代码并可加群讨论交流
数据结构课程设计题目：
【飞机订票系统】
通过此系统可以实现如下功能：
录入：可以录入航班情况（数据存储在一个数据文件中，数据结构和具体数据自定）
查询：可以查询某个航线的情况（如：输入航班号，查询起降时间、起飞抵达城市、航班票价、票价折扣、确定航班是否满仓）
订票：订票情况可以存在一个数据文件中，结构自己设定，可以订票，如果该航班已经无票，可以提供相关可选择航班
退票：可退票，退票后修改航班数据文件
基本要求：
根据以上功能说明，设计航班信息，订票信息的存储结构，设计程序完成功能；
设计分析：
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+"分"+"
路线为：
";
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]+"￥
路线为：
";
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+"
";
else
return "直达航班为："+matrix[x][y].HangBanHao+"["+matrix[x][y].startTime+"]"+tishi+"
";
}
return "无直达航班！
";
}
/**
* 查询航班详细资料
* @param hangban
* @return
*/
public String InquiryHangBan(String hangban){
String result="航班信息：
航班号 价格 余量 折扣 起飞时间 到达时间 时长(分钟)
";
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]+"
";
}
}
}
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("
");
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]+"
";
}
}
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 "无票或距起飞时间不到半小时
，请选择其他日期或者路线进行订票！";
}
}
}
}
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（左侧扫码可以关注哟！），根据提示获取！或者直接联系微信后台管理人员。