Im Artikel Muster in Java ist es wichtig, die Funktionsweise von Schleifen zu verstehen, bevor Sie eine Programmiersprache in Java lernen und tief in die fortgeschrittenen Konzepte eintauchen. Es gibt jedoch drei Arten von Schleifen: for-, while- und do-while-Schleifen. Jede Schleife wird entsprechend der jeweiligen Situation eines Programms verwendet, da sie sich geringfügig voneinander unterscheiden. Um verschiedene Schleifen verwenden zu können, ist eine gewisse Programmierlogik erforderlich. Zu diesem Zweck werden den Programmierern Musterübungen an die Hand gegeben, die den Einsatz logischer und logischer Argumentation erfordern. Beispielsweise können geometrische Figuren (wie Dreiecke, Quadrate usw.), Pyramiden, Kästchen in verschiedenen Sternenmustern, Zahlen und Zeichenstilen auf dem Konsolenbildschirm gedruckt werden. Das Format oder die grundlegende Syntax der Schleifen kann von Programmiersprache zu Programmiersprache unterschiedlich sein, aber die allgemeine Logik zum Drucken dieser Muster bleibt dieselbe.
WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 ProbetestsLassen Sie uns anhand einiger Beispiele verstehen, wie man Muster in Java zeichnet
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();
}
}
}Ausgabe:
Im obigen Beispiel sind nur 2 Grundschleifen erforderlich, um das Muster zu drucken; Die erste for-Schleife dient der Anzahl der Zeilen. In unserem Fall haben wir die Zeilen definiert, also 5, ansonsten können wir auch die Eingaben des Benutzers übernehmen und in einer Variablen speichern. Die innere Schleife dient dazu, die Zahlen in einer bestimmten Zeile auszugeben. Nach Abschluss einer Zeile oder dem Ende der „j“-Schleife wird die Zeile mit println() geändert.
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();
}
}
}Ausgabe:
Im obigen Beispiel müssen wir den Pfeil in zwei Hälften teilen und für jede Hälfte 2 Schleifen verwenden. Die erste Hälfte der Zeilen wäre der für Zeilen festgelegte Anfangswert, wohingegen die Zeilenanzahl um 1 kleiner ist als der Anfangswert für die untere Hälfte. Innere Schleifen für beide Hälften werden verwendet, um jede Zeile entsprechend der äußeren Schleife zu durchlaufen.
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();
}
}
}Ausgabe:
Im obigen Beispiel müssen wir drei Dinge tun, d. h. die Gesamtzahl der Zeilen für den Druck der Pyramide berücksichtigen, für die die erste for-Schleife von 1 bis variabel arbeitet. Zweitens müssen wir zuerst die Leerzeichen in der Pyramide und dann das Muster (*) nach den Leerzeichen drucken. Für diese zweite und dritte Schleife werden for-Schleifen innerhalb der äußeren Schleife „i“ verwendet.
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();
}
}
}Ausgabe:
Eine einfache Halbpyramide ist einfach, da wir mit den Zahlen * oder den Zeichen umgehen müssen, die wir drucken, aber für die umgekehrte Pyramide müssen wir zuerst die Leerzeichen und dann das Muster drucken, das in unserem Fall (*) ist . Es werden also 3 for-Schleifen verwendet, die ähnlich wie im Fall der vollständigen Pyramide funktionieren.
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();
}
}
}Ausgabe:
Die Pyramide wird mit der gleichen Logik wie im obigen Beispiel gedruckt, wobei zwei for-Schleifen verwendet werden, eine für die Anzahl der Zeilen und eine für das Drucken von Zeichen in einer bestimmten Zeile. Zu beachten ist aber vor allem der Umgang mit Zeichendaten. Beispielsweise hat „A“ in Java den numerischen Wert 65, sodass die gesamte mathematische Logik unter Verwendung des numerischen Werts des Alphabets ausgeführt und am Ende im Zeichenformat ausgegeben wird.
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();
}
}
}Ausgabe:
Das Grundmuster für den Umgang mit dem Zeichenwert und den beiden for-Schleifen im obigen Beispiel ähnelt Beispiel 5, der einzige Unterschied besteht in der einfachen Logik, die zum Drucken des gewünschten Musters verwendet wird.
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();
}
}
}Ausgabe:
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.
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.
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:
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.
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.
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.
Das obige ist der detaillierte Inhalt vonMuster in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
