为什么我的 for 循环会忽略满足条件的元素？ [关闭]答案

【问题标题】：Why are my for loops ignoring elements that satisfy conditions? [closed]为什么我的 for 循环会忽略满足条件的元素？ [关闭]
【发布时间】：2022-10-24 03:08:58
【问题描述】：

我对乘客列表进行了排序，但其中一些不在适当的组中。

我正在使用这个标准：

第一组：H型
第 2 组：E 型和第 1-4 行
第 3 组：G 型和第 1-4 行
第 4 组：E 型 OR（G 型 AND 第 10 或 11 行）
第 5 组：G 型和第 23-26 行
第 6 组：G 型和第 17-22 行
第 7 组：G 型和第 11-16 行
第 8 组：G 型和第 5-10 行

第 1 组应该出现在列表的开头，第 8 组应该出现在列表的末尾。优先级编号范围从 103 到 1。

这是原始未排序的乘客列表（姓名、类型、行号）：

Whitley G 8
Knowles G 1
Rocha G 24
Boyle G 24
Wooten G 2
Forbes G 16
Vinson E 1
Valencia E 7
Lindsay E 16
Rasmussen E 5
Sargent G 11
Sosa G 23
Head G 3
Holcomb G 5
Carney G 4
Kirkland G 14
Levine E 9
Cash G 10
Kaufman G 6
Ratliff G 9
Macias G 4
Sharpe G 17
Sweet G 17
Delaney G 9
Emerson G 5
Castaneda E 9
Rutledge G 26
Stuart G 19
Rosales G 23
Baird G 2
Clemons G 8
Mcgowan G 18
Compton E 10
Albert G 15
Acevedo G 14
Mayer E 9
Fitzpatrick G 16
Chaney G 8
Jarvis G 3
Berger G 26
Britt E 11
Odonnell E 8
Levy E 9
Mullen G 6
Pollard G 22
Lott G 10
Cantrell G 15
Holder E 5
Vaughan E 11
Mccarty E 24
Wilder G 11
Mayo G 1
Pickett G 8
Sykes G 26
Bender G 13
Aguirre G 16
Bernard G 10
Hopper H 7
Melendez G 13
Macdonald H 18
Carver G 15
Gould E 26
Suarez G 6
Zamora G 15
Hinton G 13
Cabrera G 26
Dickson G 22
Salas G 24
Bentley G 13
Fuentes G 23
Terrell H 3
Holman E 7
Mcintyre G 16
Hebert G 13
Hendricks G 3
Jacobson G 14
Kline G 14
Faulkner G 5
Chan G 14
Mays G 1
Crosby G 25
Buck G 22
Maddox G 20
Buckley E 17
Kane G 10
Rivas E 26
Dudley G 22
Best G 12
Finley G 24
William G 18
Frost G 2
Ashley G 14
Mcconnell G 7
Blevins G 11
Middleton G 17
Bean G 18
Sheppard G 11
Estes E 7
Pugh G 8
Rivers E 6
Barr G 4
Landry E 10
Foley G 2

这是我的一些代码：

public void loadOldPQ(ArrayList<Passenger> list) throws IOException {
    
    int priorityNumber = list.size();

    while (!list.isEmpty()) {
        //H forLoop capture all required passengers
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getType().equalsIgnoreCase("H")) {
                list.get(i).setKey(priorityNumber);
                oldPQ.add((list.get(i)));
                list.remove(i);
                priorityNumber--;
            }
        }

        //Type E AND Row 1-4 forLoop works
        for (int j = 0; j < list.size(); j++) {
            if (list.get(j).getRow() >= 1 && list.get(j).getRow() <= 4
                    && list.get(j).getType().equalsIgnoreCase("E")) {
                list.get(j).setKey(priorityNumber);
                oldPQ.add(list.get(j));
                list.remove(j);
                priorityNumber--;
            }
        }

        //Type G(implied) and Row 1-4 forLoop works
        for (int k = 0; k < list.size(); k++) {
            if (list.get(k).getRow() >= 1 && list.get(k).getRow() <= 4) {

                list.get(k).setKey(priorityNumber);
                oldPQ.add(list.get(k));
                list.remove(k);
                priorityNumber--;
            }
        }

        //Type E or Row 10, 11 forLoop
        for (int l = 0; l < list.size(); l++) {
            if (list.get(l).getType().equalsIgnoreCase("E") || list.get(l).getRow() == 10
                    || list.get(l).getRow() == 11) {
                list.get(l).setKey(priorityNumber);
                oldPQ.add(list.get(l));
                list.remove(l);
                priorityNumber--;
            }
        }

        //Row 23-26 forLoop
        for (int m = 0; m < list.size(); m++) {
            if (list.get(m).getRow() >= 23 && list.get(m).getRow() <= 26) {
                list.get(m).setKey(priorityNumber);
                oldPQ.add(list.get(m));
                list.remove(m);
                priorityNumber--;
            }
        }

        //Row 17-22 forLoop
        for (int n = 0; n < list.size(); n++) {
            if (list.get(n).getRow() >= 17 && list.get(n).getRow() <= 22) {
                list.get(n).setKey(priorityNumber);
                oldPQ.add(list.get(n));
                list.remove(n);
                priorityNumber--;
            }
        }

        //Row 11-16 forLoop (row 11 should've already been removed)
        for (int o = 0; o < list.size(); o++) {
            if (list.get(o).getRow() >= 11 && list.get(o).getRow() <= 16) {
                list.get(o).setKey(priorityNumber);
                oldPQ.add(list.get(o));
                list.remove(o);
                priorityNumber--;
            }
        }

        //Row 5-10 forLoop (Row 10 passengers should've already be removed)
        for (int p = 0; p < list.size(); p++) {
            if (list.get(p).getRow() >= 5 && list.get(p).getRow() <= 10) {
                list.get(p).setKey(priorityNumber);
                oldPQ.add(list.get(p));
                list.remove(p);
                priorityNumber--;
            }
        }
    }
    oldProcedure(oldPQ);
}

例如，Kane、McConnell、Estes 应该与第 4 组同组。 Clemons、Chauncy、Pickett 应该出现在第 8 组的列表末尾，因为它们的行号为 5-10。

这是我的结果：

Name           Type Row  Key  

Hopper         H    7    103  
Macdonald      H    18   102  
Terrell        H    3    101  
Vinson         E    1    100  
Knowles        G    1    99   
Wooten         G    2    98   
Head           G    3    97   
Carney         G    4    96   
Macias         G    4    95   
Baird          G    2    94   
Jarvis         G    3    93   
Mayo           G    1    92   
Hendricks      G    3    91   
Mays           G    1    90   
Frost          G    2    89   
Barr           G    4    88   
Foley          G    2    87   
Valencia       E    7    86   
Rasmussen      E    5    85   
Levine         E    9    84   
Castaneda      E    9    83   
Compton        E    10   82   
Mayer          E    9    81   
Britt          E    11   80   
Levy           E    9    79   
Lott           G    10   78   
Holder         E    5    77   
Mccarty        E    24   76   
Bernard        G    10   75   
Gould          E    26   74   
Holman         E    7    73   
Buckley        E    17   72   
Rivas          E    26   71   
Blevins        G    11   70   
Sheppard       G    11   69   
Rivers         E    6    68   
Rocha          G    24   67   
Sosa           G    23   66   
Rutledge       G    26   65   
Rosales        G    23   64   
Berger         G    26   63   
Sykes          G    26   62   
Cabrera        G    26   61   
Salas          G    24   60   
Fuentes        G    23   59   
Crosby         G    25   58   
Finley         G    24   57   
Sharpe         G    17   56   
Stuart         G    19   55   
Mcgowan        G    18   54   
Pollard        G    22   53   
Dickson        G    22   52   
Buck           G    22   51   
Dudley         G    22   50   
William        G    18   49   
Middleton      G    17   48   
Forbes         G    16   47   
Sargent        G    11   46   
Kirkland       G    14   45   
Albert         G    15   44   
Fitzpatrick    G    16   43   
Cantrell       G    15   42   
Wilder         G    11   41   
Bender         G    13   40   
Melendez       G    13   39   
Zamora         G    15   38   
Bentley        G    13   37   
Hebert         G    13   36   
Kline          G    14   35   
Chan           G    14   34   
Best           G    12   33   
Whitley        G    8    32   
Holcomb        G    5    31   
Kaufman        G    6    30   
Delaney        G    9    29   
Clemons        G    8    28   
Chaney         G    8    27   
Mullen         G    6    26   
Pickett        G    8    25   
Suarez         G    6    24   
Faulkner       G    5    23   
Kane           G    10   22   
Mcconnell      G    7    21   
Estes          E    7    20   
Landry         E    10   19   
Lindsay        E    16   18   
Odonnell       E    8    17   
Boyle          G    24   16   
Sweet          G    17   15   
Maddox         G    20   14   
Bean           G    18   13   
Acevedo        G    14   12   
Aguirre        G    16   11   
Hinton         G    13   10   
Jacobson       G    14   9    
Cash           G    10   8    
Emerson        G    5    7    
Pugh           G    8    6    
Vaughan        E    11   5    
Carver         G    15   4    
Ashley         G    14   3    
Ratliff        G    9    2    
Mcintyre       G    16   1

【问题讨论】：

您能否...列出您尝试实施的实际优先级标准？这个算法很糟糕，我有几个想法为什么它没有做你想做的事，但为了得到一个正确的答案，最好知道你想要做什么。例如，E 行 5 应该在 G 行 1 之前还是之后？如果 E 第 3 行的优先级低于 E 第 1 行，这有关系吗？
我还没有仔细看这个。但是，像这样的问题有时是由在迭代 Collection 时更改它引起的。尝试将for (int x = 0; x < list.size(); x++) 更改为for (int x = list.size() - 1; x <= 0; x--)，看看是否有区别。用适当的变量名替换x。
即使这是问题所在，我的建议也可能行不通。您应该获取并使用 Iterator 来在迭代时更改 Collection。
@Deltharis 我的错。我刚刚编辑了帖子以包含要排序的原始乘客列表。标准基本上是根据他们的 Key 登机的乘客。从最高到最低。
“密钥”不是输入参数，这是您的算法生成的，这不是答案。如果您的目标是按 Key 排序而不是成功，那么您的结果确实是按 Key 排序的。

标签： java for-loop if-statement priority-queue

【解决方案1】：

你确定你的作业做对了吗？你会得到一个Passengers 的列表。您应该将它们放在优先级队列中（我假设它是java.util.PriorityQueue），以便根据某些规则对它们进行排序。 Passenger 实现 Comparable。

最自然的方法是使用排序规则正确实现Passenger 中的compareTo() 方法 - 这样您就可以将乘客放入队列并进行排序而无需任何额外代码。

public class Passenger implements Comparable<Passenger>{

    public Passenger(int row, String name, String type) {
        this.row = row;
        this.name = name;
        this.type = type;
    }
    
    @Override
    public int compareTo(Passenger o) {
        if(this.getKey() > o.getKey()) {
            return 1;
        }
        else if(this.getKey() < o.getKey()){
            return -1;
        }
        else {
            return 0;
        }
    }

    private int getKey(){
        if(type.equals("H"){
            return 8;
        } else if (type.equals("E") && row <= 4){
            return 7;
        } else 
        ... // implement all your groups criteria like this
    }
}

因此，将 key 更改为仅知道您的排序要求的内部方法。然后你的方法简化为

public void loadOldPQ(ArrayList<Passenger> list) throws IOException {
    oldPQ.addAll(list);
}

PriorityQueue 可以为您整理它们。

【讨论】：

【解决方案2】：

运行这个小程序，你就会明白，在不调整索引的情况下删除项目意味着你跳过了项目：

class Application {
    public static void main(String[] args) throws IOException {

        List<String> l = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));

        for (int i = 0; i < l.size(); ++i) {
            System.out.println("Checking " + l.get(i));
            if ("B".equals(l.get(i))) {
                l.remove(i);
            }
        }

    }
}

您需要在删除项目后减少i，即

...
            if ("B".equals(l.get(i))) {
                l.remove(i);
                i--;
            }
...

或者，使用 Iterator，正如 Old Dog 建议的那样：

class Application {
    public static void main(String[] args) throws IOException {

        List<String> l = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
        Iterator<String> i = l.iterator();
        while (i.hasNext()) {
            String s = i.next();
            System.out.println("Checking " + s);
            if ("B".equals(s)) {
                i.remove();
            }
        }
    }
}

【讨论】：