15 Star Patterns in Java for Interviews 2026: Complete Guide for Freshers

Ever walked into a Java interview and blanked on a pattern question you’d seen a dozen times before in practice? You’re not alone, and it usually comes down to memorizing code instead of understanding the logic underneath it.

Star patterns in Java are console-output exercises that use nested for loops to print asterisks in shapes like triangles, pyramids, and diamonds, testing whether you truly understand loop logic rather than just recognizing shapes. This guide covers all 15 patterns with working Java code, the logic behind each one, and the mistakes that actually cost candidates marks.

TL;DR Summary

• What it is: nested-loop exercises that print shapes using stars, testing loop logic over memorization
• The 15 patterns: Right Triangle, Inverted Right Triangle, Left Triangle, Pyramid, Inverted Pyramid, Full Pyramid, Right Pascal’s Triangle, Hollow Pyramid, Diamond, Hollow Diamond, Sandglass, Hourglass, Butterfly, Hollow Butterfly, Hollow Square
• Why companies ask them: they test nested loops, manual logic tracing, and clear explanation, all in one quick question
• Time complexity: every pattern here runs in O(n²), since you’re touching roughly n rows and n columns
• If short on time: prioritize Right Triangle, Pyramid, Diamond, Hollow Pyramid, and Butterfly first

What are Star patterns in Java?

Star patterns are beginner-friendly programming exercises that use nested loops, spaces, and conditional statements to print shapes like triangles, pyramids, diamonds, and squares to the console.

Companies like TCS, Infosys, Wipro, Cognizant, and Accenture lean on these in screening rounds because they test three things at once: whether you actually understand nested loops, whether you can trace logic by hand before typing code, and whether you can explain your thinking clearly out loud.

15 Star Patterns in Java: Interview Comparison Table

Quick interview tip: If you have limited preparation time, prioritize the Right Triangle, Pyramid, Diamond, Hollow Pyramid, and Butterfly patterns because they cover the core ideas of increasing/decreasing loops, spaces, symmetry, and conditional printing.

How to Approach Any Star Patterns Problem

Every star pattern in Java, no matter how complex, breaks down the same way. You don’t need to memorise every pattern, you need to understand this mental framework:

1. Count the rows — the outer loop always runs n times (user input or fixed)
2. Identify what each row contains — spaces? stars? both?
3. Write one inner loop per element type — one for spaces, one for stars
4. Add if conditions only for hollow patterns — print * on borders, space inside
5. Test manually with n = 4 — trace on paper before running

Once you have this framework, any new pattern becomes a variation you can figure out on the spot.

Star pattern questions are a great way to strengthen your understanding of loops, nested loops, and problem-solving logic. If you’re preparing for Java interviews, explore HCL GUVI’s free Java Tutorial to master core Java concepts, control statements, OOPs, collections, and more.

The 15 Star Patterns Programs

1. Right Triangle Star Patterns

A great starting point, the most fundamental nested loop pattern. The outer loop counts rows; the inner loop prints one star per column up to the row number.

import java.util.Scanner;

public class RightTriangleStarPattern {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter number of rows: ");

        int rows = scanner.nextInt();

        for (int i = 1; i <= rows; i++) {          // outer loop: row number

            for (int j = 1; j <= i; j++) {         // inner loop: stars = row number

                System.out.print("*");

            }

            System.out.println();                  // move to next line

        }

    }

}

```

**Output (n=5):**

```

*

**

***

****

*****

Concept tested: Basic nested loop, incrementing inner loop

2. Inverted Right Triangle Star Patterns

Flip the logic; start from the full row and count down. Just change the outer loop to decrement from rows to 1.

for (int i = rows; i >= 1; i--) {   // outer loop counts down

    for (int j = 1; j <= i; j++) {  // stars = current row count

        System.out.print("*");

    }

    System.out.println();

}

```

**Output (n=5):**

```

*****

****

***

**

*

Concept tested: Decrementing outer loop

3. Left Triangle Star Patterns

Same star count as the right triangle, but now you print spaces before the stars to push them right-aligned.

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= rows - i; j++) {  // spaces for alignment

        System.out.print(" ");

    }

    for (int j = 1; j <= i; j++) {         // stars

        System.out.print("*");

    }

    System.out.println();

}

```

**Output (n=4):**

```

   *

  **

 ***

****

Concept tested: Two inner loops, space management

4. Pyramid Star Patterns

The classic. You need spaces on the left for centering, and an odd number of stars per row (2i – 1). Interviewers love asking this one because the space logic trips up many candidates.

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= rows - i; j++) {    // leading spaces

        System.out.print(" ");

    }

    for (int j = 1; j <= 2 * i - 1; j++) {  // stars: 1, 3, 5, 7...

        System.out.print("*");

    }

    System.out.println();

}

```

**Output (n=4):**

```

   *

  ***

 *****

*******

Concept tested: Space + star calculation, 2i – 1 formula

Notice how every pattern boils down to loops, conditions, and logical thinking? These are the same fundamentals used to solve coding interview questions. Strengthen your problem-solving skills with HCL GUVI’s free Data Structures and Algorithms Tutorial.

5. Inverted Pyramid Star Patterns

Start with the widest row at the top, then shrink it. Space count increases as stars decrease.

for (int i = rows; i >= 1; i--) {

    for (int j = 1; j <= rows - i; j++) {    // increasing spaces

        System.out.print(" ");

    }

    for (int j = 1; j <= 2 * i - 1; j++) {  // decreasing stars

        System.out.print("*");

    }

    System.out.println();

}

```

**Output (n=4):**

```

*******

 *****

  ***

   *

Concept tested: Inverse relationship between spaces and stars

Every role in UI/UX from UX Research to Interaction Design is covered in HCL GUVI’s UI/UX Design course. You’ll build skills across the full spectrum with real projects, mentor support, and placement assistance.

6. Full Pyramid Star Patterns(Upward + Downward Combined)

You join a pyramid and an inverted pyramid to form a rhombus shape. Two separate loop blocks, one going up, one going down.

// Upper pyramid

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= rows - i; j++) System.out.print(" ");

    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");

    System.out.println();

}

// Lower inverted pyramid (skip the middle row with rows-1)

for (int i = rows - 1; i >= 1; i--) {

    for (int j = 1; j <= rows - i; j++) System.out.print(" ");

    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");

    System.out.println();

}

```

**Output (n=4):**

```

   *

  ***

 *****

*******

 *****

  ***

   *

Concept tested: Two-part pattern, mirroring logic

If you want to be more confident about Java and learn all its knacks, then consider enrolling in HCL GUVI’s Free Self-Paced Java Programming Course that covers everything from variables and control flow to OOP, at your own pace, in your language.

7. Right Pascal’s Triangle Star Patterns

An upper right triangle joined with a downward-pointing one. Think of it as a “mountain” lying on its side.

for (int i = 1; i <= rows; i++) {         // upper: increasing

    for (int j = 1; j <= i; j++) System.out.print("*");

    System.out.println();

}

for (int i = rows - 1; i >= 1; i--) {    // lower: decreasing

    for (int j = 1; j <= i; j++) System.out.print("*");

    System.out.println();

}

```

**Output (n=4):**

```

*

**

***

****

***

**

*

Concept tested: Combining ascending and descending triangles

8. Hollow Pyramid Star Patterns

Same outer structure as the pyramid, but only border stars are printed. An if condition gates the interior; only the first column, last column, and bottom row get a *.

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= rows - i; j++) System.out.print(" ");

    for (int j = 1; j <= 2 * i - 1; j++) {

        if (j == 1 || j == 2 * i - 1 || i == rows) { // border condition

            System.out.print("*");

        } else {

            System.out.print(" ");

        }

    }

    System.out.println();

}

```

**Output (n=4):**

```

   *

  * *

 *   *

*******

Concept tested: Conditional printing, border vs interior distinction

9. Diamond Star Patterns

A diamond is a pyramid on top of an inverted pyramid, sharing no duplicate middle row. This is one of the most commonly asked medium-difficulty patterns.

// Upper half

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= rows - i; j++) System.out.print(" ");

    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");

    System.out.println();

}

// Lower half

for (int i = rows - 1; i >= 1; i--) {

    for (int j = 1; j <= rows - i; j++) System.out.print(" ");

    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");

    System.out.println();

}

```

**Output (n=4):**

```

   *

  ***

 *****

*******

 *****

  ***

   *

Concept tested: Pyramid + inverted pyramid combination

10. Hollow Diamond Star Patterns

A hollow diamond prints only the outermost stars; spaces fill the inside. The condition checks if the star is on the first or last column of each row.

// Upper hollow pyramid

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= rows - i; j++) System.out.print(" ");

    for (int j = 1; j <= 2 * i - 1; j++) {

        if (j == 1 || j == 2 * i - 1) System.out.print("*"); // only borders

        else System.out.print(" ");

    }

    System.out.println();

}

// Lower hollow inverted pyramid

for (int i = rows - 1; i >= 1; i--) {

    for (int j = 1; j <= rows - i; j++) System.out.print(" ");

    for (int j = 1; j <= 2 * i - 1; j++) {

        if (j == 1 || j == 2 * i - 1) System.out.print("*");

        else System.out.print(" ");

    }

    System.out.println();

}

```

**Output (n=4):**

```

   *

  * *

 *   *

*     *

 *   *

  * *

   *

Concept tested: Border-only condition on a symmetric shape

All six skills: user research, wireframing, visual design, interaction design, usability testing, and collaboration are taught in HCL GUVI’s UI/UX Design course through structured modules and real-world project assignments.

11. Sandglass Star Patterns

Wide at the top and bottom, narrow in the middle like a sandglass. Start with the inverted pyramid, then build upward.

// Top: inverted pyramid
for (int i = rows; i >= 1; i--) {
    for (int j = 1; j <= rows - i; j++) System.out.print(" ");
    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");
    System.out.println();
}
// Bottom: upright pyramid
for (int i = 2; i <= rows; i++) {
    for (int j = 1; j <= rows - i; j++) System.out.print(" ");
    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");
    System.out.println();
}
```
**Output (n=4):**
```
*******
 *****
  ***
   *
  ***
 *****
*******

Concept tested: Inverted + upright pyramid join, loop starting point

Pattern programs are often used by interviewers to evaluate logical thinking before moving on to coding and DSA questions. Build a stronger foundation in algorithms, data structures, and problem-solving with HCL GUVI’s free DSA Tutorial and become interview-ready faster.

12. Hourglass Star Patterns

Similar shape to the sandglass, but flipped: the widest rows sit at the outer edges, and the narrowest point sits in the middle. Count down from the full row count, then continue counting up from row 2.

for (int i = rows; i >= 1; i--) {
    for (int j = 1; j <= rows - i; j++) System.out.print(" ");
    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");
    System.out.println();
}
for (int i = 2; i <= rows; i++) {
    for (int j = 1; j <= rows - i; j++) System.out.print(" ");
    for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");
    System.out.println();
}

Output (n=4):

*******
 *****
  ***
   *
  ***
 *****
*******

Concept tested: symmetric contraction followed by expansion.

13. Butterfly Star Patterns

This one asks you to print two mirrored right triangles on the same row, with a gap between them that shrinks as the rows increase.

// Upper half
for (int i = 1; i <= rows; i++) {
    for (int j = 1; j <= i; j++) System.out.print("*");
    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(" ");
    for (int j = 1; j <= i; j++) System.out.print("*");
    System.out.println();
}
// Lower half
for (int i = rows; i >= 1; i--) {
    for (int j = 1; j <= i; j++) System.out.print("*");
    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(" ");
    for (int j = 1; j <= i; j++) System.out.print("*");
    System.out.println();
}

Output (n=4):

*      *
**    **
***  ***
********
********
***  ***
**    **
*      *

Concept tested: three inner loops per row, mirror symmetry, and the gap formula.

14. Hollow Butterfly Patterns

Same structure as the butterfly, but only border positions print a star. Add a border condition inside each wing.

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= i; j++) {

        if (j == 1 || j == i) System.out.print("*"); else System.out.print(" ");

    }

    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(" ");

    for (int j = 1; j <= i; j++) {

        if (j == 1 || j == i) System.out.print("*"); else System.out.print(" ");

    }

    System.out.println();

}

for (int i = rows; i >= 1; i--) {

    for (int j = 1; j <= i; j++) {

        if (j == 1 || j == i) System.out.print("*"); else System.out.print(" ");

    }

    for (int j = 1; j <= 2 * (rows - i); j++) System.out.print(" ");

    for (int j = 1; j <= i; j++) {

        if (j == 1 || j == i) System.out.print("*"); else System.out.print(" ");

    }

    System.out.println();

}

```

**Output (n=4):**

```

*      *

**    **

* *  * *

*  **  *

*  **  *

* *  * *

**    **

*      *

Concept tested: Border conditions on mirrored wings

Complex patterns require more than memorization; they demand a clear understanding of loops, conditions, and program flow. Strengthen your Java fundamentals with HCL GUVI’s free Java Tutorial and gain the confidence to tackle interview questions independently.

15. Hollow Square Patterns

A 2D grid where only the border cells print a star. The condition is simple: first row, last row, first column, or last column.

for (int i = 1; i <= rows; i++) {

    for (int j = 1; j <= rows; j++) {

        if (i == 1 || i == rows || j == 1 || j == rows) // border check

            System.out.print("*");

        else

            System.out.print(" ");

    }

    System.out.println();

}

```

**Output (n=5):**

```

*****

*   *

*   *

*   *

*****

Concept tested: 2D grid traversal, multi-condition border check

Beyond Stars: Number and Character Patterns

Once an interviewer sees you’ve genuinely understood star patterns, a common follow-up is asking you to swap the stars for numbers or letters, using the exact same loop structure.

• Number patterns: replace System.out.print("*") with System.out.print(j) to print 1, 2, 3 instead of stars, or System.out.print(i) to repeat the row number across the row.
• Character patterns: print letters using (char)('A' + j - 1) inside the loop to produce A, B, C sequences, a common variation on triangle and pyramid patterns specifically.

The loop logic doesn’t change at all, only what gets printed inside it does. This is exactly why understanding the why behind each pattern matters more than memorizing 15 separate programs.

Making Pattern Code More Efficient

For small values of n, System.out.print() inside nested loops is perfectly fine.

But if an interviewer asks how you’d optimize this for very large patterns, mention StringBuilder: build the full row as a string first, then print it once per row instead of calling System.out.print() on every single character.

StringBuilder row = new StringBuilder();
for (int j = 1; j <= i; j++) {
    row.append("*");
}
System.out.println(row);

This reduces the number of I/O calls from n² down to n, which is a genuinely good answer if the question comes up.

Top Star Patterns in Java for Interviews in India 2026

For Java interviews in India, star-pattern questions are useful practice for understanding nested loops, conditional logic, row-column relationships, and output formatting. 

Current Java pattern guides continue to position these problems as interview and logic-building exercises.

If you’re preparing for fresher or entry-level coding rounds in 2026, focus first on these patterns:

• Right Triangle: builds basic nested-loop understanding.
• Pyramid: introduces spaces and the 2 * i – 1 star formula.
• Inverted Pyramid: tests reverse loop logic.
• Diamond: combines an upward and downward pattern.
• Hollow Pyramid: introduces conditional border printing.
• Butterfly: tests symmetry, spacing, and multiple inner loops.
• Hollow Square: strengthens row-column and boundary conditions.

The goal isn’t to memorize 15 separate programs. Instead, understand how rows, columns, spaces, stars, and conditions interact. 

Once you can identify those relationships, you can usually build a new pattern during an interview rather than recalling it line by line.

Common Mistakes to Avoid in Interviews

Even if you know the code, these slip-ups can cost you:

• Off-by-one errors: check whether your loop starts at 0 or 1 and whether it ends at < n or <= n
• Forgetting System.out.println(): missing the newline after each row collapses your pattern into one line
• Wrong space formula: for pyramids, spaces = rows – i, not i – 1 (they give different results for off-center alignment)
• Explaining nothing: writing silent code in an interview is a red flag; narrate your loop logic as you write it
• Hardcoding n: always take n as user input via Scanner unless told otherwise

Colour theory, typography, and layout composition are the visual design fundamentals that define great UI work. HCL GUVI’s UI/UX Design course includes dedicated visual design modules with real client-grade project feedback.

While pattern programs improve logical thinking, interview success also depends on strong coding fundamentals and problem-solving skills.

Combine Java practice with Data Structures and Algorithms to prepare effectively for technical interviews.

Wrapping Up

Star patterns programs aren’t just interview filler, they’re a genuine test of how you think through a problem step by step. 

If you can look at a diamond or a butterfly and immediately start breaking it into rows, loops, and conditions, you’ve built the kind of logical thinking that carries over into algorithms, data structures, and real-world Java development.

The 15 star patterns in this guide cover everything from basic triangles to complex hollow butterflies. 

Work through them in order, test each one with n = 4 and n = 5, and try explaining your logic out loud; that last part is what interviewers actually remember.

FAQs