Java 8，While循环:减少此循环中中断语句和继续语句的总数，最多使用一条

Question

我有一个包含以下内容的类：

while (true) {
            // if minimum element in the queue is greater than required sweetness
            // then we are done
            if (queue.peek() >= minSweetness) {
                solutionPossible = true;
                break;
            } else {
                // if there are more than or equal to 2 elements,
                // then only solution is possible
                // because we have already checked queue.peek() for the single element
                // present, and that is less than minSweetness
                if (queue.size() >= 2) {
                    // remove minimum and 2nd minimum values
                    int a1 = queue.poll();
                    int a2 = queue.poll();

                    // again push the value to the queue
                    // after calculating the combined sweetness
                    queue.offer(a1 + 2 * a2);
                } else {
                    // for single element that is less than required sweetness
                    // no solution is possible
                    solutionPossible = false;
                    break;
                }
                // increase total number of operations
                operations++;
            }
        }

这是一个截图：

​

VScode告诉我要减少这个循环中中断和继续语句的总数，最多只能使用一个语句，所以我对我能想到的其他方法没有经验，我试着使用快速修复，但是它没有工作，有谁知道如何以不同的方式编写这个类…？

我试着用快速修复，但是它没有显示其他的选择。

Answer 1

不要将while编码为无限循环，而是使用一个变量来控制循环的延续或退出，而不是将break从其中退出。在这种情况下，我选择了一个boolean

boolean decided = false;
while ( ! decided ) {
            // if a minimum element in the queue is 
            // greater than the required sweetness
            // then we are done
            if (queue.peek() >= minSweetness) {
                solutionPossible = true;
                decided = true;
            } else {
                // if there are more than or equal to 2 elements,
                // then only solution is possible
                // because we have already checked 
                // queue.peek() for the single element
                // present, and that is less than minSweetness
                if (queue.size() >= 2) {
                    // remove minimum and 2nd minimum values
                    int a1 = queue.poll();
                    int a2 = queue.poll();

                    // again push the value to the queue
                    // after calculating the combined sweetness
                    queue.offer(a1 + 2 * a2);
                } else {
                    // for a single element that is 
                    // less than the required sweetness
                    // no solution is possible
                    solutionPossible = false;
                    decided = true;                       
                }
                // increase the total number of operations
                operations++;
            }
        }

顺便说一下，我喜欢保留第一个break。这是一种风格偏好：

boolean decided = false;
while ( ! decided ) {
            // if a minimum element in the queue is 
            // greater than the required sweetness
            // then we are done
            if (queue.peek() >= minSweetness) {
                solutionPossible = true;
                decided = true;
                break;

            
                // if there are more than or equal to 2 elements,
                // then only solution is possible
                // because we have already checked 
                // queue.peek() for the single element
                // present, and that is less than minSweetness
                if (queue.size() >= 2) {
                ...

保留第一个break允许消除第一个else，为下面的代码减少一个嵌套级别。

Answer 2

假设您需要保留循环的原始结构(即while (true) )，那么这是一种降低复杂性的方法(注释已删除)：

while (true)
{
    if (queue.peek() >= minSweetness || queue.size() < 2) {
        solutionPossible = (queue.peek() >= minSweetness);
        break;
    }
    int a1 = queue.poll();
    int a2 = queue.poll();

    queue.offer(a1 + 2 * a2);
    operations++;
}

两个循环“断点”被浓缩为一个。它们处理的区别在于solutionPossible的设置，它可以根据第一个条件来设置。

else被删除为不必要的。

如果peek是一个代价高昂的操作(很可能不是这样)，那么首先将结果分配给变量将是一个优化，因为它被使用了两次。