Пример #1
0
  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;
  }
Пример #2
0
  // 将排序后的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
  }
Пример #3
0
  // 对每一个车站,获取经过的所有车次信息,并按到站/离站时间升序排列
  // 从数据库读的车次信息 已经按照到站和离站时间排好序
  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);
  }