Introduction to Patterns in Java
In article Patterns in Java, before learning any programming language in Java and dive deep into the advanced concepts, it is very important and foremost part to understand the working of loops. Though there are 3 types of loops which are for, while and do-while loop. Each loop is used according to the particular situation of a program as they are slightly different from each other. In order to use various loops requires some programming logic and for this purpose, patterns practice is given to the programmers as it involves the use of logical and reasoning power. It can be the printing of geometric figures (like triangle, square, etc), pyramid, boxes in various patterns of stars, numbers, character style on the console screen. The format or basic syntax of the loops may differ from one programming language to another but the general logic to print these patterns remains the same.
Example of Patterns in Java
Let’s understand how to draw patterns in Java through some examples
Example1: Printing half pyramid using numbers.
Code:
public class Pyramid
{
public static void main(String[] args)
{
int i, j;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
//innermost loop is to print the numbers in the specific rows for (j=1; j<=i; j++)
{
System.out.print(j +" " );
}
System.out.println();
}
}
}
Output:
In the above example, only 2 basic loops are required to print the pattern, the first for loop is for the number of rows. In our case we have defined the rows, i.e. 5, otherwise we can also take the input from the user and store it in a variable. The inner loop is to print the numbers in a particular row, After the completion of 1 row or the end of the ‘j’ loop, the line is changed using println().
Example2: Printing arrow of numbers.
Code:
public class NumberTriangle
{
public static void main(String[] args)
{
int i, j;
int rows =7;
//outermost loop to represent the number of rows which is 7 in this case
//for the upper half of arrow
for (i=1; i<= rows; i++)
{
//innermost loop is to print the numbers in the specific rows
//for the upper half of arrow
for (j=1; j<=i; j++)
{
System.out.print(j + " ");
}
System.out.println();
}
//outermost loop to represent the number of rows which is 6 in this case
//for the lower half of arrow
for (i=rows-1; i>=1; i--)
{
//innermost loop is to print the numbers in the specific rows
//for the lower half of arrow
for (j=1; j<=i; j++)
{
System.out.print(j + " ");
}
System.out.println();
}
}
}
Output:
In the above example, we need to divide the arrow into two halves and use 2 loops for each half. In the first half of the number of rows would be the initial value set for rows whereas for the lower half row count is 1 less than the initial value. Inner loops for both halves are used to iterate through each row according to the outer loop.
4.8 (5,471 ratings)
View Course
Example3: Printing full pyramid using stars(*).
Code:
public class FullPyramid
{
public static void main(String[] args)
{
int i, j, k;
int rows = 5;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= rows; i++)
{
//innermost loop to represent the spaces in pyramid for (j= 1; j<= rows-i; j++)
{
System.out.print(" ");
}
//innermost loop to represent the stars (*) in pyramid for (k= 1; k<= 2*i-1; k++)
{
System.out.print("* ");
}
System.out.println();
}
}
}
Output:
In the above example, we need to do 3 things, i.e. keeping in mind the total number of rows for the printing of the pyramid for which the first for loop is working from 1 to rows variable. Secondly, we first need to print the spaces in the pyramid and then the pattern (*) after the spaces. For this second and third for loops are used which are inside the outer loop ‘i’ .
Example 4: Printing half reverse pyramid using numbers.
Code:
public class ReversePyramid
{
public static void main(String[] args)
{
int i, j, k;
int rows = 5;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= rows; i++)
{
//innermost loop to represent the spaces
for (j= 1; j<= rows-1; j++)
{
System.out.print(" ");
}
//innermost loop to represent the stars (*) in pyramid for (k= 1; k<= i; k++)
{
System.out.print("* ");
}
System.out.println();
}
}
}
Output:
Simple half pyramid is easy as we need to handle the numbers, * or the characters which we are printing, but for the reverse pyramid, we need to first print the spaces and after that the pattern which is (*) in our case. So 3 for loops are used working similarly to the ones in case of the full pyramid.
Example 5: Printing half pyramid using alphabets.
Code:
public class AlphabetPyramid
{
public static void main(String[] args)
{
int i, j;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
//innermost loop to represent the alphabets in a pyramid in particular row for (j= 1; j<= i; j++)
{
System.out.print((char)(ch + i - 1) + " ");
}
System.out.println();
}
}
}
Output:
The pyramid is printed with the same logic as used in the above example using 2 for loops, one for the number of rows and others for the character printing in a particular row. But the main thing that should be noted is the handling of character data. ‘A’ has a numeric value 65 in Java so all the mathematical logic is performed using the numeric value of the alphabet and in the end, it is printed in the character format.
Example 6: Printing pattern of alphabets.
Code:
public class AlphabetPattern
{
public static void main(String[] args)
{
int i, j;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
//innermost loop to represent the alphabets for (j= 1; j<= i; j++)
{
System.out.print((char)(ch - 1 + j) + " ");
}
System.out.println();
}
}
}
Output:
The basic pattern followed to deal with the character value and the 2 for loops in the above example is similar to Example 5 only difference being the simple logic used to print the desired pattern.
Example 7: Printing square using stars (*).
Code:
public class SquarePattern
{
public static void main(String[] args)
{
int i, j;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
//innermost loop to represent the stars (*) for (j= 1; j<= 5; j++)
{
System.out.print(" * " + " ");
}
System.out.println();
}
}
}
Output:
For printing of square, we need length and width, i.e. both sides of the square should be the same, which is 5 in our case. So the first for loop is used for the length or number of rows in square and the inner for loop is used for the width of the square, i.e. 5 stars in a single row.
Example 8: Printing rectangle using stars (*).
Code:
public class RectanglePattern
{
public static void main(String[] args)
{
int i, j;
//outermost loop to represent the number of rows which is 5 in this case for(i= 1; i<= 5; i++)
{
int ch = 65;
//innermost loop to represent columns the stars (*) for (j= 1; j<= 9; j++)
{
System.out.print(" * " + " " );
}
System.out.println();
}
}
}
Output:
The basic logic of printing the rectangle of (*) is the same as printing of squares, the only difference between is different length and width of the rectangle. Here ‘i’ loop is for the length of the rectangle and the inner ‘j’ loop is for the width of the loop. In our program, it is taken as a constant value, we can also ask the user and store them in separate variables.
Example 9: Printing a Diamond using stars.
Printing a diamond in Java is a very simple process. It involves printing 2 pyramids, 1 in the upward direction and another in an inverted direction. So basically we need to use the loops in the same way we do the coding for printing two separate pyramids.
Code:
public class Diamond
{
public static void main(String[] args)
{
int i, j, k;
int rows = 5;
//outermost loop to represent the number of rows which is 5 in this case.
// Creating upper pyramid
for(i= 1; i<= rows; i++)
{
//innermost loop to represent the spaces in upper pyramid for (j= 1; j<= rows-i; j++)
{
System.out.print(" ");
}
//innermost loop to represent the stars (*) in upper pyramid for (k= 1; k<= 2*i-1; k++)
{
System.out.print("* ");
}
System.out.println();
}
//outermost loop for the rows in the inverted pyramid for (i = rows-1; i>0; i--)
{
//innermost loop for the space present in the inverted pyramid for (j=1; j<= rows - i; j++)
{
System.out.print(" ");
}
//innermost loop inside the outer loop to print the ( * ) pattern in inverted pyramid for (k = 1; k<= 2*i-1; k++)
{
System.out.print("* ");
}
System.out.println();
}
}
}
In the above example, almost the same logic is applied for creating both the pyramids, one in an upward direction and another in an inverted direction. Very first for loop is for the number of lines or rows in the pattern and another two for loops are for spaces and the stars (*) pattern in the pattern.
Output:
Example 10: Printing binary numbers in a stair format.
Code:
public class BinaryStair
{
public static void main(String[] args)
{
int i, j;
//outer loop for the total rows which is 5 in this case for (i = 1; i <= 5; i++)
{
//inner loop for the pattern of 0 and 1 in each row for (j = 1; j<= i ; j++)
{
if (j % 2 ==0)
{
System.out.print(0);
}
else
{
System.out.print(1);
}
}
System.out.println();
}
}
}
Output:
In the above example, in order to print binary pattern , outer for loop ‘i’ is used for total number of rows and the inner for loop ‘j’ is used to iterate till the outer loop ‘i’ because for the 1st row we need 1 value, for the 2nd row we need 2 values, and so on. If and else statements are used in order to print alternate value of 0 and 1. Suppose for the first time i=1, j=1 and 1%2 != 0 then 1 is printed and execution will move out of the inner loop.
Example 11: Program to print repeating alphabet pattern.
Code:
public class AlphabetReverseOrder
{
public static void main(String[] args)
{
int i, j, k;
//outer loop for the total rows which is 5 in this case for (i = 0 ; i<=5; i++)
{
int ch= 65;
//inner loop for the pattern of alphabets in till ‘i’ loop for (j = 0; j <=i ; j++)
{
System.out.print((char) (ch+j) + " ");
}
//inner loop for the pattern of alphabets in reverse order from ‘i’ loop for (k= i-1; k >=0; k--)
{
System.out.print((char) (ch+k) + " ");
}
System.out.println();
}
}
}
Output:
In the above example, if we observe each row of pattern, we need to print the alphabet first in the increasing order, i.e. A B and then in the reverse order, i.e. A B A. For this, we need 3 loops, 1st for loop for the total number of rows. 2nd for loop to print the alphabets in increasing order then the 3rd for loop which remains inside the outer ‘i’ loop and prints the alphabets in the same line but in reverse order of ‘j’ loop.
Conclusion
The above example and their explanations clearly show how to make such patterns in Java. Though these patterns seem to be difficult in the starting but observing them deeply of how the repetition of pattern is happening in a single row and according to how many loops should be used, it becomes easy to do hands-on on this. Today also in interviews of big companies, candidates are asked to write the logic of patterns of varying difficulty levels. Because this pattern making shows the basic logical and programming knowledge of an individual.
Recommended Article
This has been a guide to Patterns in Java. Here we discuss Introduction to Patterns in Java and the Examples of Different Patterns along with Output. You can also go through our other suggested articles to learn more –
