如何从for语句中得到一个结果？ import java.util.*； 公共类组合{ 公共静态void main（字符串[]args）{ 扫描仪sc=新的扫描仪（System.in）； System.out.print（“输入一个数字：”）； 字符串输入=sc.next（）； System.out.printf（“您输入了：%d\n”，Integer.parseInt（输入））； sc.close（）； int[]arr=新int[100]； 对于（int i=0；i

你可以为它创建一个单独的函数，找到一个组合后，打印它，然后返回到主函数。如果你没有找到一个组合，你返回1，它可以在主函数中处理

import java.util.*;

public class Combination {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("Enter a number : ");
    String input = sc.next();
    System.out.printf("You entered: %d\n", Integer.parseInt(input));
    sc.close();

    int[] arr = new int[100];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i <= 97; i++) {
        int num_i = arr[i];
        for (int j = i + 1; j <= 98; j++) {
            int num_j = arr[j];
            for (int k = j + 1; k <= 99; k++) {
                int num_k = arr[k];
                if (num_i + num_j + num_k == Integer.parseInt(input))
                    System.out.printf("(%d, %d, %d)", num_i, num_j, num_k);
            }
        }
    }
  }
}

公共类组合{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
System.out.print（“输入一个数字：”）；
字符串输入=sc.next（）；
System.out.printf（“您输入了：%d\n”，Integer.parseInt（输入））；
int res=打印组合（输入）；
如果（res==1）{
//做点什么
}
sc.close（）；
}
私有静态整型打印组合（字符串输入）{
int[]arr=新int[100]；
对于（int i=0；i对于（int i=0；i你可以为它创建一个单独的函数，找到一个组合后，打印它，然后返回到主函数。如果你没有找到一个组合，你返回1，它可以在主函数中处理

import java.util.*;

public class Combination {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("Enter a number : ");
    String input = sc.next();
    System.out.printf("You entered: %d\n", Integer.parseInt(input));
    sc.close();

    int[] arr = new int[100];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i <= 97; i++) {
        int num_i = arr[i];
        for (int j = i + 1; j <= 98; j++) {
            int num_j = arr[j];
            for (int k = j + 1; k <= 99; k++) {
                int num_k = arr[k];
                if (num_i + num_j + num_k == Integer.parseInt(input))
                    System.out.printf("(%d, %d, %d)", num_i, num_j, num_k);
            }
        }
    }
  }
}

公共类组合{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
System.out.print（“输入一个数字：”）；
字符串输入=sc.next（）；
System.out.printf（“您输入了：%d\n”，Integer.parseInt（输入））；
int res=打印组合（输入）；
如果（res==1）{
//做点什么
}
sc.close（）；
}
私有静态整型打印组合（字符串输入）{
int[]arr=新int[100]；
对于（int i=0；i对于（inti=0；i首先，一些重要的建议：

import java.util.Scanner;

public class Combination {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number : ");
        String input = sc.next();
        System.out.printf("You entered: %d\n", Integer.parseInt(input));
        int num = Integer.parseInt(input);

        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }

        start: for (int i = 0; i <= 97; i++) {
            int numI = arr[i];
            for (int j = i + 1; j <= 98; j++) {
                int numJ = arr[j];
                for (int k = j + 1; k <= 99; k++) {
                    int numK = arr[k];
                    if (numI + numJ + numK == num) {
                        System.out.printf("(%d, %d, %d)", numI, numJ, numK);
                        break start;
                    }
                }
            }
        }
    }
}


不要在嵌套循环内解析
输入
，因为这会影响性能。在嵌套循环外执行一次
不要关闭
系统的
Sacnner
。在
中，因为它也会关闭
系统。在
中，如果不重新启动JVM，就无法再次打开它。这意味着，如果在应用程序的其他部分使用它，应用程序将崩溃
始终遵循，例如，您可以命名为
numJ
，而不是
num\u j
回到你的问题上来，有很多方法可以解决它，我在下面列出了其中的几个：

使用
中断
退出嵌套循环：
将逻辑放入方法中，然后
返回
：

import java.util.Scanner；
公共类组合{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
System.out.print（“输入一个数字：”）；
字符串输入=sc.next（）；
System.out.printf（“您输入了：%d\n”，Integer.parseInt（输入））；
int num=Integer.parseInt（输入）；
printfirstcomposition（num）；
}
静态void printfirstcomposition（int num）{
int[]arr=新int[100]；
对于（int i=0；i对于（inti=0；i首先，一些重要的建议：

import java.util.Scanner;

public class Combination {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number : ");
        String input = sc.next();
        System.out.printf("You entered: %d\n", Integer.parseInt(input));
        int num = Integer.parseInt(input);

        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }

        start: for (int i = 0; i <= 97; i++) {
            int numI = arr[i];
            for (int j = i + 1; j <= 98; j++) {
                int numJ = arr[j];
                for (int k = j + 1; k <= 99; k++) {
                    int numK = arr[k];
                    if (numI + numJ + numK == num) {
                        System.out.printf("(%d, %d, %d)", numI, numJ, numK);
                        break start;
                    }
                }
            }
        }
    }
}


不要在嵌套循环内解析
输入
，因为这会影响性能。在嵌套循环外执行一次
不要关闭
系统的
Sacnner
。在
中，因为它也会关闭
系统。在
中，如果不重新启动JVM，就无法再次打开它。这意味着，如果在应用程序的其他部分使用它，应用程序将崩溃
始终遵循，例如，您可以命名为
numJ
，而不是
num\u j
回到你的问题上来，有很多方法可以解决它，我在下面列出了其中的几个：

使用
中断
退出嵌套循环：
将逻辑放入方法中，然后
返回
：

import java.util.Scanner；
公共类组合{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
System.out.print（“输入一个数字：”）；
字符串输入=sc.next（）；
System.out.printf（“您输入了：%d\n”，Integer.parseInt（输入））；
int num=Integer.parseInt（输入）；
printfirstcomposition（num）；
}
静态void printfirstcomposition（int num）{
int[]arr=新int[100]；
对于（int i=0；iimport java.util.Scanner;

public class Combination {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number : ");
        String input = sc.next();
        System.out.printf("You entered: %d\n", Integer.parseInt(input));
        int num = Integer.parseInt(input);
        printFirstCombination(num);
    }

    static void printFirstCombination(int num) {
        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }

        for (int i = 0; i <= 97; i++) {
            int numI = arr[i];
            for (int j = i + 1; j <= 98; j++) {
                int numJ = arr[j];
                for (int k = j + 1; k <= 99; k++) {
                    int numK = arr[k];
                    if (numI + numJ + numK == num) {
                        System.out.printf("(%d, %d, %d)", numI, numJ, numK);
                        return;
                    }
                }
            }
        }
    }
}