为什么我得到0的无限循环？ （Java）

Question

I asked a question about my code the other day, which was quickly resolved by the incredible community here. However I have encountered a completely separate problem using a re-written version of my code. Here's a description of the program from my previous post.

I'm trying to write a program that can detect the largest sum that can be made with any subset of numbers in an ArrayList, and the sum must be lower than a user-input target number. My program is working flawlessly so far, with the exception of one line (no pun intended). Keep in mind that this code isn't complete yet too.

My problem with the code now is that after the user inputs a target number, the program outputs an infinite loop of 0's. Even after trying to debug, I still come up with problems. The ArrayList is being applied to the program perfectly fine, but I think I may have a problem somewhere within one of my while loops. Any ideas?

Heres the code.

import java.util.*;
class Sum{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int temp = 0, target = 1, result = 0, firstIndex = 0, secondIndex = 0;
        String tempString = null;
        ArrayList<String> list = new ArrayList<String>();
        ArrayList<Integer> last = new ArrayList<Integer>();
        System.out.println("Enter integers one at a time, pressing enter after each integer Type \"done\" when finished.\nOR just type \"done\" to use the default list.");
        String placehold = "NotDone";

        while (!placehold.equals("done")){
            list.add(input.nextLine());
            placehold = list.get(list.size() - 1);
        }
        list.remove(list.size() - 1);
        if (list.size() == 0){            //Inserts default list if said list is empty
            list.add("1");
            list.add("2");
            list.add("4");
            list.add("5");
            list.add("8");
            list.add("12");
            list.add("15");
            list.add("21");
        }
        for (int i = 0; i < list.size(); i++){
            tempString = list.get(i);
            temp = Integer.parseInt(tempString);     //Changes the items in the list to Integers, which can be inserted into another list and then sorted
            last.add(temp);
        }
        Collections.sort(last);
        System.out.println("Enter the target number");
        target = input.nextInt();
        while (result < target){
            firstIndex = last.size() - 1;
            secondIndex = firstIndex - 1;
            while (last.get(firstIndex) > target){
                firstIndex--;
            }
            if (last.get(firstIndex) + last.get(secondIndex) < result){
                result = last.get(firstIndex) + last.get(secondIndex);
                last.remove(firstIndex);
                last.remove(secondIndex);
                last.add(result);
            }
            else{
                secondIndex--;
            }
            System.out.println(result);
        }  
    }
}

And the Output...

Enter integers one at a time, pressing enter after each integer Type "done" when finished. OR just type "done" to use the default list.

done //Prompting to use the default list

Enter the target number

15 //User inputs target number

0 0 0 0 0 0 ... //And so on

Answer 1

target = input.nextInt();

should be within your loop otherwise the variable will never change and

while(result<target) will never turn to false

---

while(result<target) {
    target = input.nextInt();
    // otherCoolCode
}

Answer 2

You are assigning target before the while loop, and you are not altering target any way inside the while loop. You need to prompt the user within the while loop. Otherwise, if you set a target variable higher than 0, it will be an infinite loop.

Answer 3

The problem is in

if (last.get(firstIndex) + last.get(secondIndex) < result) {
    ...
}

Result is always initialized to zero, so that condition will never be true. One possible fix is to add an extra condition to handle this initial case:

if (result == 0 || last.get(firstIndex) + last.get(secondIndex) < result) {
    ...
}

Answer 4

An infinite loop occurs when you have a loop whose condition(s) do not change during an iteration of the loop.

Let's review your loop:

  while (result < target){ firstIndex = last.size() - 1; secondIndex = firstIndex - 1; while (last.get(firstIndex) > target){ firstIndex--; } if (last.get(firstIndex) + last.get(secondIndex) < result){ result = last.get(firstIndex) + last.get(secondIndex); last.remove(firstIndex); last.remove(secondIndex); last.add(result); } else{ secondIndex--; } System.out.println(result); } 

Your loop will only end if result and/or target change so that result < target is false.

Within your loop you assign to result only when (last.get(firstIndex) + last.get(secondIndex) < result) is true. So if that condition is false then result will not change.

You have some additional state that is not in the loop condition itself but is manipulated by the loop: firstIndex and secondIndex . Every iteration of the loop you assign to them. You do have an 'else' clause where you modify secondIndex just before printing the current value of result , however you then immediately assign to it at the top of the loop.

This is the crux of your infinite loop (when last.get(firstIndex) + last.get(secondIndex) < result is false) :

1. result doesn't change
2. Your list last isn't modified, thus last.size()-1 and firstIndex - 1 remain the same
3. You assign secondIndex = firstIndex - 1; overwriting the decrement at the end of the loop, thus neither firstIndex nor secondIndex change

Answer 5

In this line

if (last.get(firstIndex) + last.get(secondIndex) < result) {

the sum of both your values will hardly ever be less than result, which is "0".