如何使用限制为n的递归java打印奇数

我是编程语言的新手

我有以下代码

import javax.swing.*;

public class oddTest{

public static void odd(int a){
    if (a < 0){
        if (a % 2 != 0){
        a++;
        }
    }
    odd(--a);
}

public static void main(String[] args){
    int n = 0;
    String str = JOptionPane.showInputDialog(null, "make the limits = ");
    n = Integer.parseInt(str);
    odd(n);
    JOptionPane.showInputDialog(n);
}
}

import javax.swing.*；
公共类测试{
公共静态无效奇数（int a）{
if（a<0）{
如果（a%2！=0）{
a++；
}
}
奇数（--a）；
}
公共静态void main（字符串[]args）{
int n=0；
String str=JOptionPane.showInputDialog（null，“设置限制=”）；
n=整数.parseInt（str）；
奇数（n）；
JOptionPane.showInputDialog（n）；
}
}

如果我将限制设置为

7

，则输出应为：

输出：1,3,5,7

---

我将您的方法改写如下：

import javax.swing.JOptionPane;
public class OddTest{
    public static void odd(int a){
        if (a > 0){
            if (a % 2 != 0){
                System.out.println(a);
            }
            odd(--a);
        }
    }

    public static void main(String[] args){
        int n = 0;
        String str = JOptionPane.showInputDialog(null, "make the limits = ");
        n = Integer.parseInt(str);
        odd(n);
        JOptionPane.showInputDialog(n);
    }
}

import javax.swing.JOptionPane;
public class OddTest{
    public static void odd(int a, int limit){
        if (a <= limit){
            if (a % 2 != 0){
                System.out.println(a);
            }
            odd(++a, limit);
        }
    }

    public static void main(String[] args){
        int n = 0;
        String str = JOptionPane.showInputDialog(null, "make the limits = ");
        n = Integer.parseInt(str);
        odd(0, n);
        JOptionPane.showInputDialog(n);
    }
}

输出是：7，5，3，1

如果您想要升序输出，您将编写如下内容：

import javax.swing.JOptionPane;
public class OddTest{
    public static void odd(int a){
        if (a > 0){
            if (a % 2 != 0){
                System.out.println(a);
            }
            odd(--a);
        }
    }

    public static void main(String[] args){
        int n = 0;
        String str = JOptionPane.showInputDialog(null, "make the limits = ");
        n = Integer.parseInt(str);
        odd(n);
        JOptionPane.showInputDialog(n);
    }
}

import javax.swing.JOptionPane;
public class OddTest{
    public static void odd(int a, int limit){
        if (a <= limit){
            if (a % 2 != 0){
                System.out.println(a);
            }
            odd(++a, limit);
        }
    }

    public static void main(String[] args){
        int n = 0;
        String str = JOptionPane.showInputDialog(null, "make the limits = ");
        n = Integer.parseInt(str);
        odd(0, n);
        JOptionPane.showInputDialog(n);
    }
}

import javax.swing.JOptionPane；
公共类测试{
公共静态无效奇数（整数a，整数限制）{
if（a为什么要使用递归。使用迭代非常简单：

public static void printOddNumbers(int max) {
    for (int i = 1; i <= max; i += 2)
        System.out.println(i);
}

您可以这样使用：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class OddCalc {

    public static void main(String[] args) {

        List<Integer> odds = OddCalc.odd(7);
        Collections.reverse(odds);
        System.out.println(odds);

    }

    public static List<Integer> odd(int a) {
        return odd(a, new ArrayList<Integer>());
    }

    private static List<Integer> odd(int a, List<Integer> odds) {

        if( a == 0 ) {
            return odds;
        }

        if( a % 2 != 0 ) {
            odds.add(a);
        }

        return odd(--a, odds);
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公共类OddCalc{
公共静态void main（字符串[]args）{
列表赔率=奇数计算奇数（7）；
收款。反向（赔率）；
系统输出打印项次（赔率）；
}
公共静态列表奇数（int a）{
返回奇数（a，新的ArrayList（））；
}
私有静态列表奇数（整数a，列表赔率）{
如果（a==0）{
回报率；
}
如果（a%2！=0）{
增加（a）；
}
返回奇数（--a，赔率）；
}
}

输出将是
[1,3,5,7]
，您可以将结果放入
JPanel
导入com.sun.deploy.util.StringUtils；
import com.sun.deploy.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;

public class Main {

    static List<String> odds = new ArrayList<>();

    public static void main(String[] args) {
        int n = 0;
        String str = JOptionPane.showInputDialog(null, "make the limits = ");
        n = Integer.parseInt(str);
        printOdds(n);
        String result = StringUtils.join(odds, ", ");
        JOptionPane.showMessageDialog(null, result);
    }

    static void printOdds(int n) {
        if (n < 1) return;
        if (n%2 == 0) n--;
        printOdds(n-2);
        odds.add(String.valueOf(n));
    }
}

导入java.util.ArrayList；
导入java.util.List；
导入javax.swing.JOptionPane；
公共班机{
静态列表赔率=新的ArrayList（）；
公共静态void main（字符串[]args）{
int n=0；
String str=JOptionPane.showInputDialog（null，“设置限制=”）；
n=整数.parseInt（str）；
印刷赔率（n）；
字符串结果=StringUtils.join（赔率，“，”）；
showMessageDialog（空，结果）；
}
静态无效打印赔率（整数n）{
如果（n<1）返回；
如果（n%2==0）n--；
印刷赔率（n-2）；
赔率.add（String.valueOf（n））；
}
}

您可以使用以下代码：

import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;

public class Main {

    static List<String> odds = new ArrayList<>();

    public static void main(String[] args) {
        int n = 0;
        String str = JOptionPane.showInputDialog(null, "make the limits = ");
        n = Integer.parseInt(str);
        printOdds(n);

        StringBuilder nameBuilder = new StringBuilder();
        for (String oddNum : odds) {
            nameBuilder.append(oddNum).append(",");
        }
        nameBuilder.deleteCharAt(nameBuilder.length() - 1);

        JOptionPane.showMessageDialog(null, nameBuilder.toString());
    }

    static void printOdds(int n) {
        if (n < 1) return;
        if (n%2 == 0) n--;
        printOdds(n-2);
        odds.add(String.valueOf(n));
    }
}

import java.util.ArrayList；
导入java.util.List；
导入javax.swing.JOptionPane；
公共班机{
静态列表赔率=新的ArrayList（）；
公共静态void main（字符串[]args）{
int n=0；
String str=JOptionPane.showInputDialog（null，“设置限制=”）；
n=整数.parseInt（str）；
印刷赔率（n）；
StringBuilder nameBuilder=新的StringBuilder（）；
for（字符串oddNum:赔率）{
nameBuilder.append（oddNum.append（“，”）；
}
nameBuilder.deleteCharAt（nameBuilder.length（）-1）；
showMessageDialog（null，nameBuilder.toString（））；
}
静态无效打印赔率（整数n）{
如果（n<1）返回；
如果（n%2==0）n--；
印刷赔率（n-2）；
赔率.add（String.valueOf（n））；
}
}

如果您没有jdk以外的任何库。
最好使用streams：

  public static void odd(int max) {
    int limit = (int)Math.ceil(max/2.0);
    IntStream
      .iterate(1, i -> i+2)
      .limit(limit)
      .forEach(i -> System.out.println(i));
  }

你真的想在这里递归吗？为什么不干脆
i+=2
？@oleg.cherednik yap！对不起，值
2
？
的意思是什么（int i=1；我很好，我如何存储到我的主空？@abu ahmedal khatiri:我添加了两个主空（一个用于第一个，一个用于第二个解决方案）很好，但那只是在
a
变量，不包括在
n
变量在你的方法中，奇怪的是你有一个名为a的参数。在调用者中你有n。为什么你不能有一个双参数方法？我如何为
a
值创建两个参数与
n
相同？我喜欢使用递归，而不是for循环！你知道吗Ottraid of
StackOverflowException
？对不起，变量
OddCalc
的符号是什么？OddCalc是我用来包含静态方法的一个类。让我把它包含在源代码中。我得到了错误，因为我没有
OddCalc
classnice，它是使用
StringUtils
类的替代方法吗？因为我只有JDK这样做除了使用
StringUtils
class？，我的Ubuntu上只有JDK源代码