Introdução aos padrões em Java
No artigo Padrões em Java, antes de aprender qualquer linguagem de programação em Java e aprofundar-se nos conceitos avançados, é muito importante e fundamental entender o funcionamento dos loops. Embora existam 3 tipos de loops para loop while e do-while. Cada loop é usado de acordo com a situação particular de um programa, pois eles são ligeiramente diferentes um do outro. Para usar vários loops, é necessária alguma lógica de programação e, para esse propósito, a prática de padrões é dada aos programadores, pois envolve o uso do poder lógico e de raciocínio. Pode ser a impressão de figuras geométricas (como triângulo, quadrado, etc.), pirâmide, caixas em vários padrões de estrelas, números, estilo de caractere na tela do console. O formato ou sintaxe básica dos loops pode diferir de uma linguagem de programação para outra, mas a lógica geral para imprimir esses padrões permanece a mesma.
Exemplo de padrões em Java
Vamos entender como desenhar padrões em Java através de alguns exemplos
Exemplo1: Imprimir meia pirâmide usando números.
Código:
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();
)
)
)
Resultado:
No exemplo acima, apenas 2 loops básicos são necessários para imprimir o padrão, o primeiro loop for é para o número de linhas. No nosso caso, definimos as linhas, ou seja, 5, caso contrário, também podemos pegar a entrada do usuário e armazená-la em uma variável. O loop interno é para imprimir os números em uma linha específica. Após a conclusão de 1 linha ou o final do loop 'j', a linha é alterada usando println ().
Exemplo2: Imprimir seta de números.
Código:
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();
)
)
)
Resultado:
No exemplo acima, precisamos dividir a seta em duas metades e usar 2 loops para cada metade. Na primeira metade do número de linhas, seria o valor inicial definido para as linhas, enquanto que para a metade inferior, a contagem de linhas é 1 menor que o valor inicial. Os loops internos das duas metades são usados para percorrer cada linha de acordo com o loop externo.
Exemplo 3: Imprimir pirâmide completa usando estrelas (*).
Código:
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();
)
)
)
Resultado:
No exemplo acima, precisamos fazer três coisas, ou seja, tendo em mente o número total de linhas para a impressão da pirâmide para a qual o primeiro loop for está trabalhando da variável 1 para as linhas. Em segundo lugar, primeiro precisamos imprimir os espaços na pirâmide e depois o padrão (*) após os espaços. Para este segundo e terceiro loops for, são utilizados dentro do loop externo 'i'.
Exemplo 4: Imprimir meia pirâmide reversa usando números.
Código:
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();
)
)
)
Resultado:
A meia pirâmide simples é fácil, pois precisamos lidar com os números * ou os caracteres que estamos imprimindo, mas para a pirâmide reversa, precisamos primeiro imprimir os espaços e depois o padrão que é (*) no nosso caso. Portanto, 3 para loops são usados trabalhando de maneira semelhante aos no caso da pirâmide completa.
Exemplo 5: Imprimindo meia pirâmide usando alfabetos.
Código:
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();
)
)
)
Resultado:
A pirâmide é impressa com a mesma lógica usada no exemplo acima, usando 2 para loops, uma para o número de linhas e outras para o caractere impresso em uma linha específica. Mas a principal coisa que deve ser notada é a manipulação de dados de caracteres. 'A' possui um valor numérico 65 em Java, portanto toda a lógica matemática é realizada usando o valor numérico do alfabeto e, no final, é impressa no formato de caractere.
Exemplo 6: Padrão de impressão de alfabetos.
Código:
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();
)
)
)
Resultado:
O padrão básico seguido para lidar com o valor do caractere e os 2 para loops no exemplo acima é semelhante à diferença do Exemplo 5, sendo a única lógica simples usada para imprimir o padrão desejado.
Exemplo 7: Imprimindo quadrados usando estrelas (*).
Código:
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();
)
)
)
Resultado:
Para a impressão do quadrado, precisamos de comprimento e largura, ou seja, os dois lados do quadrado devem ser iguais, o que é 5 no nosso caso. Portanto, o primeiro loop for é usado para o comprimento ou o número de linhas em quadrado e o loop for interno é usado para a largura do quadrado, ou seja, 5 estrelas em uma única linha.
Exemplo 8: Imprimir retângulo usando estrelas (*).
Código:
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();
)
)
)
Resultado:
A lógica básica de imprimir o retângulo de (*) é igual à impressão de quadrados, a única diferença entre os diferentes comprimentos e larguras do retângulo. Aqui o loop 'i' é para o comprimento do retângulo e o loop interno 'j' é para a largura do loop. Em nosso programa, é tomado como um valor constante, também podemos pedir ao usuário e armazená-lo em variáveis separadas.
Exemplo 9: Imprimindo um diamante usando estrelas.
Imprimir um diamante em Java é um processo muito simples. Envolve imprimir 2 pirâmides, 1 na direção para cima e outra na direção invertida. Então, basicamente, precisamos usar os loops da mesma maneira que fazemos a codificação para imprimir duas pirâmides separadas.
Código:
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();
)
)
)
No exemplo acima, quase a mesma lógica é aplicada para criar as pirâmides, uma na direção ascendente e outra na direção invertida. O primeiro loop for refere-se ao número de linhas ou linhas no padrão e outros dois para loops são para espaços e o padrão de estrelas (*) no padrão.
Resultado:
Exemplo 10: Imprimindo números binários em um formato de escada.
Código:
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();
)
)
)
Resultado:
No exemplo acima, para imprimir um padrão binário, o loop for externo 'i' é usado para o número total de linhas e o loop for interno 'j' é usado para iterar até o loop externo 'i' porque, para a primeira linha precisamos de 1 valor, para a segunda linha precisamos de 2 valores e assim por diante. Se as instruções if e else forem usadas para imprimir valores alternativos de 0 e 1. Suponha pela primeira vez que i = 1, j = 1 e 1% 2! = 0, então 1 seja impresso e a execução sairá da laço interno.
Exemplo 11: Programa para imprimir padrões repetitivos de alfabeto.
Código:
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();
)
)
)
Resultado:
No exemplo acima, se observarmos cada linha do padrão, precisamos imprimir o alfabeto primeiro na ordem crescente, ou seja, AB e depois na ordem inversa, ou seja, AB A. Para isso, precisamos de 3 loops, primeiro para loop para o número total de linhas. O segundo loop for imprime os alfabetos em ordem crescente e o terceiro loop for, que permanece dentro do loop externo 'i' e imprime os alfabetos na mesma linha, mas na ordem inversa do loop 'j'.
Conclusão
O exemplo acima e suas explicações mostram claramente como criar esses padrões em Java. Embora esses padrões pareçam difíceis no início, mas observando-os profundamente de como a repetição do padrão está acontecendo em uma única linha e de acordo com a quantidade de loops que devem ser usados, torna-se fácil fazer isso de maneira prática. Hoje também em entrevistas de grandes empresas, os candidatos são convidados a escrever a lógica de padrões de diferentes níveis de dificuldade. Porque essa criação de padrões mostra o conhecimento lógico e de programação básico de um indivíduo.
Artigo recomendado
Este foi um guia para padrões em Java. Aqui discutimos Introdução aos padrões em Java e os exemplos de diferentes padrões, juntamente com a saída. Você também pode consultar nossos outros artigos sugeridos para saber mais -
- Padrões de estrelas em Java
- Estruturas em Java
- Layout em Java
- Introdução aos padrões em PHP
- Padrões em JavaScript com exemplos