In the article Patterns in Java, before learning any programming language in Java and diving deep into the advanced concepts, it is important 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. For example, it can be printing geometric figures (like triangles, squares, etc.), pyramids, boxes in various patterns of stars, numbers, and character styles 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 the 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. The first half of the rows would be the initial value set for rows, whereas the row count is 1 less than the initial value for the lower half. Inner loops for both halves are used to iterate through each row according to the outer loop.

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 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 we are printing, but for the reverse pyramid, we need to first print the spaces and then the pattern, which is (*) in our case. So 3 ?for? loops are used, working similarly to the ones in the case of the full pyramid.

Example 5: Printing half the 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. For example, ‘A’ has a numeric value of 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 ? ?loop is used for the length or number of rows in the square, and the inner ? ?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 the 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. Our program 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. Basically, we need to use the loops to do the coding to print 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 to create both pyramids, one in an upward direction and another in an inverted direction. Thus, the first ?loop is for the number of lines or rows in the pattern, and the second is 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 a 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 the 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 patterns.

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, 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.

The above is the detailed content of Patterns in Java. For more information, please follow other related articles on the PHP Chinese website!