从某个术语开始用Java编写斐波那契序列

我正在尝试编写一个基于Java的斐波那契序列生成器。我在互联网上看到了许多例子，例如：

public class Fibonacci {

    public static void main(String[] args) {
        generateFibonacci(20);  // generate the first 20 fibonacci numbers
    }

    public static void generateFibonacci(long limit) {
        long first = 0;
        long second = 1;
        System.out.print(first+", "+second);
        for(long i=1;i<limit;i++) {
            long next = first + second;
            System.out.print(", "+next);
            first = second;
            second = next;
        }
        System.out.println();
    }

}

应输出： 8l
13l 21l 34l 55l 89l 144l 233l 377l

我尝试了以下代码，但似乎没有执行所需的操作：

public class example {
    public static void main(String[] args) {
        generateFibonacci(10, 5); 
    }

    public static void generateFibonacci(long limit, long startPoint) {
        long first = 0;
        long second = 1;
        long endPoint = startPoint + limit;
        System.out.print(first + ", " + second);
        for (long i = 1; i < endPoint; i++) {
            long next = first + second;
            if (i > startPoint) {
                System.out.print(", " + next);
            }
            ;
            System.out.print(", " + next);
            first = second;
            second = next;
        }
    }
}

公共类示例{
公共静态void main（字符串[]args）{
generateFibonacci（10,5）；
}
公共静态无效生成器（长限、长起始点）{
长优先=0；
长秒=1；
长端点=起始点+极限；
系统输出打印（第一次+“，”+第二次）；
用于（长i=1；istartPoint）{
系统输出打印（“，”+下一步）；
}
;
系统输出打印（“，”+下一步）；
第一=第二；
第二个=下一个；
}
}
}

关于如何有效地实现这一点，您有什么想法吗？

如果（i>startPoint）

在这里，您不必在

i

上设置条件，而是在

下一个

上设置条件

问题是我不仅要生成前20个数字， 但我还需要指定一个起点

另外，我不知道为什么要打印前两个元素，即

0

和

1

。我已删除了

sysout（）

，以满足您指定的

startPoint

条件

以下是更正后的代码片段：

public static void generateFibonacci(long limit, long startPoint) {
    long first = 0;
    long second = 1;
    long endPoint = startPoint + limit;
    long next = first + second;
    for (long i = 1; i < endPoint; i++) {
        if (next > startPoint) {
            System.out.print(next + ", ");
        }
        first = second;
        second = next;
        next = first + second;
    }
}

---

第10行总是要打印0和1，所以请删除该行

第16行有一个分号，第17行打印所有斐波那契数，这就是为什么得到两个你想要的

尝试：

公共类示例{
公共静态void main（字符串[]args）{
generateFibonacci（10,5）；
}
公共静态无效生成器（长限、长起始点）{
长优先=0；
长秒=1；
长端点=起始点+极限；
用于（长i=1；istartPoint）{
系统输出打印（“，”+下一步）；
}
第一=第二；
第二个=下一个；
}
}

正如您所说，输出必须如下所示

 8                                                                                                                                                                   
 [13, 21, 34, 55, 89, 144, 233, 377] 

你想返回一个斐波那契数的列表

您可以通过这种方式返回您想要的列表

public static void main(String[] args) {
    List<Long> list = generateFibonacci(10, 5);
    System.out.println(list.size());     
    System.out.println(Arrays.toString(list.toArray()));     
}

public static List<Long>  generateFibonacci(long limit, long startPoint) {
    List<Long> list = new ArrayList<>();

    long first = 0;
    long second = 1;
    long endPoint = startPoint + limit - 1;
    //System.out.print(first + ", " + second);
    if (startPoint==0){
            list.add(0);
            list.add(1);
    }else if (startPoint ==1){
            list.add(1);
    }
    for (long i = 2; i < endPoint; i++) {
        long next = first + second;
        if (i > startPoint) {
            // System.out.println(next);
            list.add(next);
        }

        first = second;
        second = next;
    }

    return list;
}

publicstaticvoidmain（字符串[]args）{
List=generateFibonacci（10,5）；
System.out.println（list.size（））；
System.out.println（Arrays.toString（list.toArray（））；
}
公共静态列表生成器（长限制，长起始点）{
列表=新的ArrayList（）；
长优先=0；
长秒=1；
长端点=起始点+极限-1；
//系统输出打印（第一次+“，”+第二次）；
如果（起始点==0）{
列表。添加（0）；
增加第（1）款；
}else if（起始点==1）{
增加第（1）款；
}
for（长i=2；istartPoint）{
//System.out.println（下一步）；
列表。添加（下一步）；
}
第一=第二；
第二个=下一个；
}
退货清单；
}

由于您必须计算初始斐波那契数，因此只需使用标准方法并执行以下操作：

public static void generateFibonacci(long limit, long startPoint) {
    return generateFibonacci(limit).subList(startPoint - 1, limit);
}

---

if后面有一个

；

太多了。有错误吗？如果您以两个整数作为起点（替换

第一个
和
第二个
变量），您可以很容易地解决问题，但我猜您需要“规范”项Fibonacci序列。我在if之后没有看到该字符有任何错误。我已经删除了它，但得到的结果是：0、1、1、2、3、5、8、13、13、21、21、34、34、55、55、55、89、89、144、144、233、233、377、377、610、6100。最好将问题分成两个函数。尝试修改
generateBonacci
函数来创建fibonacc我按照给定的限制进行排序，并将它们放入一个列表中。然后使用第二个函数从列表中打印出该序列的最后一个
x
编号它可以工作！但如果我这样做：list list=generateFibonacci（9，0）；输出是[1，2，3，5，8，13，21]。因此列表不包含序列的前两项。它们是0和1。您可以使用if语句根据起点和限制来解决此问题，我在答案中添加了一个简单的if，但它需要更多条件来检查限制是否正常工作。
public class example {
    public static void main(String[] args) {
    generateFibonacci(10, 5); 
}

public static void generateFibonacci(long limit, long startPoint) {
    long first = 0;
    long second = 1;
    long endPoint = startPoint + limit;
    for (long i = 1; i < endPoint; i++) {
        long next = first + second;
        if (i == startPoint) {
            System.out.print(next);
        }
        else if ( i > startPoint){
            System.out.print(", " + next);
        }
        first = second;
        second = next;
    }
}

 8                                                                                                                                                                   
 [13, 21, 34, 55, 89, 144, 233, 377] 

public static void main(String[] args) {
    List<Long> list = generateFibonacci(10, 5);
    System.out.println(list.size());     
    System.out.println(Arrays.toString(list.toArray()));     
}

public static List<Long>  generateFibonacci(long limit, long startPoint) {
    List<Long> list = new ArrayList<>();

    long first = 0;
    long second = 1;
    long endPoint = startPoint + limit - 1;
    //System.out.print(first + ", " + second);
    if (startPoint==0){
            list.add(0);
            list.add(1);
    }else if (startPoint ==1){
            list.add(1);
    }
    for (long i = 2; i < endPoint; i++) {
        long next = first + second;
        if (i > startPoint) {
            // System.out.println(next);
            list.add(next);
        }

        first = second;
        second = next;
    }

    return list;
}

public static void generateFibonacci(long limit, long startPoint) {
    return generateFibonacci(limit).subList(startPoint - 1, limit);
}