解析来自文件，定界符，循环，java的输入

Question

总体项目是为机场创建系统管理员。 它跟踪每个类别的机场，航班，座位区，座位和其他相关信息。 初始系统是通过从已格式化的文件中导入来设置的。 我在正确解析文件以设置初始系统时遇到问题。 数据从文件中解析出来，并用作创建对象的方法参数：机场，航空公司，航班，航班区和座位。

格式为：[机场代码列表] {航空公司列表}

机场代码列表:: =以逗号分隔的字符串

航空公司清单:: =航空公司名称1 [flightinfo-list1]，航空公司名称2 [flightinfo-list2]，航空公司名称3 [flightinfo-list3]，…

flightinfo-list ::: flightID1 | flightdate1 | originAirportCode1 | destinationAirportCode1 [flightsectionlist1]，flightID2 | flightdate2 | originAirportCode2 | destinationAirportCode2 [flightsection-list2]，…

flightdate :: =年，月，月日，小时，分钟

flightsection-list :: = sectionclass：座位价格：布局：行数，…

班级::: F，B，E（头等舱，商务舱，经济舱）

布局:: = S，M，W（不同的已知座位布局）

例：

[DEN，NYC，SEA，LAX] {AMER [AA1 | 2018,10,8,16,30 | DEN | LAX [E：200：S：4，F：500：S：2]，AA2 | 2018,8 ，9,7,30 | LAX | DEN [E：200：S：5，F：500：S：3]，…]，UNTD [UA21 | 2018,11,8,12,30 | NYC | SEA [E ：300：S：6，F：800：S：3]，UA12 | 2018,8,9,7,30 | SEA | DEN [B：700：S：5，F：1200：S：2]，… ]，前[...]，美国航空[...]}

我尝试使用定界符和while循环的组合强行强制使用它。 该代码成功创建了Airports，第一个航空公司和Flighsections，但是当创建第二个航空公司时，它崩溃了，因为我没有正确地循环，并且很难正确设置。 到目前为止，我的代码混乱不堪，如果您愿意研究一下，我将不胜感激。 我的问题是解决这个问题的更好方法是什么？ 不同的设计方法？ 也许是使用分隔符的更聪明的方法？ 在此先感谢您的帮助！！

这是我尝试过的。

private void readFile(File file){
    System.out.println("reading file");
    Scanner tempScan;
    String result;
    String temp = "";
    scan.useDelimiter("\\[|\\{"); 
    try{
        // AIRPORTS
        result = scan.next();
        tempScan = new Scanner(result);
        tempScan.useDelimiter(",|\\]");
        while(tempScan.hasNext()){
            temp = tempScan.next();
            sysMan.createAirport(temp);
        }
        tempScan.close();
        /* AIRLINE
         *    FLIGHT
         *    FLIGHTSECTION
         */
        do{
            // AIRLINE (loop<flight & fsection>)
            result = scan.next();
            sysMan.createAirline(result);
            // FLIGHT
            result = scan.next();
            tempScan = new Scanner(result);
            do{

                tempScan.useDelimiter(",|\\|");

                ArrayList flightInfo = new ArrayList();

                while(tempScan.hasNext()){
                    if(tempScan.hasNextInt()){
                        flightInfo.add(tempScan.nextInt());
                    } else {
                        flightInfo.add(tempScan.next());
                    }
                }

                tempScan.close();
                sysMan.createFlight(sysMan.getLastAddedAirline(),(String)flightInfo.get(0), (int)flightInfo.get(1), (int)flightInfo.get(2), (int)flightInfo.get(3), (int)flightInfo.get(4), (int)flightInfo.get(5), (String)flightInfo.get(6), (String)flightInfo.get(7));
                // FLIGHTSECTION (loop<itself>)
                result = scan.next();
                tempScan = new Scanner(result);
                tempScan.useDelimiter(",|:|\\]");
                ArrayList sectInfo = new ArrayList();

                int i = 1;
                while(!temp.contains("|")){
                    if(tempScan.hasNextInt()){
                        sectInfo.add(tempScan.nextInt());
                    } else {
                        temp = tempScan.next();
                        if(temp.equals(""))
                            break;
                        char c = temp.charAt(0);
                        sectInfo.add(c);
                    }
                    if(i == 4){
                        sysMan.createSection(sysMan.getLastAddedAirline(), sysMan.getLastAddedFlightID(), (char)sectInfo.get(0), (int)sectInfo.get(1), (char)sectInfo.get(2), (int)sectInfo.get(3));
                        i = 1;
                        sectInfo = null;
                        sectInfo = new ArrayList();
                        continue;
                    }

                    i++;
                }


            }while(!temp.equals("\\s+"));


        }while(!temp.contains("\\s+")); 




    }catch(NullPointerException e){
        System.err.println(e);
    }
}

Answer 1

我宁愿通过正则表达式对外部边界进行数学运算来分解它，看看，我把它打破了几个层次。

import java.util.regex.Matcher;

导入java.util.regex.Pattern;

公共类Tokeni {

static String yolo = "[DEN,NYC,SEA,LAX]{AMER["
+ "AA1|2018,10,8,16,30|DEN|LAX[E:200:S:4,F:500:S:2],"
+ "AA2|2018,8,9,7,30|LAX|DEN[E:200:S:5,F:500:S:3]],"
+ "UNTD[UA21|2018,11,8,12,30|NYC|SEA[E:300:S:6,F:800:S:3],"
+ "UA12|2018,8,9,7,30|SEA|DEN[B:700:S:5, F:1200:S:2]]}";

public static void main(String[] args) {

    Matcher airportCodesMatcher = Pattern.compile("\\[(.*?)\\]").matcher(yolo);
    airportCodesMatcher.find();
    String[] airportCodes = airportCodesMatcher.group(1).split(",");

    Matcher airLinesMatcher = Pattern.compile("\\{(.*?)\\}").matcher(yolo);
    airLinesMatcher.find();
    String airLinesStr = airLinesMatcher.group(1);

    System.out.println(airLinesStr);

    Pattern airLinePattern = Pattern.compile("\\D+\\[(.*?)\\]\\]");
    Matcher airLineMatcher = airLinePattern.matcher(airLinesStr);

    while( airLineMatcher.find() ) {
        String airLineStr = airLineMatcher.group(0).trim();
        if(airLineStr.startsWith(",")) {
            airLineStr = airLineStr.substring(1, airLineStr.length()).trim();
        }           

        System.out.println(airLineStr);

        Matcher airLineNameMatcher = Pattern.compile("[A-Z]+").matcher(airLineStr);
        airLineNameMatcher.find();
        String airLineName = airLineNameMatcher.group(0).trim();
        System.out.println(airLineName);

        airLineStr = airLineStr.substring(airLineStr.indexOf("[")+1, airLineStr.length());          
        Matcher airLineInfoMatcher = Pattern.compile("\\D+(.*?)\\]").matcher(airLineStr);   
        while(airLineInfoMatcher.find()) {
            String airLineInfoStr = airLineInfoMatcher.group(0).trim();
            if(airLineInfoStr.startsWith(",")) {
                airLineInfoStr = airLineInfoStr.substring(1, airLineInfoStr.length()).trim();
            }               
            System.out.println(airLineInfoStr);
        }           
    }       
}

}