/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // 根据区段获得属于区段内的所有车站信息  并排序
  public void getAllStationInfoByDistrict(String districtName) {

    StationDistrictRelation tableName = new StationDistrictRelation(); // 设置要进行操作的数据库表名
    String sqlStr =
        "select * from stationdistrictrelation where District_name = '" + districtName + "'";

    // 获取区段内所有车站信息
    List<StationDistrictRelation> list =
        databaseAccessHandler.sqlQuery(tableName, "StationDistrictRelation", sqlStr);

    List<StationDistrictRelation> sortedStationDistrictRelationList =
        new ArrayList<StationDistrictRelation>();

    // 对区段内所有车站信息进行排序 : 首站->终点站
    sortedStationDistrictRelationList = this.sortStations(list);

    baseParam.setSortedStationDistrictRelationList(sortedStationDistrictRelationList);
    if (sortedStationDistrictRelationList == null || sortedStationDistrictRelationList.size() == 0)
      return;

    int len = sortedStationDistrictRelationList.size();
    List<String> stationNameList = new ArrayList<String>();
    // 计算区段内站的总距离 和提取车站名
    int sumStationDistance = 0;
    for (int i = 0; i < len; i++) {
      StationDistrictRelation sdr = sortedStationDistrictRelationList.get(i);
      sumStationDistance = sumStationDistance + sdr.getPredistance();
      stationNameList.add(sdr.getStation_name()); // 提取车站名
    }

    BaseParam.setSortedStationNameList(stationNameList);

    baseParam.setSumStationDistance(sumStationDistance);
  }
  public boolean TDCSCommandForRun(String vrTime, String timeStep) { // 此方法对应于教师TDCS界面中选取命令的处理

    TDCSCommandMessage sMsg = new TDCSCommandMessage();

    // AbstractMessage类中定义的字段 通信类别  此数据报所表示的是客户端和服务器代码进行进一步处理的依据
    sMsg.setCommandType(Constants.TYPE_CLIENT_EXPERIMENT_RUN); // 运行
    // sMsg.setCommandType(Constants.TYPE_CLIENT_EXPERIMENT_CLOSE);关闭实验
    // Constants.TYPE_TEACHER_TDCS_START);//启动

    // 设置当前区段名称
    sMsg.setDistrictName(baseParam.getCurrentDistrictName());

    // 下面设置默认的工作模式
    sMsg.setRunMode(Constants.RUN_MODE_AUTO); // 自律模式
    sMsg.setSubjectName(Constants.EXPERIMENT_MODE_TDSI); // 综合实验

    // 设置虚拟时间
    if ((vrTime == null) || (vrTime.length() == 0)) timeStep = "00:00"; // 默认值
    sMsg.setVrTime(vrTime);

    // 设置时间步长
    if ((timeStep == null) || (timeStep.length() == 0)) timeStep = "2"; // 默认值
    sMsg.setTimeStep(timeStep);

    // 向服务器发送开始实验消息
    TDCSCommandMessage rMsg = databaseAccessHandler.TDCSRunCommandToServer(sMsg);

    if (rMsg == null) return false;
    else // 成功
    {
      utilForCurrentTimeAxis.displayTimeOnToolBar(
          rMsg.getVrTime(), rMsg.getCurrentTime(), rMsg.getTimeStep());
      return true;
    }
  }
  //////////////////// 以上的代码是写数据到数据库中//////////////////////////////
  // ********************************************************************************************************//
  //////////////////// 以下的代码是从数据库中读取内容//////////////////////////////
  ///////////////////////////////////////////////////////////////////////////////////////////////
  // 获取所有区段信息
  public void getAllDistrictInfo() {
    District tableName = new District();
    String sqlStr = "select * from District";

    List<District> list = databaseAccessHandler.sqlQuery(tableName, "District", sqlStr);

    baseParam.setAllDistrictName(list);

    // 测试代码
    // getAllPlanTrainInfoByDistrict("北京-呼和浩特");
  }
  public void TDCSCommandForStop() { // 关闭实验

    TDCSCommandMessage sMsg = new TDCSCommandMessage();

    // AbstractMessage类中定义的字段 通信类别  此数据报所表示的是客户端和服务器代码进行进一步处理的依据
    sMsg.setCommandType(Constants.TYPE_CLIENT_EXPERIMENT_CLOSE); // 关闭实验

    // 设置当前区段名称
    sMsg.setDistrictName(baseParam.getCurrentDistrictName());

    databaseAccessHandler.TDCSCloseCommandToServer(sMsg);
  }
  // 发送改动后的车次信息到服务器
  public void TDCSCommandForTrain() {
    TeamTdcsRsbMessage sMsg = new TeamTdcsRsbMessage();

    switch (BaseParam.getOperationType()) {
      case Constants.TDCS_TRAIN_TYPE_DELETE: // 删除车次
        sMsg.setCommandType(Constants.TYPE_CLIENT_ZNTDCS_DELETE);
        break;
      case Constants.TDCS_TRAIN_TYPE_NEW: // 添加新车次
        sMsg.setCommandType(Constants.TYPE_CLIENT_ZNTDCS_ADD);
        break;
      case Constants.TDCS_MENU_TOOL_RECTANGLE_ADJUST: // 调整车次的发车或到站时间
        sMsg.setCommandType(Constants.TYPE_CLIENT_ZNTDCS_ADJUST);
        break;
    }
    sMsg.setTeamID(BaseParam.getTeamID()); // 组编号

    // 车次信息
    List<TDCSPlan> trainPlan = BaseParam.getTdcsTrainList();
    sMsg.setTrainPlan(JsonUtil.list2json(trainPlan));

    databaseAccessHandler.TDCSCommandForTrainToServer(sMsg);
  }
  // 根据区段获得属于区段内的所有计划车次信息
  public void getAllPlanTrainInfoByDistrict(String districtName) {

    // ORDER BY 记录将按照默认的升序进行排列(即:从1到9,从a到z)使用DESC 数据按照降序排列
    Plan tableName = new Plan(); // 设置要进行操作的数据库表名
    String sqlStr =
        "select * from plan where District_name = '"
            + districtName
            + "' ORDER BY Plan_arrivestationtime,Plan_leavestationtime";

    // 从plan表中获取区段内所有车次信息 已经按照到站和离站时间排好序
    List<Plan> planTrainList = databaseAccessHandler.sqlQuery(tableName, "Plan", sqlStr);

    //////////////////////////////////////////////////////////////////
    // 从TrainDistrictRelation表中获取区段内所有车次信息,仅有车次信息  原来的
    // List<TrainDistrictRelation> trainNameList =
    // getAllTrainDistrictRelationByDistrict(districtName);
    // 从Train表中获取区段内所有车次信息
    List<Train> trainNameList = getAllTrainsByDistrict(districtName);

    if (trainNameList == null || trainNameList.size() == 0) return;

    // 对trainNameList进行加工,方便getTrainDirectionByTrainName方法的执行,提高效率
    Iterator<Train> it = trainNameList.iterator();
    while (it.hasNext()) {
      Train data = (Train) it.next();
      trainNameDirectionMap.put(data.getTrain_name(), data.getTrain_direction());
    }
    baseParam.setTrainNameDirectionMap(trainNameDirectionMap);

    // 对每一个车站,获取经过的所有车次信息,并自动排序
    sortPlanTrainForStation(planTrainList);

    // 转换格式
    int len = trainNameList.size();
    // 每次执行,仅对一个车次的信息的进行操作
    for (int i = 0; i < len; i++) {
      String trainName = trainNameList.get(i).getTrain_name();

      // 依据车次trainName按照车站的先后顺序对本车次进行排序  首站->终点站
      List<Plan> sortPlanTrainList = sortPlanTrainList(planTrainList, trainName);

      // 依据车次trainName,对排好序的车次详细信息进行加工,使之用于屏幕绘图
      setTrainPlanFromatList(sortPlanTrainList, trainName);
    }

    // 将车次信息添加到tdcsDataset的TrainList中
    for (int i = 0; i < len; i++) {
      String trainName = trainNameList.get(i).getTrain_name();
      trainNameExist(trainName); // 判断trainName是否已经存在
    }
  }
  // 判断trainName是否存在
  private void trainNameExist(String trainName) {

    boolean existFlag = false;
    List<String> trainNameList = baseParam.getTrainNameList();

    if (trainNameList == null || trainNameList.size() == 0) existFlag = false;
    else {
      for (int i = 0; i < trainNameList.size(); i++) {
        if (trainNameList.get(i).equalsIgnoreCase(trainName)) { // 如果存在
          existFlag = true;
          break;
        }
      }
    }
    // 如果不存在
    if (!existFlag) { // 车次名称
      baseParam.appendTrainNameList(trainName);
      // 车次本身信息
      LineFigure trainList = new LineFigure();
      trainList.setTrainName(trainName); // 设置车次信息List的trainName
      trainList.setTrainDirection(getTrainDirectionByTrainName(trainName)); // 设置车次的方向
      baseParam.appendTrainList(trainList);
    }
  }
  // 将排序后的sortPlanTrainList中的plan数据转化为可以直接画图的TrainDrawFromat格式数据
  // 执行一次,只能实现对某一车次的运营计划的数据进行格式化
  private void setTrainPlanFromatList(List<Plan> list, String trainName) {

    if ((list == null) || (list.size() == 0) || (trainName.length() == 0)) {
      return;
    }
    Plan plan = new Plan();
    Plan planStation = new Plan();
    Plan planNextStation = new Plan();
    FromatedTrain trainDrawFromat = new FromatedTrain();
    int len = list.size();
    for (int i = 0; i < len; i++) { // for2
      plan = list.get(i);
      if (plan.getTrain_name().equalsIgnoreCase(trainName)) { // if语句1
        planStation = plan;
        // System.out.println("转换格式函数:i = " + i);
        for (int j = i + 1; j < len; j++) { // for 1
          plan = list.get(j);
          if (plan.getTrain_name().equalsIgnoreCase(trainName)) {

            planNextStation = plan;

            trainDrawFromat = new FromatedTrain();
            trainDrawFromat.setTrainName(trainName); // 设置车次
            trainDrawFromat.setStationName(planStation.getStation_name()); // 设置本站名称
            trainDrawFromat.setNextStationName(planNextStation.getStation_name()); // 设置下一站名称

            // 设置本站出发时间    时:分:秒 转换为分
            String leaveTimeStr = planStation.getPlan_leavestationtime();
            trainDrawFromat.setStationTimeX(UtilForTime2X.timeToX(leaveTimeStr));

            // 设置下站到站时间
            String arriveTimeStr = planNextStation.getPlan_arrivestationtime();
            trainDrawFromat.setNextStationTimeX(UtilForTime2X.timeToX(arriveTimeStr));

            // System.out.println("车次:" + trainDrawFromat.getTrainName() + "  发站:" +  leaveTimeStr +
            // " 到站:" +  arriveTimeStr  );

            baseParam.appendTrainPlanFromatList(trainDrawFromat);

            planStation = planNextStation;
          }
        } // for1
        break; // 退出循环
      } // if 语句1
    } // for2
  }
  // 对每一个车站,获取经过的所有车次信息,并按到站/离站时间升序排列
  // 从数据库读的车次信息 已经按照到站和离站时间排好序
  private void sortPlanTrainForStation(List<Plan> planList) {
    // 临时保存车站名和经过该车站的所有车次信息(添加过程中,系统按找车次的到达时间自动排序)
    Map<String, TreeSet<SortedTrain>> stationTrainDownMap =
        new HashMap<String, TreeSet<SortedTrain>>(); // 保存下行
    Map<String, TreeSet<SortedTrain>> stationTrainUpMap =
        new HashMap<String, TreeSet<SortedTrain>>(); // 保存上行

    // 获取已经排好序的车站列表
    List<String> sortedStationNameList = new ArrayList<String>();

    sortedStationNameList = BaseParam.getSortedStationNameList();

    if ((planList == null)
        || (sortedStationNameList == null)
        || (planList.size() == 0)
        || (sortedStationNameList.size() == 0)) return;

    Plan plan = new Plan();
    int planLength = planList.size();
    int stationLength = sortedStationNameList.size();
    String firstStation = sortedStationNameList.get(0);
    String lastStation = sortedStationNameList.get(stationLength - 1);

    for (int i = 0; i < stationLength; i++) { // 对所有车站
      TreeSet<SortedTrain> treeSetDown = new TreeSet<SortedTrain>();
      TreeSet<SortedTrain> treeSetUp = new TreeSet<SortedTrain>();

      String sortedStationName = sortedStationNameList.get(i);
      // int timeType = Constants.TDCS_TIME_TYPE_ARRIVEAL;
      String trainName = "";
      for (int j = 0; j < planLength; j++) { // 某一车站的所有车次

        plan = planList.get(j);
        if (sortedStationName.equalsIgnoreCase(plan.getStation_name())) {
          trainName = plan.getTrain_name();
          /*数据库中时间格式(字符串):00:00:00 //plan.getPlan_arrivestationtime()
           转换后时间格式(整数):000,单位 分钟 //TimeX_x.timeToX
          */
          int arriveTime = UtilForTime2X.timeToX(plan.getPlan_arrivestationtime());
          int leaveTime = UtilForTime2X.timeToX(plan.getPlan_leavestationtime());
          int trainDirection = getTrainDirectionByTrainName(trainName);
          int typeFlag = Constants.TDCS_TRAIN_TYPE_NO;
          SortedTrain sortedPlan = null;
          if (trainDirection == 1) // 车次方向  下行1
          {
            if (!firstStation.equalsIgnoreCase(plan.getStation_name())) { // 首站 不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_ARRIVEAL,
                      arriveTime); // time是到站时间
              treeSetDown.add(sortedPlan);
            }
            if (!lastStation.equalsIgnoreCase(plan.getStation_name())) { // 终点站 不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_LEAVE,
                      leaveTime); // time是离站时间
              treeSetDown.add(sortedPlan);
            }
          } else if (trainDirection == 0) // 车次方向(上行0)
          {
            if (!lastStation.equalsIgnoreCase(plan.getStation_name())) { // 首站  不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_ARRIVEAL,
                      arriveTime); // time是到站时间
              treeSetUp.add(sortedPlan);
            }

            if (!firstStation.equalsIgnoreCase(plan.getStation_name())) { // 终点站 不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_LEAVE,
                      leaveTime); // time是离站时间
              treeSetUp.add(sortedPlan);
            }
          }
        }

        if (!treeSetDown.isEmpty()) {
          stationTrainDownMap.put(sortedStationName, treeSetDown);
        }
        if (!treeSetUp.isEmpty()) {
          stationTrainUpMap.put(sortedStationName, treeSetUp);
        }
      } // 某一车站的所有车次 for
    } // 对所有车站
    UtilForMouseAction.setStationTrainDownMap(stationTrainDownMap);
    UtilForMouseAction.setStationTrainUpMap(stationTrainUpMap);
  }
Esempio n. 10
0
public class DatabaseServer {

  private static DatabaseServer thisData = null;

  public static DatabaseServer getInstance() {
    if (thisData == null) {
      thisData = new DatabaseServer();
    }
    return thisData;
  }

  public DatabaseServer() {}

  ///////////////////////////////////////////////////////////////////////////////////////
  private static BaseParam baseParam = BaseParam.getInstance();
  private UtilForCurrentTimeAxis utilForCurrentTimeAxis =
      new UtilForCurrentTimeAxis().getInstance();
  private DatabaseAccessHandler databaseAccessHandler = new DatabaseAccessHandler().getInstance();

  // ********************************************************************************************************//
  ////////////////// 以下代码是供发有关命令到服务器使用//////////////////////////////
  // 从服务器获取组的名称或组内成员名称
  public String[] getTeamORMemberNameFromServer(int flag, String teamID) {

    TDCSCommandMessage sMsg = new TDCSCommandMessage();
    sMsg.setDistrictName(teamID);
    sMsg.setCommandType(flag);

    return databaseAccessHandler.getTeamORMemberNameFromServer(sMsg);
  }

  // 向服务器发送故障或调度命令
  public boolean sendScheduleORErrorCommandToServer(
      int CommandType, int teamID, String name, String content) {

    // hu 2010-11-2 修改
    // ScheduleErrorMessage sMsg = new ScheduleErrorMessage();
    CommonMessage cMsg = new CommonMessage();
    cMsg.setTeamID(teamID);
    if (name.equalsIgnoreCase("TDCS")) {
      cMsg.setCommandType(Constants.TYPE_DDZR_TO_ZNTDCS_ASYN);
    } else if (name.equalsIgnoreCase("CTC")) {
      cMsg.setCommandType(Constants.TYPE_DDZR_TO_ZNCTC_ASYN);
    } else if (name.equalsIgnoreCase("电务维修机")) { // 电务
      cMsg.setCommandType(Constants.TYPE_DDZR_TO_DW_ASYN);
    } else {
      cMsg.setCommandType(Constants.TYPE_DDZR_TO_SICS_ASYN);
      cMsg.setStationName(name);
    }

    ScheduleErrorMessage sMsg = new ScheduleErrorMessage();
    sMsg.setContent(content);
    sMsg.setTeamID(teamID);

    cMsg.setMeseageName("ScheduleErrorMessage");
    cMsg.setMessage(JsonUtil.bean2json(sMsg));

    databaseAccessHandler.sendCommonMessageToServer(cMsg);

    return true;
  }

  public boolean TDCSCommandForRun(String vrTime, String timeStep) { // 此方法对应于教师TDCS界面中选取命令的处理

    TDCSCommandMessage sMsg = new TDCSCommandMessage();

    // AbstractMessage类中定义的字段 通信类别  此数据报所表示的是客户端和服务器代码进行进一步处理的依据
    sMsg.setCommandType(Constants.TYPE_CLIENT_EXPERIMENT_RUN); // 运行
    // sMsg.setCommandType(Constants.TYPE_CLIENT_EXPERIMENT_CLOSE);关闭实验
    // Constants.TYPE_TEACHER_TDCS_START);//启动

    // 设置当前区段名称
    sMsg.setDistrictName(baseParam.getCurrentDistrictName());

    // 下面设置默认的工作模式
    sMsg.setRunMode(Constants.RUN_MODE_AUTO); // 自律模式
    sMsg.setSubjectName(Constants.EXPERIMENT_MODE_TDSI); // 综合实验

    // 设置虚拟时间
    if ((vrTime == null) || (vrTime.length() == 0)) timeStep = "00:00"; // 默认值
    sMsg.setVrTime(vrTime);

    // 设置时间步长
    if ((timeStep == null) || (timeStep.length() == 0)) timeStep = "2"; // 默认值
    sMsg.setTimeStep(timeStep);

    // 向服务器发送开始实验消息
    TDCSCommandMessage rMsg = databaseAccessHandler.TDCSRunCommandToServer(sMsg);

    if (rMsg == null) return false;
    else // 成功
    {
      utilForCurrentTimeAxis.displayTimeOnToolBar(
          rMsg.getVrTime(), rMsg.getCurrentTime(), rMsg.getTimeStep());
      return true;
    }
  }

  // 发送改动后的车次信息到服务器
  public void TDCSCommandForTrain() {
    TeamTdcsRsbMessage sMsg = new TeamTdcsRsbMessage();

    switch (BaseParam.getOperationType()) {
      case Constants.TDCS_TRAIN_TYPE_DELETE: // 删除车次
        sMsg.setCommandType(Constants.TYPE_CLIENT_ZNTDCS_DELETE);
        break;
      case Constants.TDCS_TRAIN_TYPE_NEW: // 添加新车次
        sMsg.setCommandType(Constants.TYPE_CLIENT_ZNTDCS_ADD);
        break;
      case Constants.TDCS_MENU_TOOL_RECTANGLE_ADJUST: // 调整车次的发车或到站时间
        sMsg.setCommandType(Constants.TYPE_CLIENT_ZNTDCS_ADJUST);
        break;
    }
    sMsg.setTeamID(BaseParam.getTeamID()); // 组编号

    // 车次信息
    List<TDCSPlan> trainPlan = BaseParam.getTdcsTrainList();
    sMsg.setTrainPlan(JsonUtil.list2json(trainPlan));

    databaseAccessHandler.TDCSCommandForTrainToServer(sMsg);
  }

  public void TDCSCommandForStop() { // 关闭实验

    TDCSCommandMessage sMsg = new TDCSCommandMessage();

    // AbstractMessage类中定义的字段 通信类别  此数据报所表示的是客户端和服务器代码进行进一步处理的依据
    sMsg.setCommandType(Constants.TYPE_CLIENT_EXPERIMENT_CLOSE); // 关闭实验

    // 设置当前区段名称
    sMsg.setDistrictName(baseParam.getCurrentDistrictName());

    databaseAccessHandler.TDCSCloseCommandToServer(sMsg);
  }

  ////////////////// 以上代码是供发有关命令到服务器使用//////////////////////////////
  // ********************************************************************************************************//
  ////////////////// 以下代码是写数据到数据库中//////////////////////////////

  /*
   本方法是针对教师的,如果对学生,只需将plan表更改为dispatch表,当然需要增加一些字段
  */
  public boolean batchUpdateFromTDCSForTeacher(
      Map<String, PlanForStatics> insertTrainDistrictMap,
      Map<String, PlanForStatics> deleteTrainDistrictMap,
      Map<TrainStation, PlanForStatics> insertPlanMap, // plan表插入
      Map<TrainStationTime, TrainPlan> updatePlanMap, // plan表更新
      String firstStation,
      String lastStation) {
    int insertLen = insertTrainDistrictMap.size();
    int deleteLen = deleteTrainDistrictMap.size();
    int insertPlanLen = insertPlanMap.size();
    int updatePlanLen = updatePlanMap.size();

    String[] sqlArray =
        new String[(deleteLen * 3) + (insertLen * 2) + insertPlanLen + updatePlanLen];

    int rowNumber = 0;
    String zeroTimeStr = "00:00:00";

    // 组装插入记录
    if (insertLen != 0) { // 存在元素
      for (String key : insertTrainDistrictMap.keySet()) {
        PlanForStatics info = insertTrainDistrictMap.get(key);

        /*表TrainDistrictRelation  关键字: Train_name  车次名称, District_name 区段名称 */
        String inertStr =
            "insert into TrainDistrictRelation(District_name,Train_name) Values('"
                + info.getDistrictName()
                + "','"
                + key
                + "');";
        sqlArray[rowNumber++] = inertStr;

        /*Train表  关键字:Train_name
        Train_name 车次名称,Train_direction 车次方向(上行0和下行1)Train_maxspeed 车最大速度'
        Train_startstationname始发站名称',Train_endstationname 到达站名称'*/
        inertStr =
            "insert into Train(Train_name,Train_direction,Train_startstationname,Train_endstationname) Values('"
                + key
                + "',"
                + info.getTrainDirection()
                + ",'"
                + firstStation
                + "','"
                + lastStation
                + "');";
        sqlArray[rowNumber++] = inertStr;

        //	System.out.println(inertStr);
      }
    }

    // 对于plan需要单独处理,因为plan表所保存的内容是以车站和车次为关键字,即同一个车次在不同车站的状态都要保存
    if (insertPlanLen != 0) { // 存在元素
      for (TrainStation key : insertPlanMap.keySet()) {
        /*Plan表     关键字:Train_name   Station_name
        Train_name 车次名称, District_name 区段名称' Prestation_name'前站站名',Station_name 本站站名',
                 Plan_arrivestationtime 到站时间', Plan_leavestationtime 离站时间',*/

        String trainName = key.getTrainName();
        PlanForStatics info = insertPlanMap.get(key);

        String arriveTime = info.getArriveTime();
        String leaveTime = info.getLeaveTime();
        if (leaveTime == null) leaveTime = zeroTimeStr;
        if (arriveTime == null) arriveTime = zeroTimeStr;

        String inertStr =
            "insert into Plan(District_name,Train_name,Prestation_name,Station_name,Plan_arrivestationtime,Plan_leavestationtime) Values('"
                + info.getDistrictName()
                + "','"
                + trainName
                + "','"
                + info.getPrestationName()
                + "','"
                + info.getStationName()
                + "','"
                + arriveTime
                + "','"
                + leaveTime
                + "')";
        sqlArray[rowNumber++] = inertStr;

        //	System.out.println(inertStr);
      }
    }

    // 对于plan需要单独处理,因为plan表所保存的内容是以车站和车次为关键字,即同一个车次在不同车站的状态都要保存
    if (updatePlanLen != 0) { // 存在元素
      for (TrainStationTime key : updatePlanMap.keySet()) {
        int timeType = key.getTypeTime();

        TrainPlan value = updatePlanMap.get(key);
        String fixStr =
            "' where Train_name='"
                + key.getTrainName()
                + "' and Station_name='"
                + key.getStationName()
                + "';";
        String updateStr = "";

        if (timeType == Constants.TDCS_TIME_TYPE_ARRIVEAL) // 到站时间
        {
          updateStr = "update Plan set Plan_arrivestationtime='" + value.getTime() + fixStr;
        } else if (timeType == Constants.TDCS_TIME_TYPE_LEAVE) // 离站时间
        {
          updateStr = "update Plan set Plan_leavestationtime='" + value.getTime() + fixStr;
        }
        sqlArray[rowNumber++] = updateStr;

        //	System.out.println(updateStr);
      }
    }

    // 组装删除记录
    if (deleteLen != 0) { // 存在元素

      for (String key : deleteTrainDistrictMap.keySet()) {
        PlanForStatics info = deleteTrainDistrictMap.get(key);

        // TrainDistrictRelation表
        String deleteStr =
            "delete from TrainDistrictRelation where District_name='"
                + info.getDistrictName()
                + "' and Train_name='"
                + key
                + "';";
        sqlArray[rowNumber++] = deleteStr;

        // Train表
        deleteStr = "delete from Train where Train_name='" + key + "';";
        sqlArray[rowNumber++] = deleteStr;

        // Plan表
        deleteStr = "delete from Plan where Train_name='" + key + "';";
        sqlArray[rowNumber++] = deleteStr;

        // System.out.println(deleteStr);
      }
    }
    // NODEFINE 表示无须指定表名,实际上此字段可以去掉。
    boolean result = databaseAccessHandler.updateQuery("NODEFINE", sqlArray);
    // System.out.println("result::"+result);
    return result;
  }

  //////////////////// 以上的代码是写数据到数据库中//////////////////////////////
  // ********************************************************************************************************//
  //////////////////// 以下的代码是从数据库中读取内容//////////////////////////////
  ///////////////////////////////////////////////////////////////////////////////////////////////
  // 获取所有区段信息
  public void getAllDistrictInfo() {
    District tableName = new District();
    String sqlStr = "select * from District";

    List<District> list = databaseAccessHandler.sqlQuery(tableName, "District", sqlStr);

    baseParam.setAllDistrictName(list);

    // 测试代码
    // getAllPlanTrainInfoByDistrict("北京-呼和浩特");
  }

  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // 根据区段获得属于区段内的所有车站信息  并排序
  public void getAllStationInfoByDistrict(String districtName) {

    StationDistrictRelation tableName = new StationDistrictRelation(); // 设置要进行操作的数据库表名
    String sqlStr =
        "select * from stationdistrictrelation where District_name = '" + districtName + "'";

    // 获取区段内所有车站信息
    List<StationDistrictRelation> list =
        databaseAccessHandler.sqlQuery(tableName, "StationDistrictRelation", sqlStr);

    List<StationDistrictRelation> sortedStationDistrictRelationList =
        new ArrayList<StationDistrictRelation>();

    // 对区段内所有车站信息进行排序 : 首站->终点站
    sortedStationDistrictRelationList = this.sortStations(list);

    baseParam.setSortedStationDistrictRelationList(sortedStationDistrictRelationList);
    if (sortedStationDistrictRelationList == null || sortedStationDistrictRelationList.size() == 0)
      return;

    int len = sortedStationDistrictRelationList.size();
    List<String> stationNameList = new ArrayList<String>();
    // 计算区段内站的总距离 和提取车站名
    int sumStationDistance = 0;
    for (int i = 0; i < len; i++) {
      StationDistrictRelation sdr = sortedStationDistrictRelationList.get(i);
      sumStationDistance = sumStationDistance + sdr.getPredistance();
      stationNameList.add(sdr.getStation_name()); // 提取车站名
    }

    BaseParam.setSortedStationNameList(stationNameList);

    baseParam.setSumStationDistance(sumStationDistance);
  }

  // 对list序列进行排序 首站->终点站
  private List<StationDistrictRelation> sortStations(List<StationDistrictRelation> list) {

    List<StationDistrictRelation> sortedList = new ArrayList<StationDistrictRelation>();

    if ((list == null) || (list.size() == 0)) {
      return null;
    }
    StationDistrictRelation sdr = new StationDistrictRelation();
    int listLength = list.size();
    String preStationName = "";

    // 查找区段内首站,即第一个车站
    for (int i = 0; i < listLength; i++) {
      sdr = list.get(i);
      String stationName = sdr.getStation_name();
      if (stationName.equalsIgnoreCase(sdr.getPrestation_name())) {
        preStationName = stationName;
        sortedList.add(sdr);
        break;
      }
    }

    // 没有找到首站
    if (preStationName.length() == 0) {
      return null;
    }
    // 依据首站 依次查找区段内其他站
    for (int i = 0; i < listLength; i++) {
      sdr = list.get(i);
      if (sdr.getStation_name().equalsIgnoreCase(sdr.getPrestation_name())) { // 首站
        continue;
      }
      for (int j = 0; j < listLength; j++) {
        sdr = list.get(j);
        String stationName = sdr.getStation_name();
        if (stationName.equalsIgnoreCase(sdr.getPrestation_name())) { // 首站
          continue;
        } else // 非首站
        if (preStationName.equalsIgnoreCase(sdr.getPrestation_name())) {
          preStationName = stationName;
          sortedList.add(sdr);
        }
      }
    }
    return sortedList;
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  // 根据区段 从TrainDistrictRelation表获得属于区段内的所有计划车次信息 仅含车次信息  目前不用
  private List<TrainDistrictRelation> getAllTrainDistrictRelationByDistrict(String districtName) {
    TrainDistrictRelation tableName = new TrainDistrictRelation(); // 设置要进行操作的数据库表名
    String sqlStr =
        "select * from Traindistrictrelation where District_name = '" + districtName + "'";
    List<TrainDistrictRelation> trainNameList =
        databaseAccessHandler.sqlQuery(tableName, "TrainDistrictRelation", sqlStr);
    return trainNameList;
  }

  private List<Train> getAllTrainsByDistrict(String districtName) {
    Train tableName = new Train(); // 设置要进行操作的数据库表名
    String sqlStr =
        "select * from Train where Train.Train_name in "
            + "(select Train_name from Traindistrictrelation where District_name='"
            + districtName
            + "')";
    List<Train> trainList = databaseAccessHandler.sqlQuery(tableName, "Train", sqlStr);
    return trainList;
  }

  // 返回车次的方向(上行0,下行1)
  private int getTrainDirectionByTrainName(String trainName) {
    if ((trainNameDirectionMap == null)
        || (trainNameDirectionMap.size() == 0)
        || (!trainNameDirectionMap.containsKey(trainName))) return -1;
    else {
      return trainNameDirectionMap.get(trainName);
    }
  }

  private Map<String, Integer> trainNameDirectionMap = new HashMap<String, Integer>();

  // 根据区段获得属于区段内的所有计划车次信息
  public void getAllPlanTrainInfoByDistrict(String districtName) {

    // ORDER BY 记录将按照默认的升序进行排列(即:从1到9,从a到z)使用DESC 数据按照降序排列
    Plan tableName = new Plan(); // 设置要进行操作的数据库表名
    String sqlStr =
        "select * from plan where District_name = '"
            + districtName
            + "' ORDER BY Plan_arrivestationtime,Plan_leavestationtime";

    // 从plan表中获取区段内所有车次信息 已经按照到站和离站时间排好序
    List<Plan> planTrainList = databaseAccessHandler.sqlQuery(tableName, "Plan", sqlStr);

    //////////////////////////////////////////////////////////////////
    // 从TrainDistrictRelation表中获取区段内所有车次信息,仅有车次信息  原来的
    // List<TrainDistrictRelation> trainNameList =
    // getAllTrainDistrictRelationByDistrict(districtName);
    // 从Train表中获取区段内所有车次信息
    List<Train> trainNameList = getAllTrainsByDistrict(districtName);

    if (trainNameList == null || trainNameList.size() == 0) return;

    // 对trainNameList进行加工,方便getTrainDirectionByTrainName方法的执行,提高效率
    Iterator<Train> it = trainNameList.iterator();
    while (it.hasNext()) {
      Train data = (Train) it.next();
      trainNameDirectionMap.put(data.getTrain_name(), data.getTrain_direction());
    }
    baseParam.setTrainNameDirectionMap(trainNameDirectionMap);

    // 对每一个车站,获取经过的所有车次信息,并自动排序
    sortPlanTrainForStation(planTrainList);

    // 转换格式
    int len = trainNameList.size();
    // 每次执行,仅对一个车次的信息的进行操作
    for (int i = 0; i < len; i++) {
      String trainName = trainNameList.get(i).getTrain_name();

      // 依据车次trainName按照车站的先后顺序对本车次进行排序  首站->终点站
      List<Plan> sortPlanTrainList = sortPlanTrainList(planTrainList, trainName);

      // 依据车次trainName,对排好序的车次详细信息进行加工,使之用于屏幕绘图
      setTrainPlanFromatList(sortPlanTrainList, trainName);
    }

    // 将车次信息添加到tdcsDataset的TrainList中
    for (int i = 0; i < len; i++) {
      String trainName = trainNameList.get(i).getTrain_name();
      trainNameExist(trainName); // 判断trainName是否已经存在
    }
  }
  // 对每一个车站,获取经过的所有车次信息,并按到站/离站时间升序排列
  // 从数据库读的车次信息 已经按照到站和离站时间排好序
  private void sortPlanTrainForStation(List<Plan> planList) {
    // 临时保存车站名和经过该车站的所有车次信息(添加过程中,系统按找车次的到达时间自动排序)
    Map<String, TreeSet<SortedTrain>> stationTrainDownMap =
        new HashMap<String, TreeSet<SortedTrain>>(); // 保存下行
    Map<String, TreeSet<SortedTrain>> stationTrainUpMap =
        new HashMap<String, TreeSet<SortedTrain>>(); // 保存上行

    // 获取已经排好序的车站列表
    List<String> sortedStationNameList = new ArrayList<String>();

    sortedStationNameList = BaseParam.getSortedStationNameList();

    if ((planList == null)
        || (sortedStationNameList == null)
        || (planList.size() == 0)
        || (sortedStationNameList.size() == 0)) return;

    Plan plan = new Plan();
    int planLength = planList.size();
    int stationLength = sortedStationNameList.size();
    String firstStation = sortedStationNameList.get(0);
    String lastStation = sortedStationNameList.get(stationLength - 1);

    for (int i = 0; i < stationLength; i++) { // 对所有车站
      TreeSet<SortedTrain> treeSetDown = new TreeSet<SortedTrain>();
      TreeSet<SortedTrain> treeSetUp = new TreeSet<SortedTrain>();

      String sortedStationName = sortedStationNameList.get(i);
      // int timeType = Constants.TDCS_TIME_TYPE_ARRIVEAL;
      String trainName = "";
      for (int j = 0; j < planLength; j++) { // 某一车站的所有车次

        plan = planList.get(j);
        if (sortedStationName.equalsIgnoreCase(plan.getStation_name())) {
          trainName = plan.getTrain_name();
          /*数据库中时间格式(字符串):00:00:00 //plan.getPlan_arrivestationtime()
           转换后时间格式(整数):000,单位 分钟 //TimeX_x.timeToX
          */
          int arriveTime = UtilForTime2X.timeToX(plan.getPlan_arrivestationtime());
          int leaveTime = UtilForTime2X.timeToX(plan.getPlan_leavestationtime());
          int trainDirection = getTrainDirectionByTrainName(trainName);
          int typeFlag = Constants.TDCS_TRAIN_TYPE_NO;
          SortedTrain sortedPlan = null;
          if (trainDirection == 1) // 车次方向  下行1
          {
            if (!firstStation.equalsIgnoreCase(plan.getStation_name())) { // 首站 不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_ARRIVEAL,
                      arriveTime); // time是到站时间
              treeSetDown.add(sortedPlan);
            }
            if (!lastStation.equalsIgnoreCase(plan.getStation_name())) { // 终点站 不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_LEAVE,
                      leaveTime); // time是离站时间
              treeSetDown.add(sortedPlan);
            }
          } else if (trainDirection == 0) // 车次方向(上行0)
          {
            if (!lastStation.equalsIgnoreCase(plan.getStation_name())) { // 首站  不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_ARRIVEAL,
                      arriveTime); // time是到站时间
              treeSetUp.add(sortedPlan);
            }

            if (!firstStation.equalsIgnoreCase(plan.getStation_name())) { // 终点站 不处理
              sortedPlan =
                  new SortedTrain(
                      typeFlag,
                      trainName,
                      trainDirection,
                      Constants.TDCS_TIME_TYPE_LEAVE,
                      leaveTime); // time是离站时间
              treeSetUp.add(sortedPlan);
            }
          }
        }

        if (!treeSetDown.isEmpty()) {
          stationTrainDownMap.put(sortedStationName, treeSetDown);
        }
        if (!treeSetUp.isEmpty()) {
          stationTrainUpMap.put(sortedStationName, treeSetUp);
        }
      } // 某一车站的所有车次 for
    } // 对所有车站
    UtilForMouseAction.setStationTrainDownMap(stationTrainDownMap);
    UtilForMouseAction.setStationTrainUpMap(stationTrainUpMap);
  }

  // 判断trainName是否存在
  private void trainNameExist(String trainName) {

    boolean existFlag = false;
    List<String> trainNameList = baseParam.getTrainNameList();

    if (trainNameList == null || trainNameList.size() == 0) existFlag = false;
    else {
      for (int i = 0; i < trainNameList.size(); i++) {
        if (trainNameList.get(i).equalsIgnoreCase(trainName)) { // 如果存在
          existFlag = true;
          break;
        }
      }
    }
    // 如果不存在
    if (!existFlag) { // 车次名称
      baseParam.appendTrainNameList(trainName);
      // 车次本身信息
      LineFigure trainList = new LineFigure();
      trainList.setTrainName(trainName); // 设置车次信息List的trainName
      trainList.setTrainDirection(getTrainDirectionByTrainName(trainName)); // 设置车次的方向
      baseParam.appendTrainList(trainList);
    }
  }

  // 将排序后的sortPlanTrainList中的plan数据转化为可以直接画图的TrainDrawFromat格式数据
  // 执行一次,只能实现对某一车次的运营计划的数据进行格式化
  private void setTrainPlanFromatList(List<Plan> list, String trainName) {

    if ((list == null) || (list.size() == 0) || (trainName.length() == 0)) {
      return;
    }
    Plan plan = new Plan();
    Plan planStation = new Plan();
    Plan planNextStation = new Plan();
    FromatedTrain trainDrawFromat = new FromatedTrain();
    int len = list.size();
    for (int i = 0; i < len; i++) { // for2
      plan = list.get(i);
      if (plan.getTrain_name().equalsIgnoreCase(trainName)) { // if语句1
        planStation = plan;
        // System.out.println("转换格式函数:i = " + i);
        for (int j = i + 1; j < len; j++) { // for 1
          plan = list.get(j);
          if (plan.getTrain_name().equalsIgnoreCase(trainName)) {

            planNextStation = plan;

            trainDrawFromat = new FromatedTrain();
            trainDrawFromat.setTrainName(trainName); // 设置车次
            trainDrawFromat.setStationName(planStation.getStation_name()); // 设置本站名称
            trainDrawFromat.setNextStationName(planNextStation.getStation_name()); // 设置下一站名称

            // 设置本站出发时间    时:分:秒 转换为分
            String leaveTimeStr = planStation.getPlan_leavestationtime();
            trainDrawFromat.setStationTimeX(UtilForTime2X.timeToX(leaveTimeStr));

            // 设置下站到站时间
            String arriveTimeStr = planNextStation.getPlan_arrivestationtime();
            trainDrawFromat.setNextStationTimeX(UtilForTime2X.timeToX(arriveTimeStr));

            // System.out.println("车次:" + trainDrawFromat.getTrainName() + "  发站:" +  leaveTimeStr +
            // " 到站:" +  arriveTimeStr  );

            baseParam.appendTrainPlanFromatList(trainDrawFromat);

            planStation = planNextStation;
          }
        } // for1
        break; // 退出循环
      } // if 语句1
    } // for2
  }

  private List<Plan> sortPlanTrainList(List<Plan> list, String trainName) {
    List<Plan> sortedList = new ArrayList<Plan>();
    UtilForStatics utilForStatics = new UtilForStatics();
    if ((list == null) || (list.size() == 0) || (trainName.length() == 0)) {
      return null;
    }
    Plan plan = new Plan();
    int listLength = list.size(); // 获取指定区段内所有车次的数量
    String preStationName = "";

    // 查找区段内首站,即第一个车站
    for (int i = 0; i < listLength; i++) {
      plan = list.get(i);
      if ((plan.getTrain_name().equalsIgnoreCase(trainName))
          && (plan.getStation_name().equalsIgnoreCase(plan.getPrestation_name()))) {
        preStationName = plan.getStation_name();
        // System.out.println("首站:"+preStationName);
        sortedList.add(plan);

        // 保存数据到ScheduleDataset类的scheduleTrainMap中,用于记录学员调整运行计划
        utilForStatics.putScheduleTrainMap(plan);
        break;
      }
    }

    // 没有找到首站
    if (preStationName.length() == 0) {
      return null;
    }

    // 依据首站 依次查找区段内其他站
    for (int i = 0; i < listLength; i++) {
      plan = list.get(i);
      if (plan.getStation_name().equalsIgnoreCase(plan.getPrestation_name())) { // 首站
        continue;
      }
      for (int j = 0; j < listLength; j++) {
        plan = list.get(j);
        String stationName = plan.getStation_name();
        if ((plan.getTrain_name().equalsIgnoreCase(trainName))
            && (plan.getStation_name().equalsIgnoreCase(plan.getPrestation_name()))) { // 首站
          continue;
        } else // 非首站
        if ((plan.getTrain_name().equalsIgnoreCase(trainName))
            && preStationName.equalsIgnoreCase(plan.getPrestation_name())) {
          // System.out.println("其他站:"+stationName);
          preStationName = stationName;
          sortedList.add(plan);

          // 保存数据到UtilForStatics_x类的scheduleTrainMap中,用于记录学员调整运行计划
          utilForStatics.putScheduleTrainMap(plan);
        }
      }
    }
    return sortedList;
  }
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  public static void main(String args[]) {

    /*String time = "01:15:00";
     DateFormat sdf = new SimpleDateFormat("hh:mm:ss");
    //得到现在小时
    public static String getHour() {
       Date currentTime = new Date();
       SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       String dateString = formatter.format(currentTime);
       String hour;
       hour = dateString.substring(11, 13);
       return hour;
    }
    //得到现在分钟

    public static String getTime() {
       Date currentTime = new Date();
       SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       String dateString = formatter.format(currentTime);
       String min;
       min = dateString.substring(14, 16);
       return min;
    }

    public static String getTimeShort() {
    	   SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
    	   Date currentTime = new Date();
    	   String dateString = formatter.format(currentTime);
    	   return dateString;
    	}
     */
  }
}