Home ProgrammingJava Java Program to Display Fibonacci Series: Recursive, Iterative and other ways

# Java Program to Display Fibonacci Series: Recursive, Iterative and other ways

## 7 Ways to Calculate Fibonacci Numbers: Definition, Formulas and Examples

In this article, we will go through the process of creating a Java program that displays the Fibonacci series. By the end of this tutorial, you will have a fully functional program that you can use to explore the Fibonacci series and learn more about its properties.

## What is the Fibonacci Sequence

The Fibonacci series is a series of numbers in which each number is the sum of the two preceding ones, usually starting with 0 and 1. The Fibonacci series is an important mathematical concept with a wide range of applications in various fields, such as computer science, biology, and finance.

## How to Calculate the Fibonacci Sequence

The Fibonacci series can be defined as follows:

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

This definition specifies that the first term of the Fibonacci series is 0, the second term is 1, and the nth term is the sum of the two preceding terms. For example, the third term of the Fibonacci series is F(2) = F(1) + F(0) = 1 + 0 = 1, and the fourth term is F(3) = F(2) + F(1) = 1 + 1 = 2. The Fibonacci series has several interesting properties, such as the fact that the ratio of any two successive terms approaches the golden ratio as the terms increase. It also has many practical applications, such as in the analysis of financial markets and in the design of computer algorithms.

## Fibonacci Series Program using Recursion

Let’s write a program that will calculate and display fibonacci numbers. Let’s start with the recursion method.

### Setting up the project

To get started, open up your favorite Java development environment and create a new Java project. Name your project “Fibonacci” and choose a suitable location to save it. Once the project is set up, you will see the default main class in the project navigator. This is where we will implement the Fibonacci program.

### Implementing the Fibonacci function using Recursion

The first step in creating a Java program to display the Fibonacci series is to implement the Fibonacci function itself. The Fibonacci function is a recursive function that calculates the nth term of the Fibonacci series, given the two preceding terms.

To implement the Fibonacci function, add the following code to the main class:

```public static int fibonacci(int n, int a, int b) {
if (n == 0) return a;
if (n == 1) return b;
return fibonacci(n - 1, b, a + b);
}```

This code defines the Fibonacci function as a recursive function that takes three arguments: `n`, `a`, and `b`. The `n` argument represents the nth term of the Fibonacci series, and the `a` and `b` arguments represent the two preceding terms.

The Fibonacci function first checks if `n` is equal to 0 or 1. If it is, it returns the corresponding term (`a` or `b`). If `n` is greater than 1, it returns the result of calling itself with `n` decremented by 1 and `a` and `b` swapped. This recursive call continues until `n` is 0 or 1, at which point the function returns the corresponding term and the recursion ends.

### Displaying the Fibonacci series

Now that we have implemented the Fibonacci function, we can use it to display the Fibonacci series. To do this, we will use a for loop that iterates from 0 to the desired number of terms and calls the Fibonacci function to calculate each term.

To display the Fibonacci series, add the following code to the main class:

```public static void main(String[] args) {
int n = 10; // Number of terms

for (int i = 0; i < n; i++) {
System.out.println(fibonacci(i, 0, 1));
}
}```

This code defines the main function and declares a variable `n` that represents the number of terms to display. It then uses a for loop to iterate from 0 to `n` and calls the Fibonacci function to calculate each term. The result of each call is then printed to the console.

### Testing the program

To test the Fibonacci program, run the program in your Java development environment. You should see the Fibonacci series printed to the console, starting with 0 and 1 and continuing up to the number of terms specified in the `n` variable.

For example, if you set `n` to 10, the program should print the following output:

```0
1
1
2
3
5
8
13
21
34```

This is the first 10 terms of the Fibonacci series. You can change the value of `n` to display more or fewer terms of the series.

### Customizing the program

You can customize the Fibonacci program further by adding more features or changing the way the series is displayed. For example, you can add a user interface that allows the user to enter the number of terms and displays the series in a graphical format, or you can add a feature that calculates the sum of the series. The possibilities are endless, and the choice is yours.

## Other ways to Find Fibonacci Numbers

Here are six other ways to find Fibonacci numbers, using loops, matrix method, closed-form formula, dynamic programming, recursive method with memoization and Binet’s formula with `BigInteger`.

### Iterative method (using Loops)

This method involves using a loop (without using recursion) to calculate each term of the Fibonacci series. To do this, you can use a for loop that starts with the first two terms of the series (0 and 1) and iteratively calculates each subsequent term by adding the two preceding terms. For example, the code below calculates the first 10 terms of the Fibonacci series using an iterative method:

```int a = 0;
int b = 1;
int c;

for (int i = 0; i < 10; i++) {
c = a + b;
a = b;
b = c;
System.out.println(c);
}```

### Matrix method

This method involves using matrix multiplication to calculate the nth term of the Fibonacci series. To do this, you can define a matrix `M` such that `M^n` is equal to the nth term of the Fibonacci series. For example, the code below calculates the 10th term of the Fibonacci series using a matrix method:

```int[][] M = {{1, 1}, {1, 0}};
int[][] F = {{1}, {0}};

for (int i = 1; i < 10; i++) {
F = multiply(M, F);
}

System.out.println(F);```

### Closed-form formula

This method involves using a closed-form formula to calculate the nth term of the Fibonacci series. One such formula is the Binet’s formula, which is given by:

F(n) = (φ^n – (-φ)^(-n)) / √5

where φ is the golden ratio. This formula can be used to calculate the nth term of the Fibonacci series for any positive integer n. For example, the code below calculates the 10th term of the Fibonacci series using the Binet’s formula:

```int[][] M = {{1, 1}, {1, 0}};
int[][] F = {{1}, {0}};

for (int i = 1; i < 10; i++) {
F = multiply(M, F);
}

System.out.println(F);```

### Dynamic programming

This method involves using a bottom-up approach to calculate each term of the Fibonacci series by storing previously calculated values in an array and using them to calculate subsequent terms. This method is known as dynamic programming because it breaks down a larger problem into smaller subproblems and solves them in a specific order to avoid unnecessary recalculations. For example, the code below calculates the 10th term of the Fibonacci series using dynamic programming:

```int[] F = new int[10 + 1];
F = 0;
F = 1;

for (int i = 2; i <= 10; i++) {
F[i] = F[i - 1] + F[i - 2];
}

System.out.println(F);```

### Recursive method with memoization

This method involves using a top-down approach to calculate each term of the Fibonacci series by recursively calling a function and storing previously calculated values in a cache (also known as memoization). This method combines the benefits of the recursive method (e.g., simplicity) with the benefits of dynamic programming (e.g., efficiency). For example, the code below calculates the 10th term of the Fibonacci series using a recursive method with memoization:

```Map<Integer, Integer> cache = new HashMap<>();

int fibonacci(int n) {
if (n == 0) return 0;
if (n == 1) return 1;
if (cache.containsKey(n)) return cache.get(n);

int F = fibonacci(n - 1) + fibonacci(n - 2);
cache.put(n, F);
return F;
}

System.out.println(fibonacci(10));```

### Binet’s formula with BigInteger

This method involves using the Binet’s formula to calculate the nth term of the Fibonacci series, but using the `BigInteger`class to handle large values of n. The `BigInteger` class is a part of the `java.math` package and provides support for arbitrary-precision integers. This method is useful when you need to calculate very large Fibonacci numbers, such as the 100th or 1000th term of the series. For example, the code below calculates the 100th term of the Fibonacci series using Binet’s formula with `BigInteger`:

```BigInteger phi = BigInteger.valueOf((long) (1 + Math.sqrt(5)) / 2);
BigInteger minusPhi = BigInteger.valueOf((long) (-1 * (1 + Math.sqrt(5)) / 2));
BigInteger sqrt5 = BigInteger.valueOf((long) Math.sqrt(5));

BigInteger F = phi.pow(100).subtract(minusPhi.pow(100)).divide(sqrt5);

System.out.println(F);```

## Comparison of Methods for Finding Fibonacci numbers in Java

Here is a comparison of the different methods for finding Fibonacci numbers, along with their advantages and disadvantages:

Recursion Simple and intuitive Less efficient than iterative and dynamic programming methods
Iterative method Simple and easy to understand Less efficient than matrix and dynamic programming methods
Matrix method Efficient (O(log n)) and concise Less intuitive and more difficult to implement than iterative and recursive methods
Closed-form formula Most efficient (single operation) and concise Less flexible and only applicable to Fibonacci series
Dynamic programming Efficient (avoids unnecessary recalculations) and declarative Less elegant and concise than iterative and matrix methods, and requires more memory and coding effort
Recursive method with memoization Simple, declarative, and efficient (avoids unnecessary recalculations) Less efficient than dynamic programming method (requires more function calls and cache lookups)
Binet’s formula with BigInteger Most efficient (single operation) and flexible (can handle very large values of n) Only applicable to Fibonacci series and requires `BigInteger` class

As you can see, each method has its own advantages and disadvantages, and the choice of method will depend on the specific requirements and constraints of your problem. Some methods may be more suitable for certain types of problems, while others may be more suitable for other types of problems.

For example, the recursive method may be a good choice for simple problems that require a more intuitive and declarative approach, while the dynamic programming method may be a good choice for more complex problems that require a more efficient and scalable solution. On the other hand, the matrix method may be a good choice for problems that require a more elegant and concise solution, while the Binet’s formula with `BigInteger` may be a good choice for problems that require the calculation of very large Fibonacci numbers.

I hope this tutorial has helped you learn how to create a Java program to display the Fibonacci series. Happy coding!

Rate this post