關注微信公眾號：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+"分"+"\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（左側掃碼可以關注喲！），根據提示獲取！或者直接聯系微信后台管理人員。