package com.dear.uniteMysqlPostgresql;
/**
*公交换乘一站的算法思想:
*(注意:车次信息、站点信息、公交信息是等价的都是以HashMap的形式存储信息)
*1.从数据库中获得所有公交信息存储到ArrayList,每个具体信息的元数据有三个:
*公交车次、公交站点、该公交站点距离该公交车次的始发站点的站数,具体信息用HashMap保存
*2.然后把公交信息数据进行结构化,把所有公交站点抽出,再把每一个站点对应的所有车次抽出
*与其一一对应,单一的车次信息用HashMap存储,站点对应的所有车次信息用ArrayList存储,
*所有的站点有经过站点的车次信息用HashMap存储
*3.根据查询要求,分别从结构化以后的公交信息数据中找到,经过出发地的所有车次,经过目的地
*的所有车次,然后在分别遍历每个车次,筛选出符合要求的中转站点,筛选规则是:每查询出一个
*站点时,得到该站点距离该站点对应车次的始发站的站数,如果这个站数小于查询站点距离该车次的始
*发站的站数,那么就符合规则,便把该站点信息保存到符合站点的ArrayList中,反之亦然
*4.分别得到查询条件中出发地和目的地的中转站点信息(中转站点信息存储在ArrayList中),然
*后遍历两个中转站点信息的集合,得到所有中转信息(最终中转信息也是用ArrayList存储)
*5.最后处理所有中转信息,即是把中转信息中是相同的两个车次的信息进行合并
*比如有两个换乘方法:109到龙泽换乘200 109到上地换乘200
*那么把该数据整理为109到龙泽或者上地换乘200
*
*/
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
publicclass BusTransfer2 {
private String start = null;// 出发地
private String whither = null;// 目标地
private List schedule = null;// 用于缓存列车时刻表。
private HashMap<String, ArrayList> stationsOfLine = null; // 所有公交线路,每个list存储该线路经过的所有车站。
private HashMap<String, ArrayList> linesOfStation = null;// 所有车站,每个list中存储通过该车站的所有车次。
// private ArrayList<String> startLine = new ArrayList<String>();//
// 途经出发地的所有车次。
// private ArrayList<String> whitherLine = new ArrayList<String>();//
// 途经目的地的所有车次。
private ArrayList<Map> firLineStaList = new ArrayList<Map>();
private ArrayList<Map> secLineStaList = new ArrayList<Map>();
public BusTransfer2() {
}
public BusTransfer2(String start, String whither) {
this.start = start;
this.whither = whither;
try {
this.schedule = this
.executeQuery("select busLine,up,stationNo from bus_stations");
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println("读取数据库出错");
e.printStackTrace();
}
stationsOfLine = this.getStationsOfLine();
linesOfStation = this.getLinesOfStation();
}
private ArrayList<String> getStations() {
ArrayList<String> arr=new ArrayList<String>();
for (int i = 0; i < schedule.size(); i++) {
arr.add((String)((Map) schedule.get(i)).get("up"));
}
return arr;
}
private HashMap<String, ArrayList> getStationsOfLine() {
HashMap map = new HashMap();// 用于临时存储从schedule中取出的HashMap.
ArrayList<Map> line = null;// 每个list存储一个车次的相关车站信息。
String buffer = "a";// 缓存站名。
String temp = null;// 临时存储每次迭代取出的站名,用于与buffer站名比较。
HashMap<String, ArrayList> stationsGroupByLine = new HashMap<String, ArrayList>();// 存储以车次分组後的车站的list
Iterator it = schedule.iterator(); // 迭代器
while (it.hasNext()) {
map = (HashMap) it.next();
temp = (String) map.get("busLine");
if (stationsGroupByLine.containsKey(temp)) {
line = stationsGroupByLine.get(temp);
buffer = (String) ((Map) line.get(0)).get("busLine");
}
if (buffer.equals(temp)) {
line.add(map);// 将同一车次的车站放入一个list中
} else {
if (line != null && !line.isEmpty()) {
stationsGroupByLine.put(buffer, line);// 将由车次分组后的车站构成的list存入一个map
}
line = new ArrayList<Map>(); // line重新引用一个新构造的list,以供存储同一车站的车次。
line.add(map);// 将同一车次的车站放入刚刚构造的空list中
}
buffer = temp;// 缓存当前操作的车次。
}
return stationsGroupByLine;
}
private HashMap getLinesOfStation() {
HashMap map = new HashMap();// 用于临时存储从schedule中取出的HashMap.
ArrayList<Map> station = null;// 每个list存储一个经过该车站的相关车次信息。
String buffer = "a";// 缓存车次。
String temp = null;// 临时存储每次迭代取出的车次,用于与buffer车次比较。
HashMap<String, ArrayList> linesGroupBystation = new HashMap<String, ArrayList>();// 存储以车站分组後的车次的list
Iterator it = schedule.iterator(); // 迭代器
while (it.hasNext()) {
map = (HashMap) it.next();
temp = (String) map.get("up");
if (linesGroupBystation.containsKey(temp)) {
// station存储temp车次对应的站点信息
station = linesGroupBystation.get(temp);
// 从station中取出已经放入linesGroupBystation车站信息,缓存改车站的名字
// 与刚取出的Map中存储到车站信息进行比较
buffer = (String) ((Map) station.get(0)).get("up");
}
if (buffer.equals(temp)) {
// 如果station中几经存在该站点信息,那么,本站和station中存储到是同一站,所以
// 将同一车次的车站放入一个list中
station.add(map);
} else {
if (station != null && !station.isEmpty()
&& buffer.length() > 0) {
// 将由车次分组后的车站构成的list存入一个map
linesGroupBystation.put(buffer, station);
}
// line重新引用一个新构造的list,以供存储经过另一车站的所有车次
station = new ArrayList<Map>();
station.add(map);// 将同一车次的车站放入刚刚构造的空list中
}
buffer = temp;// 缓存当前操作的车次。
}
return linesGroupBystation;
}
/**
*站点筛选规则:把符合规则的站点添分别放入
*
*@paramstartSta
*@paramwhitherSta
*/
privatevoid getStationsInLine(String startSta, String whitherSta) {
// 获得经过初始站点的所有公交车次
ArrayList firTrainLine = linesOfStation.get(startSta);
// 获得经过所有目的站点的公交车次
ArrayList secTrainLine = linesOfStation.get(whitherSta);
ArrayList station;
HashMap line = null;
int transferStaNo = 0;
// String stationName = null;
String trainNo = "";
if (firTrainLine != null) {
Iterator firIt = firTrainLine.iterator();
while (firIt.hasNext()) {
// 取出一个存储车站信息HashMap
line = (HashMap) firIt.next();
// 取出车次信息
trainNo = (String) line.get("busLine");
transferStaNo = (Integer) line.get("stationNo");
// 取出车次trainNo经过的所有站点信息
station = stationsOfLine.get(trainNo);
Iterator it = station.iterator();
while (it.hasNext()) {
Map map = (Map) it.next();// trainNo's map.
int i = (Integer) map.get("stationNo");
// 筛选站点规则:如果该站点距离初始站点距离比出发站点的距离初始站点的距离大,那么就把该站点存储到
// firLineStaList,反之就做反车了,所以那些站点不必加入firLineStaList中
if (i != transferStaNo) {
//
firLineStaList.add(map);
}
}
}
}
if (secTrainLine != null) {
Iterator secIt = secTrainLine.iterator();
while (secIt.hasNext()) {
line = (HashMap) secIt.next();
trainNo = (String) line.get("busLine");
transferStaNo = (Integer) line.get("stationNo");
station = stationsOfLine.get(trainNo);
Iterator it = station.iterator();
while (it.hasNext()) {
Map map = (Map) it.next();
int i = (Integer) map.get("stationNo");
if (i != transferStaNo) {
secLineStaList.add(map);
}
}
}
}
}
/**
*
*createdate:2008-5-19author:Administrator
*
*@return
*/
private ArrayList<Map> checkCrossLine() {
ArrayList<Map> crossLineList = new ArrayList<Map>();// 相交线路的集合,即是所有的换乘方法的集合
ArrayList<Map> lsStart = firLineStaList;// 经过起点站的所有车次的经停站站信息。
ArrayList<Map> lsEnd = secLineStaList;// 经过目的站的所有车次的经停站站信息。
if (lsStart != null && !lsStart.isEmpty() && lsEnd != null
&& !lsEnd.isEmpty()) {
for (Map<String, String> mapStart : lsStart) {
for (Map<String, String> mapEnd : lsEnd) {
// if (IsInTheSameCity(mapStart.get("up"),
// mapEnd.get("up"))) {
if (mapStart.get("up").equals(mapEnd.get("up"))) {
// 将相交线路信息存入crossLine,存储某一个具体的换乘方法
Map<String, String> crossLine = new HashMap<String, String>(
4, 0.8f);
// 把第一次要做到车次放如crossLine
crossLine.put("firstLine", mapStart.get("busLine"));
// 把要换乘的车次放入到crossLine
crossLine.put("secondLine", mapEnd.get("busLine"));
// 把中转站点放入到crossLine
crossLine.put("transferSta", mapEnd.get("up"));
// crossLine.put("transferSta",(String)startInf.get("up"));
// 将包含相交线路信息的HashMap存入List
// 也即是把具体某个换乘方法放入crossLineList
// if(crossLineList.size()!=0){
// for (int i=0;i<crossLineList.size();i++) {
// if (crossLineList.get(i).get("firstLine").equals(
// crossLine.get("firstLine"))
// && crossLineList.get(i).get("secondLine").equals(
// crossLine.get("secondLine"))) {
// String transfer = (String) crossLineList.get(i)
// .get("transferSta");
// transfer += " 或者 "
// + (String) crossLine.get("transferSta");
// crossLineList.get(i).put("transferSta", transfer);
// } else {
// crossLineList.add(crossLine);
// }
//
// }
// }else{
// crossLineList.add(crossLine);
// }
if (((String) crossLine.get("transferSta")).length() > 0) {
crossLineList.add(crossLine);
}
} else {
continue;
}
}
}
} else {
crossLineList = null;
}
return operateTransferMap(crossLineList);
}
/**
*
*createdate:2008-5-22author:Administrator处理类似问题:比如有两个换乘方法:109到龙泽
*换乘200109到上地换乘200那么把该数据整理为109到龙泽或者上地换乘200
*
*@paramarrList
*@return
*/
public ArrayList<Map> operateTransferMap(ArrayList<Map> arrList) {
ArrayList<Map> arr = new ArrayList<Map>();
for (Map map : arrList) {
if (arr.size() == 0) {
arr.add(map);
} else {
// 记录没把当前中转方法加入arr前的大小
int size = arr.size();
for (int i = 0; i < size; i++) {
if (map.get("firstLine")
.equals(arr.get(i).get("firstLine"))
&& map.get("secondLine").equals(
arr.get(i).get("secondLine"))) {
String temp = (String) map.get("transferSta");
temp += " 或者 " + arr.get(i).get("transferSta");
arr.get(i).put("transferSta", temp);
break;
}
if (i == arr.size() - 1) {
arr.add(map);
}
}
}
}
return arr;
}
privateboolean IsInTheSameCity(String station1, String station2) {
if (station1.contains(station2) || station2.contains(station1)) {
// System.out.println(station1+"#########"+station2);
returntrue;
} else {
returnfalse;
}
}
public ArrayList<Map> getSchemaOfTransfer() {
this.getStationsInLine(this.start, this.whither);
returnthis.checkCrossLine();
}
publicstaticvoid main(String[] args) {
BusTransfer2 tb = new BusTransfer2("","");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedReader br1 = new BufferedReader(
new InputStreamReader(System.in));
String start = "";
String end = "";
//判断输入是否含
ArrayList<String> stations=tb.getStations();
while (true) {
try {
System.out.println("请输入出发站:");
start = br.readLine();
//判断是否退出
if (start.equals("q")){
System.exit(0);
}
//判断是否数据库中是否含有该站信息
while(!stations.contains(start)){
System.out.println("对不起,该站名暂时还没有被我们收录/n请你重新" +
"输入出发站");
start=br.readLine();
if (start.equals("q")){
System.exit(0);
}
}
System.out.println("/n请输入目的站:");
end = br.readLine();
if (end.equals("q")){
System.exit(0);
}
while(!stations.contains(end)){
System.out.println("对不起,该站名暂时还没有被我们收录/n请你重新" +
"输入目的站");
end=br.readLine();
if (end.equals("q")){
System.exit(0);
}
}
System.out.println("现在开始查询/n");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
tb = new BusTransfer2(start, end);
ArrayList nonstop = tb.getNonstopLines(start, end);
if (nonstop.size() > 0) {
System.out.println("您好,您要去的地方有直达公交");
for (int i = 0; i < nonstop.size(); i++) {
System.out.println("/n您可以乘坐" + nonstop.get(i) + "直接到达");
System.out
.println("/n---------------------------------------------/n");
}
} else {
System.out.println("您好,你要去的地方没有直达公交,您可以选择一下换乘方法到达/n");
for (Map map : tb.getSchemaOfTransfer()) {
System.out.println(map);
System.out.println("您好,您可以先乘坐 " + map.get("firstLine")
+ " 到 " + map.get("transferSta") + " 然后换乘 "
+ map.get("secondLine") + " 便可到达,不要错过站吆!");
System.out
.println("/n---------------------------------------------/n");
}
}
}
// tb.getSchemaOfTransfer();
// BusTransfer2 tb = new BusTransfer2("新都", "北京西站");
// for (Map map : tb.getSchemaOfTransfer()) {
// System.out.println(map);
// System.out.println("您好,您可以先乘坐 " + map.get("firstLine") + " 到 "
// + map.get("transferSta") + " 然后换乘 " + map.get("secondLine")
// + " 便可到达,不要错过站吆!");
// System.out
// .println("/n---------------------------------------------/n");
// }
// System.out.println(tb.secLineStaList.size());
}
private Connection getConnection() {
Connection con = null;
String url = "jdbc:mysql://127.0.0.1:3306/souwhat?autoReconnect=true&useUnicode=true&characterEncoding=GBK&mysqlEncoding=GBK";
String user = "root";
String psWord = "";
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("The Exception at load the Driver");
}
try {
con = DriverManager.getConnection(url, user, psWord);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("The Exception at creat the connection");
}
return con;
}
privatevoid closeConnection(Connection conn) throws Exception {
if (conn != null) {
conn.close();
}
}
private List executeQuery(String sql) throws Exception {
// System.out.println("executeQuery(sql): " + sql);
List list = new ArrayList();
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
conn = getConnection();
stmt = conn.createStatement();
System.out.println(sql);
rs = stmt.executeQuery(sql);
ResultSetMetaData rsmd = rs.getMetaData();
while (rs.next()) {
Map map = new HashMap();
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
// 每一行所有列存入HashMap中
map.put(rsmd.getColumnName(i), rs.getObject(i));
}
// 所有行存入List中
list.add(map);
}
} catch (Exception e) {
System.out.println("数据库查询出错!");
e.printStackTrace();
} finally {
if (rs != null)
rs.close();
closeConnection(conn);
}
return list;
}
/**
*得到直达的公交车次createdate:2008-5-22author:Administrator
*
*@return
*/
public ArrayList<String> getNonstopLines(String start, String whither) {
ArrayList<String> arr = new ArrayList<String>();
Set set = stationsOfLine.keySet();
Iterator it = set.iterator();
while (it.hasNext()) {
String line = it.next().toString();
String stations = stationsOfLine.get(line).toString();
if (stations.contains(start) && stations.contains(whither)) {
arr.add(line);
}
}
return arr;
}
}