Display Fibonacci Series in Java

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Iteration

Overview

What You’ll Learn

Fibonacci starts with 0 and 1; each next term is the sum of the previous two. This tutorial covers n-term printing, a value-ceiling variant, memoized recursion, a live preview, worked Java examples, edge cases, and complexity.

Definition

0, 1 seeds

F_k = F_k-1 + F_k-2.

Two Variables

(a, b) shift

Print a, then a, b = b, a + b.

Two Stop Rules

n or ≤ M

Fixed term count or value ceiling.

Avoid Naive Recursion

O(φⁿ)

Memoize or iterate for real work.

Live Preview

BigInt

Exact terms in the browser up to 500.

O(n)

Iterative

Linear updates with O(1) extra space.

Introduction

The Fibonacci series starts with seeds 0 and 1. Every next value is the sum of the previous two: 0, 1, 1, 2, 3, 5, 8, 13, …

It is a classic state-update pattern: keep two previous terms, print one, then move forward. Some books start with 1, 1 — the recurrence is the same; only indexing shifts.

Why it matters?

It teaches loops, rolling state, and why naive recursion fails — skills that transfer to DP and sequence problems.

Key Highlights

Seeds 0, 1

State the convention before coding.

Shift Update

(a, b) ← (b, a+b) streams the series.

Iterate First

Best default for printing many terms.

~φ^k Growth

Values grow exponentially with k.

In short: print a starting at 0, then repeatedly replace (a, b) with (b, a + b).

Foundation

📝 Problem & Approach

Print the first n Fibonacci terms, or all terms up to a maximum value.

java

// seeds: 0, 1
// first 10: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
# <= 100:   ... ends at 89 (next is 144)

Inputs & Outputs

Item	Type	Description
`n`	int	Number of terms (positive for a non-empty series).
`maxVal`	int	Optional ceiling: print while term ≤ maxVal.
Output	text	Space- or comma-separated Fibonacci numbers.

Minimal workflow

Pseudocode

function print_first_n_fibonacci_terms(n):
    a = 0
    b = 1
    repeat n times:
        output a
        next = a + b
        a = b
        b = next

Method comparison

Method	Idea	Notes
Iterative series	Two-variable shift	Best for printing many terms
Until max	While a ≤ M	Different stop rule, same update
Memoized recursive	Map memo on fib(k)	Good for single nth term

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Initialize	`long a = 0, b = 1;`
Advance	`long next = a + b; a = b; b = next;`
n terms	`for (int i = 0; i < n; i++)`
Until max	`while (a <= maxVal)`
First ten	`0, 1, 1, 2, 3, 5, 8, 13, 21, 34`
Format cleanly	`StringBuilder` append with separators

Compare

📋 Iterative vs Naive Recursive vs Memoized

Same recurrence — very different costs for series output.

Iterative

a, b = b, a+b

O(n) time, O(1) extra space

Naive recursive

fib(n-1)+fib(n-2)

Exponential recomputation

Memoized

@Map memo

O(n) for nth term with cache

Interview tip

iterate to print

Mention memo/matrix as follow-ups

Context

When This Problem Shows Up

Reach for Fibonacci when rolling state or sequence drills appear.

Interview warm-ups
Classic loop and recursion-vs-iteration discussion.
After factorial
Natural next step from product loops to recurrence.
Teaching DP mindset
Shows why overlapping subproblems need memoization.
Growth intuition
Golden-ratio asymptotics make exponential growth concrete.
Not naive recursion for series
Print with a loop; reserve recursion for nth-term demos.

Key benefit: one short loop that teaches rolling state, stop conditions, and recursion tradeoffs.

Interactive

🔮 Live Preview

Print the first n terms using exact BigInt arithmetic.

Hands-On

Examples Gallery

Three complete Java programs — first n terms, until a max value, and memoized recursive nth term. Click View Output to reveal sample console results.

📚 Getting Started

Interview-style first-n-terms printer.

Example 1 — First n Terms (`n = 10`)

Clean comma formatting with a two-variable update.

java

public class Main {
    static void displayFibonacciTerms(int n) {
        if (n <= 0) {
            System.out.println("Need a positive term count.");
            return;
        }
        long first = 0;
        long second = 1;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            if (i > 0) sb.append(", ");
            sb.append(first);
            long next = first + second;
            first = second;
            second = next;
        }
        System.out.println("Fibonacci series up to " + n + " terms: " + sb);
    }

    public static void main(String[] args) {
        displayFibonacciTerms(10);
    }
}

How It Works

Two rolling values stream the series. Building with StringBuilder avoids trailing-comma bugs.

⚡ Value Ceiling

Same recurrence with a different stop rule.

Example 2 — All Terms ≤ 100

Continue while the current term stays within the limit.

java

public class Main {
    static void displayFibonacciUntil(int maxVal) {
        if (maxVal < 0) {
            System.out.println("maxVal must be nonnegative.");
            return;
        }
        long a = 0;
        long b = 1;
        StringBuilder sb = new StringBuilder();
        while (a <= maxVal) {
            if (sb.length() > 0) sb.append(" ");
            sb.append(a);
            long next = a + b;
            a = b;
            b = next;
        }
        System.out.println("Fibonacci numbers <= " + maxVal + ": " + sb);
    }

    public static void main(String[] args) {
        displayFibonacciUntil(100);
    }
}

How It Works

The first Fibonacci number greater than 100 is 144, so the printed list ends at 89.

⚙️ Memoized Recursive

Get the nth term without exponential recomputation.

Example 3 — Memoized `fib(k)`

Use a memo array when you need a single term, not a full print loop.

java

import java.util.HashMap;
import java.util.Map;

public class Main {
    static long fib(int k, Map<Integer, Long> memo) {
        if (k < 0) {
            throw new IllegalArgumentException("k must be nonnegative.");
        }
        if (k <= 1) {
            return k;
        }
        if (memo.containsKey(k)) {
            return memo.get(k);
        }
        long value = fib(k - 1, memo) + fib(k - 2, memo);
        memo.put(k, value);
        return value;
    }

    public static void main(String[] args) {
        Map<Integer, Long> memo = new HashMap<>();
        // 0-based: fib(0)=0, fib(1)=1, ..., fib(9)=34
        for (int k = 0; k < 10; k++) {
            System.out.println("F(" + k + ") = " + fib(k, memo));
        }
    }
}

How It Works

Without a cache, each call branches into two — exponential work. With a Map memo, each k is computed once (O(n) for F(n)). For printing a long series, prefer the iterative loop from Example 1.

🧠 How the Algorithm Streams Terms

Initialize

Set a = 0, b = 1.

Seeds

Print current

Output a as the next term.

Emit

Shift

Set a, b = b, a + b and repeat.

Update

Series

Stop after n terms or when a > max.

Trace

🔎 Worked Walkthrough — First 6 Terms

Trace the two-variable update starting from (0, 1).

Step	(a, b) before	Print	(a, b) after
1	`(0, 1)`	`0`	`(1, 1)`
2	`(1, 1)`	`1`	`(1, 2)`
3	`(1, 2)`	`1`	`(2, 3)`
4	`(2, 3)`	`2`	`(3, 5)`
5	`(3, 5)`	`3`	`(5, 8)`
6	`(5, 8)`	`5`	`(8, 13)`

Printed so far: 0, 1, 1, 2, 3, 5.

Use Cases

Where Fibonacci shows up beyond the interview prompt.

1. Interview Warm-Ups

Rolling state and stop-condition practice.

Example: print first n terms.

2. DP Teaching

Shows overlapping subproblems clearly.

Example: naive vs memoized fib.

3. After Factorial

Next classic sequence after product loops.

Example: this walkthrough chain.

4. Ceiling Filters

List all terms up to a budget M.

Example: Fibonacci ≤ 100.

5. Growth Talks

Golden ratio and exponential growth demos.

Example: F_k+1/F_k → φ.

6. Fast Follow-Ups

Matrix exponentiation / fast doubling for huge n.

Example: O(log n) single term.

Pro Tip: say “seeds 0 and 1” before coding — indexing debates vanish.

Advantages

Why this pattern works well in interviews and classwork.

1. Tiny State
Only two integers stream the entire series.
2. Flexible Stops
Same update for n terms or ≤ M.
3. Famous Checks
First ten terms are easy to verify by eye.
4. Rich Follow-Ups
Memoization, matrix pow, and φ asymptotics.

Pro Tip: lead with the iterative printer; offer memoized recursion only if asked for the nth term.

Usage Tips

Small habits that keep Fibonacci solutions interview-ready.

1. State the Seeds
Say 0, 1 (or 1, 1) before writing code.
2. Prefer Iteration for Series
Two variables beat naive recursion for printing.
3. Use join() for Formatting
Avoid trailing commas and messy separators.
4. Handle n ≤ 0
Empty series or a clear message — pick one.
5. Spot-Check First Ten
0…34 catches off-by-one shift bugs fast.

Pro Tip: Java long overflows after enough terms — mention BigInteger for huge indices.

Common Pitfalls

Mistakes that commonly break Fibonacci solutions.

1. Naive Recursion for Series
Calling fib(n) recursively to print many terms.
→ Use the two-variable iterative loop.
2. Unclear Seed Convention
Mixing 0,1 with 1,1 without saying so.
→ State seeds explicitly in the answer.
3. Off-by-One Term Count
Looping n-1 times or starting from 1 only.
→ Trace first 10 against 0…34.
4. Trailing Separators
Printing commas after every term including the last.
→ Collect then join.
5. Ignoring Nonpositive n
Empty or bogus output when n ≤ 0.
→ Validate and message clearly.

Edge Cases

Java long can overflow, so clarity and stop conditions still matter.

Terms

`n ≤ 0`

Handle as empty/error depending on requirement.

Formatting

Comma placement

Using join() avoids trailing comma issues.

Recursion

Naive recursive fib

Recomputes work exponentially; avoid for long series output.

Indexing

Seed convention

State clearly whether the sequence starts with 0,1 or 1,1.

Ceiling

`maxVal = 100`

Last printed term is 89; next would be 144.

Huge terms

long overflow

Use BigInteger for huge indices — printing cost grows with digit count.

Math

⚖️ Facts Worth Knowing

Handy follow-ups interviewers sometimes ask.

Recurrence. F₀ = 0, F₁ = 1, F_k = F_k-1 + F_k-2.
Binet / asymptotics. F_k ∼ φ^k / √5 with φ = (1+√5)/2.
Ratios. F_k+1/F_k approaches φ as k grows.
First ten. 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. First 15 terms

Print with commas
End at 377

2. Until 1000

List all F ≤ 1000
Last should be 987

3. Match memo vs loop

Compare F(k) for k = 0…20
Assert identical values

4. Ratio demo

Print F(k+1)/F(k)
Watch it approach φ

Important

Notes

Core update: print a, then a, b = b, a + b.
Variants: fixed number of terms or stop at a max value.
Watch-outs: nonpositive input, indexing convention, and avoiding naive recursion.
Iterative printing is O(n) time and O(1) extra space.

Quick Takeaway: keep two seeds, print the first, shift with a + b, and prefer iteration for series output.

Analysis

⏱️ Time and Space Complexity

Task	Time	Extra space
First n terms (iterative)	`O(n)`	`O(1)`
All terms ≤ M	`O(k)` where k terms printed	`O(1)`
Naive fib(n) recursion	`O(φⁿ)`	`O(n)`
Memoized fib(n)	`O(n)`	`O(n)` cache

For interview printing tasks, the iterative approach is the right default. Extra space above ignores the output string/list size.

Wrap Up

🎉 Conclusion

Fibonacci streams from seeds 0 and 1 by repeatedly replacing (a, b) with (b, a + b). Print with an iterative loop; use memoized recursion only when you need a single nth term.

Practice the three examples above, then continue to GCD for the classic Euclidean algorithm.

State seeds, avoid naive recursion for series printing, and verify against the first ten terms.

View Examples Gallery Continue to GCD

Pro Tips

💡 Best Practices

✅ Do

State seeds 0, 1 up front
Print with a two-variable loop
Use join for clean formatting
Handle n ≤ 0 explicitly
Mention memoization as a follow-up

❌ Don’t

Use naive recursion to print series
Leave seed convention ambiguous
Ignore off-by-one term counts
Leave trailing commas
Assume C-style int overflow

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about Fibonacci

Stream the series the interview-friendly way.

Core concepts

0 01

Seeds

0, 1

Definition

+ 02

Update

a, b = b, a+b

Core

n 03

Stops

n or ≤ M

Variants

! 04

Avoid

Naive recur

Trap

O 05

Cost

O(n)

Analysis

❓ Frequently Asked Questions

What is the Fibonacci sequence?

Each term is the sum of the previous two. With seeds 0 and 1, it starts 0, 1, 1, 2, 3, 5, 8, 13, ...

Can we start with 1, 1 instead?

Yes, some books do that. The recurrence is the same; indexing is shifted.

Does Java long overflow?

Yes. Fibonacci grows fast; long overflows after a limited number of terms. Use BigInteger for very large indices.

Should I use recursion for the full series?

For printing many terms, iterative two-variable update is best. Naive recursion repeats work and is much slower.

What if n is 0 terms?

That is valid as an empty series, or you can print a friendly message based on your requirement.

What is complexity for printing n terms?

O(n) updates and O(1) extra space, ignoring output storage.

What is the golden ratio connection?

F_k is about phi^k / sqrt(5), and consecutive ratios approach phi = (1+sqrt(5))/2.

How do I get only the nth term fast?

Use an iterative loop, memoized recursion, or advanced methods like matrix exponentiation for huge n.

Did you Know? 🔊

The ratio of consecutive terms F_k+1/F_k approaches the golden ratio φ = (1+√5)/2 as k grows.

Continue to GCD

Learn how to find the greatest common divisor with Euclidean division.

GCD tutorial →

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

9 people found this page helpful

Java Program to Find Factorial of a Number Java Program to Find GCD

Display Fibonacci Series in Java

What You’ll Learn

Definition

Two Variables

Two Stop Rules

Avoid Naive Recursion

Live Preview

O(n)

Introduction

Why it matters?

Seeds 0, 1

Shift Update

Iterate First

~φk Growth

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Method comparison

⚡ Quick Reference

📋 Iterative vs Naive Recursive vs Memoized

When This Problem Shows Up

Interview warm-ups

After factorial

Teaching DP mindset

Growth intuition

Not naive recursion for series

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — First n Terms (n = 10)

How It Works

⚡ Value Ceiling

Example 2 — All Terms ≤ 100

How It Works

⚙️ Memoized Recursive

Example 3 — Memoized fib(k)

How It Works

🧠 How the Algorithm Streams Terms

Initialize

Print current

Shift

Series

🔎 Worked Walkthrough — First 6 Terms

Use Cases

1. Interview Warm-Ups

2. DP Teaching

3. After Factorial

4. Ceiling Filters

5. Growth Talks

6. Fast Follow-Ups

Advantages

1. Tiny State

2. Flexible Stops

3. Famous Checks

4. Rich Follow-Ups

Usage Tips

1. State the Seeds

2. Prefer Iteration for Series

3. Use join() for Formatting

4. Handle n ≤ 0

5. Spot-Check First Ten

Common Pitfalls

1. Naive Recursion for Series

2. Unclear Seed Convention

3. Off-by-One Term Count

4. Trailing Separators

5. Ignoring Nonpositive n

Edge Cases

n ≤ 0

Comma placement

Naive recursive fib

Seed convention

maxVal = 100

long overflow

⚖️ Facts Worth Knowing

🎯 Practice Problems

1. First 15 terms

2. Until 1000

3. Match memo vs loop

4. Ratio demo

~φ^k Growth

Example 1 — First n Terms (`n = 10`)

Example 3 — Memoized `fib(k)`

`n ≤ 0`

`maxVal = 100`