公交换乘算法.txt

java开发中经常用到的代码

偶5月份写的公交换乘算法： 
公交换乘一站算法busTransfer 
/** 
* 公交换乘一站的算法思想： 
* （注意：车次信息、站点信息、公交信息是等价的都是以HashMap的形式存储信息） 
* 1.从数据库中获得所有公交信息存储到ArrayList，每个具体信息的元数据有三个： 
* 公交车次、公交站点、该公交站点距离该公交车次的始发站点的站数，具体信息用HashMap保存 
* 2.然后把公交信息数据进行结构化，把所有公交站点抽出，再把每一个站点对应的所有车次抽出 
* 与其一一对应，单一的车次信息用HashMap存储，站点对应的所有车次信息用ArrayList存储， 
* 所有的站点有经过站点的车次信息用HashMap存储 
* 3.根据查询要求，分别从结构化以后的公交信息数据中找到，经过出发地的所有车次，经过目的地 
* 的所有车次，然后在分别遍历每个车次，筛选出符合要求的中转站点，筛选规则是：每查询出一个 
* 站点时，得到该站点距离该站点对应车次的始发站的站数，如果这个站数小于查询站点距离该车次的始 
* 发站的站数，那么就符合规则，便把该站点信息保存到符合站点的ArrayList中，反之亦然 
* 4.分别得到查询条件中出发地和目的地的中转站点信息（中转站点信息存储在ArrayList中），然 
* 后遍历两个中转站点信息的集合，得到最终的具体中转信息（最终中转信息也是用ArrayList存储） 
*/ 
package bustransfer; 

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.ResultSet; 
import java.sql.ResultSetMetaData; 
import java.sql.SQLException; 
import java.sql.Statement; 
import java.util.ArrayList; 
import java.util.Iterator; 
import java.util.List; 
import java.util.HashMap; 
import java.util.Map; 

public class BusTransfer { 

        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 BusTransfer(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 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()) { 
                                        // 将由车次分组后的车站构成的list存入一个map 
                                        linesGroupBystation.put(buffer, station); 
                                } 
                                // line重新引用一个新构造的list，以供存储经过另一车站的所有车次 
                                station = new ArrayList <Map>(); 
                                station.add(map);// 将同一车次的车站放入刚刚构造的空list中 
                        } 
                        buffer = temp;// 缓存当前操作的车次。 
                } 
                return linesGroupBystation; 
        } 

  /** 
        * 站点筛选规则：把符合规则的站点添分别放入 
        * 
        * @param startSta 
        * @param whitherSta 
        */ 
        private void 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");