Fibonacci Series in Java: How to Write & Display Fibonnaci in Java

The Fibonacci sequence gets its name from Italian mathematician, Leonardo Fibonacci. He introduced this series in Western Europe with his book Liber Abaci back in 1202. The Indian mathematics scene had seen the Fibonacci magic way back in 200 BCE, as evidenced by the works of Pingala. This representation of numbers also occupies a special place in the spheres of coding and computing. By the end of this explainer, you will have learned about writing a Fibonacci series in Java.  

The integer sequence starts with 0 and 1, and each number after that is the sum of the two numbers that precede it, for example, 0, 1, 1, 2, 3, 5, and so on. There are two main ways of generating it in JavaScript, namely (i) using iteration, i.e., without using recursion, and (ii) using recursion. While the iterative approach takes linear time to finish the task, you exponentially get the solution with the recursive technique. Now, let us delve into the details of these methods one by one. 

Understanding the Fibonacci Series 

The Fibonacci series program in Java is one of the most popular and widely used mathematical sequences in computer science and engineering. It has many practical applications, from financial models to image processing algorithms. It is also conceptually simple yet elegant; a simple recursive formula defines the sequence and can be easily extended to different lengths. 

The fibonacci series program in Java begins with two numbers: 0 and 1. Each subsequent number in the series is equal to the sum of the previous two – 0,1,1,2,3,5,…and so on. The nth term of the series is represented as:

Fn = Fn-1 + Fn-2. This pattern continues forever, and each new number is calculated from its predecessors. 

Check out our free courses to get an edge over the competition

Read: Python vs. Javascript Throwdown: Which One Should You Prefer?

Writing Fibonacci Series in Java

Method 1: Without recursion

• For Loop

In this case, you want the Java program to generate first n numbers of a Fibonacci sequence. Here is a detailed look at how the ‘for’ loop iteration works. 

First, you initialize the first two numbers of the series. Then, For Loop will add up the two immediate predecessors and print the value. This process will continue until the first n numbers have been displayed. Since the program has already published 0 and 1 before beginning the iteration, the For Loop condition is given by n-2.

Check out upGrad’s Advanced Certification in Cloud Computing

• While Loop

It follows a logic similar to the For Loop method but requires programmers to be more careful in its application. The control flow statement of the ‘while’ loop executes code repeatedly on a Boolean condition. Only if the condition satisfies, or is true, the body of the loop is executed. Further, the update expression increments the loop variable. Conversely, we will exit from the while loop if the condition evaluates as false. 

Read: Java Architecture & Components Explained

Let us observe the Java code given below to gain a better understanding of While Loop:

Method 2: With recursion

When you are writing the Fibonacci series in Java using recursion, the function calls itself directly or indirectly. It is a basic JavaScript programming technique, and the function is known as a recursive function. 

Check out upGrad’s Advanced Certification in Blockchain

Recursive algorithms can help you solve complex problems with ease. Suppose you want to print the first ‘n’ numbers of the Fibonacci sequence using recursion. You would need a recursive Java program to generate the required series. Here is the step-wise explanation of such an implementation:

• The user would give the input
• For Loop would be applied to loop until each iteration calls the function that returns the Fibonacci number at the n position. Let it be fibonaccinumber (int n)
• Then the function would recursively call itself and add the previous two Fibonacci numbers

Creating a Program in Java Using Recursion 

To create a program which calculates the Fibonacci series program using recursion in Java, we’ll need to define an appropriate recursive function that takes an integer argument (the desired length of the sequence) and returns an array containing the series. 

We’ll also need to consider a few additional items, such as:

• How to define base cases (when to stop recursing) 
• How to handle edge cases or invalid input 
• The most efficient way to calculate each number in the sequence 

Once we’ve figured out those details, our function should be ready for use! With it, you’ll easily calculate any length of the Fibonacci sequence. 

Benefits and Limitations of Using Java for Fibonacci Series Programs 

Java is an excellent language for creating recursive programs like this one. The fact that it has inherent readability, robustness, and scalability makes it exceptional. Additionally, Java’s libraries and tooling make it much easier to develop and debug code quickly. 

Java is a great programming language. However, it has some limitations which should be addressed. 

For example:

• The language lacks native support for tail-call optimization, which may lead to performance issues if handled incorrectly.
• Moreover, since Fibonacci series computations necessitate a lot of memory, Python or C++ might be more appropriate programming languages due to their superior memory management abilities.

Here’s the complete code for generating the Fibonacci series using recursion in Java:

public class FibonacciSeries {
    public static int fibonacciRecursion(int n) {
        if (n == 0 || n == 1) {
            return n;
        } else {
            return fibonacciRecursion(n - 1) + fibonacciRecursion(n - 2);
        }
    }
    public static void printFibonacciSeries(int n) {
        System.out.println("Fibonacci Series up to " + n + " terms:");
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacciRecursion(i) + " ");
        }
    }
    public static void main(String[] args) {
        int numberOfTerms = 10;
        printFibonacciSeries(numberOfTerms);
    }
}

If you want to enhance your recursive programming abilities, try writing a program in Java to generate a Fibonacci series. By understanding recursion and the strengths and limitations of Java coding, you can develop an efficient program for calculating this significant sequence. As you become more proficient, you can easily expand your code to tackle more demanding tasks!

Examples of Fibonacci series

Some real-life instances of the Fibonacci sequence include the petals in a flower, pinecones, branches of trees, spirals of shells, among many other representations in nature. This Golden Ratio rule of this mathematical sequence is inherent in the most fundamental characteristics of the universe, such as our DNA molecules and the spirals of galaxies. 

The iterative and recursive methods described above are implementations of the recurrence relation of the Fibonacci series. It is given by: F(n) = F(n-1) + F(n-2). When we put in the seed values in this relation, we get: F(0) = 0 and F(1) = 1. For a given number, n, how will you find the n-th number in a Fibonacci series? Let us consider this scenario with different inputs.

• For an input n=2, the output would be 1
• For an input n=9, the result would be 34

You can build on these fundamentals to write a function that returns F(n). The function can be given by: int fib (int n). The fib() function will return 0 when n = 0. Similarly, if n = 1, fib() should return 1. And the output should be F(n-1) + F (n-2) for n > 1. 

Test case for the fib() function 

For a short sequence, viz. [0, 1, 1, 2, 3, 5, 8,…,55] and fib(5), the result would come out to be 5. So, we aim to return an element with index 5 from the Fibonacci sequence array. Let us see how this will unfold using the iterative method.

function fib(n){

let array = [0,1];
for (let j = 2; j < n + 1; j ++) {
array.push(array[j-2] + array[j-1])
}
return array[n]
}

You can notice that in the above code snippet, we assigned the array variable to [0,1] instead of creating an empty array. The loop starts iterating from j = 2 and keeps on adding numbers until the length of the array is n + 1. And in this way, we return the number at the n index. Hence, the output would be 3 for fib (4), 5 for fib (5), and so on. 

If you are asked to solve the same problem using recursion in an interview, you can use the following base case.

function fib(n){

 if (n > 2){
 return n
 }
 return fib(n-1) + fib (n-2)
}

Suppose you call fib() with argument 5. Here, the fib function will keep on creating more branches of the tree until it reaches the base case (the value of n is less than 2), after which it will begin summing up the return values of each branch. The recursive calls will stop only when an integer equal to 5 is printed.

Advantages of Fibonacci series in Java

• With a simple Javascript program, you can execute a Fibonacci series to effortlessly display a series up to a specific number or term
• Recursion delivers a concise and expressive code in Java
• Iterative algorithms provide an excellent solution in production as they are bounded, keeping the code robust. In contrast, recursive algorithms sometimes lead to stack overflow error
• Fibonacci search works in sorted arrays and performs better than binary search, mainly when the access speed depends upon the previously accessed location
• Being conversant with the Fibonacci series allows students to develop logic while working on modern applications that demand various front-end and back-end functionalities

Check out: Java Project Ideas

Summing up

In this article, we tried to help you implement a Fibonacci series in Java and understand the logic behind different methods. You can represent Fibonacci numbers using recursion or without recursion (for loop and while loop). After that, we refreshed the core concepts behind the two methods and also discussed their advantages.

With all this information, you can refresh your knowledge of algorithms and write better code. It would be best if you also had a good understanding of data structures like arrays, binary trees, linked lists, etc. Use the above article as a starting point of your revision and build your programming skills! 

upGrad’s Exclusive Software Development Webinar for you –

SAAS Business – What is So Different?

If you’re interested to learn more about Java, full-stack software development, check out upGrad & IIIT-B’s PG Diploma in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.