Fibonacci Series in Java

Implementing the Fibonacci series in Java is a classic programming exercise that serves as a great introduction to recursion, dynamic programming, and mathematical concepts. In this section, we will explore various ways to implement the Fibonacci series in Java, discuss their pros and cons, and delve into the underlying mathematics.

Fibonacci series

The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones. In other words, In Fibonacci series, next number is the sum of previous two numbers. It usually starting with 0 and 1. The sequence goes like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, and so on.

Before diving into Java code, let's briefly discuss the mathematical properties of the Fibonacci series. Each number in the sequence (after the first two) is the sum of the two preceding numbers. Formally, if we denote the nth Fibonacci number as F(n), then:

F(0) = 0
F(1) = 1
F(n) = F(n-1) + F(n-2) for n > 1

There are the following two ways to write the Fibonacci series program in Java:

Fibonacci Series without using recursion
Fibonacci Series using recursion

Fibonacci Series in Java Without Using Recursion

Fibonacci series can be determining by using an iterative approach. Like the iterative approach, the recursive approach starts from the bottom and builds its way up.

Let's see the Fibonacci series program in Java without using recursion.

FibonacciExample1.java

class FibonacciExample1{
public static void main(String args[])
{  
 int n1=0,n2=1,n3,i,count=10;  
 System.out.print(n1+" "+n2);//printing 0 and 1  
  
 for(i=2;i<count;++i)//loop starts from 2 because 0 and 1 are already printed  
 {  
  n3=n1+n2;  
  System.out.print(" "+n3);  
  n1=n2;  
  n2=n3;  
 }  

}}

Test it Now

Output:

0 1 1 2 3 5 8 13 21 34

One of the most straightforward ways to generate Fibonacci numbers in Java is by using recursion. The recursive approach directly follows the mathematical definition of the Fibonacci series.

Let's see the Fibonacci series program in Java using recursion.

FibonacciExample2.java

class FibonacciExample2{
 static int n1=0,n2=1,n3=0;  
 static void printFibonacci(int count){  
    if(count>0){  
         n3 = n1 + n2;  
         n1 = n2;  
         n2 = n3;  
         System.out.print(" "+n3); 
         printFibonacci(count-1);  
     }  
 }  
 public static void main(String args[]){  
  int count=10;  
  System.out.print(n1+" "+n2);//printing 0 and 1  
  printFibonacci(count-2);//n-2 because 2 numbers are already printed 
 }
}

Test it Now

Output:

0 1 1 2 3 5 8 13 21 34

This approach has a significant drawback: it recalculates Fibonacci numbers repeatedly. For example, when calculating fibonacci(5), it recalculates fibonacci(3) and fibonacci(4) multiple times. This redundancy leads to exponential time complexity, making it inefficient for large values of n.

Memoization: Overcoming Recursion's Shortcomings

To overcome the inefficiency of the recursive approach, we can employ memoization. It involves storing the results of expensive function calls and returning the cached result when the same inputs occur again. In the context of Fibonacci, this means storing previously calculated Fibonacci numbers to avoid redundant calculations.

Here's how we can implement memoization in Java:

Fibonacci.java

import java.util.HashMap;
import java.util.Map;
public class Fibonacci {
    private static Map<Integer, Integer> memo = new HashMap<>();
    public static int fibonacci(int n) {
        if (n <= 1)
            return n;
        if (memo.containsKey(n))
            return memo.get(n);
        int result = fibonacci(n - 1) + fibonacci(n - 2);
        memo.put(n, result);
        return result;
    }
    public static void main(String[] args) {
        int n = 10;
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacci(i) + " ");
        }
    }
}

Output:

0 1 1 2 3 5 8 13 21 34

By storing intermediate results in the memo map, we eliminate redundant calculations, drastically improving the performance of our Fibonacci function. With memoization, the time complexity reduces to linear, making it much more efficient.

Conclusion

In this section, we have explored various ways to generate Fibonacci numbers in Java. We discussed the recursive approach, its inefficiencies, and how memoization can overcome them. Additionally, we explored the iterative approach, which provides an efficient alternative. Understanding and implementing the Fibonacci series not only helps in mastering fundamental programming concepts but also provides insights into the elegance and beauty of mathematical sequences. As you continue your journey in Java programming, remember that the Fibonacci series is just one of many mathematical concepts waiting to be explored and implemented in code.

Next TopicJava Programs

← prev next →