In this article, we will discuss different ways to generate Fibonacci Series in Java.

## What is Fibonacci Series ?

A Fibonacci series is a sequence of numbers where each number (after the first two) is the sum of the two preceding ones. The series starts with 0 and 1, and the subsequent numbers are calculated by adding the two previous numbers together.

The Fibonacci series follows the pattern: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

To generate the Fibonacci series, you start with the first two numbers (0 and 1) and then calculate the next number by adding the previous two numbers. This process continues indefinitely, creating an infinite sequence of numbers.

The Fibonacci series finds applications in various areas of mathematics, computer science, and nature.

## Different ways to generate Fibonacci Series in Java?

There are multiple ways to generate the Fibonacci series in Java. Here are a few common methods:

### Using a loop

In this program we will generate Fibonacci Series in Java using a loop.

The program takes an integer input n representing the desired length of the Fibonacci series. It then uses a loop to calculate and print the Fibonacci numbers up to N. The loop starts with the first two numbers of the series (0 and 1) and iterates until the desired length is reached. In each iteration, the program calculates the next Fibonacci number by adding the two previous numbers. The loop continues until the desired length is achieved, and the resulting Fibonacci series is displayed as the output.

```
public class FibonacciSeries {
public static void main(String[] args) {
int n = 10; // Number of Fibonacci numbers to generate
int[] fibonacci = new int[n];
fibonacci[0] = 0;
fibonacci[1] = 1;
// Generate Fibonacci series using a loop
for (int i = 2; i < n; i++) {
fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
}
// Print Fibonacci series
for (int num : fibonacci) {
System.out.print(num + " ");
}
}
}
```

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

### Using recursion

In this program we will generate Fibonacci Series in Java using recursion.

Fibonacci series program calls a function recursively to calculate the Fibonacci numbers. It takes an integer input N, and if N is less than or equal to 1, it returns N. Otherwise, it recursively calls the function to calculate the sum of the previous two Fibonacci numbers. The recursion continues until the base case is reached, and the resulting Fibonacci series is returned as the output.

```
public class FibonacciSeries {
public static void main(String[] args) {
int n = 10; // Number of Fibonacci numbers to generate
// Generate and print Fibonacci series using recursion
for (int i = 0; i < n; i++) {
System.out.print(fibonacci(i) + " ");
}
}
// Recursive method to calculate Fibonacci number
public static int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
```

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

### Using memoization with recursion

In this program we will generate Fibonacci Series in Java using memoization with recursion.

Fibonacci series program optimizes the calculation by storing previously computed Fibonacci numbers. It takes an integer input N and maintains a memoization table to store the Fibonacci numbers as they are computed. Before making a recursive call, the program checks if the Fibonacci number is already present in the memoization table. If so, it retrieves the value from the table instead of recalculating it. This technique reduces redundant calculations and significantly improves the performance of the Fibonacci series program.

```
public class FibonacciSeries {
public static void main(String[] args) {
int n = 10; // Number of Fibonacci numbers to generate
// Generate and print Fibonacci series using memoization
for (int i = 0; i < n; i++) {
System.out.print(fibonacci(i) + " ");
}
}
// Recursive method with memoization to calculate Fibonacci number
public static int fibonacci(int n) {
int[] memo = new int[n + 1];
return fibonacciMemoization(n, memo);
}
public static int fibonacciMemoization(int n, int[] memo) {
if (n <= 1) {
return n;
}
if (memo[n] != 0) {
return memo[n];
}
memo[n] = fibonacciMemoization(n - 1, memo) + fibonacciMemoization(n - 2, memo);
return memo[n];
}
}
```

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

### Using an iterative approach with variables

In this program we will generate Fibonacci Series in Java using an iterative approach with variables.

Fibonacci series program calculates the Fibonacci numbers without recursion. It takes an integer input N and initializes two variables to store the current and previous Fibonacci numbers. It then iterates N times, updating the variables by swapping their values and calculating the next Fibonacci number as the sum of the previous two. The resulting Fibonacci series is generated iteratively and displayed as the output.

```
public class FibonacciSeries {
public static void main(String[] args) {
int n = 10; // Number of Fibonacci numbers to generate
int prev1 = 0;
int prev2 = 1;
System.out.print(prev1 + " " + prev2);
// Generate Fibonacci series using iterative approach
for (int i = 2; i < n; i++) {
int fib = prev1 + prev2;
System.out.print(" " + fib);
prev1 = prev2;
prev2 = fib;
}
}
}
```

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

## Conclusion

There are multiple ways to generate the Fibonacci series in Java. You can use a loop to iteratively calculate and store the numbers, or employ recursion to calculate each number based on the preceding ones. Memoization can be used to optimize recursive approaches by storing previously calculated values. Additionally, an iterative approach using variables can be employed for efficient generation of the series.

By exploring and implementing the various ways to generate the Fibonacci series in Java, developers can enhance their problem-solving skills, deepen their understanding of recursion and iteration, and gain valuable experience in optimizing code performance.

**Related Article**