DEV Community: Kaviya.k

For loop Number pattern:

Kaviya.k — Fri, 14 Feb 2025 06:57:17 +0000

Numbers pattern(1to9):

package B1;

public class Npattern {

    public static void main(String[] args) {
        // Npattern1();
        // Npattern2();
        // Npattern3();
        // Npatern4();
        // Npattern5();
        // Npattern6();
        // Npattern7();
        // Npattern8();
        // Npattern9();
        Npattern10();

    }

    private static void Npattern10() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (col == 3 || col == 9 || col == 1)
                    System.out.print("* ");
                else if (row == 1 && col >= 3 || row == 9 && col >= 3)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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


    private static void Npattern9() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 9 || row == 1 || col == 9)
                    System.out.print("* ");
                else if (row == 5 || col == 1 && row <= 5)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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



    private static void Npattern8() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 5 || row == 1 || row == 9)
                    System.out.print("* ");
                else if (col == 1 || col == 9)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }
    }
output:

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


    private static void Npattern7() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 1 || row + col == 10)
                    System.out.print("* ");

                else
                    System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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

    private static void Npattern6() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 5 || row == 1 || row == 9)
                    System.out.print("* ");
                else if (col == 1 || col == 9 && row >= 5)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }
    }
output:

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


    private static void Npattern5() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 5 || row == 1 || row == 9)
                    System.out.print("* ");
                else if (col == 1 && row <= 5 || col == 9 && row >= 5)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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


    private static void Npatern4() {

        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 5 || col == 5)
                    System.out.print("* ");
                else if (row + col == 6 && row <= 5)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }
    }
output:

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

    private static void Npattern3() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 9 || row == 5 || row == 1)
                    System.out.print("* ");
                else if (col == 9 && row <= 5 || col == 9 && row >= 5)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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


    private static void Npattern2() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 9 || row == 5 || row == 1)
                    System.out.print("* ");
                else if (col == 1 && row >= 5 || col == 9 && row <= 5)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }
    }
output:

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


    private static void Npattern1() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if (row == 9 || col == 5 || col + row == 6 && row <= 4)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }
    }
}

output:

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

Star and numbers pattern:


package B1;

public class NSpattern {

    public static void main(String[] args) {
        pattern();
        // pattern1();
        // pattern2();
        // pattern3();
        // pattern4();
        // pattern5();
        // pattern6();

    }

    private static void pattern() {
        for (int row = 1; row <= 5; row++) {
            for (int col = 1; col <= row; col++)
                System.out.print("* ");

            System.out.println();
        }

    }
output:
* 
* * 
* * * 
* * * * 
* * * * * 


    private static void pattern6() {
        for (int row = 5; row >= 1; row--) {
            for (int col = 1; col <= row; col++)
                System.out.print(row + col + " ");
            System.out.println();
        }

    }
output:

6 7 8 9 10 
5 6 7 8 
4 5 6 
3 4 
2 


    private static void pattern5() {
        for (int row = 5; row >= 1; row--) {
            for (int col = 1; col <= row; col++)
                System.out.print(row / col + " ");
            System.out.println();
        }
    }
output:

5 2 1 1 1 
4 2 1 1 
3 1 1 
2 1 
1 


    private static void pattern4() {
        for (int row = 5; row >= 1; row--) {
            for (int col = 1; col <= row; col++)
                System.out.print(row * col + " ");
            System.out.println();
        }
    }
output:

5 10 15 20 25 
4 8 12 16 
3 6 9 
2 4 
1



    private static void pattern3() {
        for (int row = 5; row >= 1; row--) {
            for (int col = 1; col <= row; col++)
                System.out.print(col + " ");
            System.out.println();
        }
    }
output:

1 2 3 4 5 
1 2 3 4 
1 2 3 
1 2 
1 



    private static void pattern2() {
        for (int row = 5; row >= 1; row--) {
            for (int col = 1; col <= row; col++)
                System.out.print(row + " ");
            System.out.println();
        }
    }
output:

5 5 5 5 5 
4 4 4 4 
3 3 3 
2 2 
1 

    private static void pattern1() {
        for (int row = 5; row >= 1; row--) {
            for (int col = 1; col <= row; col++)
                System.out.print("* ");
            System.out.println();
        }

    }

}
output:

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

while loop:

Kaviya.k — Thu, 13 Feb 2025 10:53:40 +0000

Number series:

1.Look at this series: 7, 10, 8, 11, 9, 12, ... What number should come next?

Let's analyze the pattern in this series:

7 → 10 (add 3)
10 → 8 (subtract 2)
8 → 11 (add 3)
11 → 9 (subtract 2)
9 → 12 (add 3)

The pattern alternates between adding 3 and subtracting 2.Since the last operation was adding 3 (from 9 to 12), the next operation should be subtracting 2.

program 1:

public class Series {

    public static void main(String[] args) {
        int no=7;
        int count=0;
    while(count<=6) {
            System.out.println(no);
            no=no+3;
            System.out.println(no);
            no=no-2;
            count=count+2;
        }
    }

}

output:
7
10
8
11
9
12
10
13

2.Look at this series: 36, 34, 30, 28, 24, ... What number should come next?

Let's analyze the pattern:

36 → 34 (subtract 2)
34 → 30 (subtract 4)
30 → 28 (subtract 2)
28 → 24 (subtract 4)

The pattern alternates between subtracting 2 and subtracting 4.so the next operation should be to subtract 2 from 24.

program 2:

package Numbers;

public class Series1 {

    public static void main(String[] args) {
        int no=36;
        int count=0;
        while(count<5) {
            System.out.println(no);
            no=no-2;
            System.out.println(no);
            no=no-4;
            count=count+2;
        }

    }

}
output:
36
34
30
28
24
22

3.Look at this series: 53, 53, 40, 40, 27, 27, ... What number should come next?

let's look at the pattern:

53 → 53 (no change)
53 → 40 (subtract 13)
40 → 40 (no change)
40 → 27 (subtract 13)
27 → 27 (no change)

The pattern alternates between no change and subtracting 13. the next step should be subtracting 13 from 27.

program3:
package Numbers;

public class Series2 {

    public static void main(String[] args) {
        int no=53;
        int count=0;
        while(count<=5){
            System.out.println(no);
            System.out.println(no);
            no=no-13;
            count=count+2;
        }
    }

}
output:
53
53
40
40
27
27

4.Look at this series: 21, 9, 21, 11, 21, 13, 21, ... What number should come next?

Let's break down the pattern:

21 → 9 (subtract 12)
9 → 21 (add 12)
21 → 11 (subtract 10)
11 → 21 (add 10)
21 → 13 (subtract 8)

The pattern alternates between subtracting a number and then adding the same or a different number.
The pattern for subtraction follows: 12, 10, 8 (subtracting 2 each time) the next step should be to add 8 (following the alternating pattern of addition and subtraction).13 + 8 = 21

program 4:
package Numbers;

public class Series3 {

    public static void main(String[] args) {
        int no=58;
        int count=1;
        while(count<=5) {
            System.out.println(no);
            no=no-6;
            count=count+1;
        }
    }

}
output:
58
52
46
40
34

5.Look at this series: 3, 4, 7, 8, 11, 12, ... What number should come next?

Let's look at the pattern:

3 → 4 (add 1)
4 → 7 (add 3)
7 → 8 (add 1)
8 → 11 (add 3)
11 → 12 (add 1)

The pattern alternates between adding 1 and adding 3. the next operation should be adding 3.

program 5:
package Numbers;

public class Series4 {

    public static void main(String[] args) {
        int no=3;
        int count=1;
        while(count<=6){
            System.out.println(no);
            no=no+1;
            System.out.println(no);
            no=no+3;
            count=count+2;
        }
        }

}
output:
3
4
7
8
11
12

6.Look at this series: 8, 22, 8, 28, 8, ... What number should come next?

Let's analyze the pattern:

8 → 22 (add 14)
22 → 8 (subtract 14)
8 → 28 (add 20)
28 → 8 (subtract 20)

The pattern alternates between adding a number and then subtracting the same number, with the numbers being added or subtracted increasing by 6 each time.
The last operation was subtracting 20, so the next step should be to add 26 (because the previous addition increased by 6).

program 6:
package Numbers;

public class Series5 {

    public static void main(String[] args) {
        int no=22;
        int count=0;
        while(count<=5){
            System.out.print(8 +" ");
            System.out.print(no +" ");
            no=no+6;
            count=count+2;
        }
}
}
output:
8 
22 
8 
28 
8 
34

7.Look at this series: 21, 9, 21, 11, 21, 13, 21, ... What number should come next?

Let's analyze the pattern:

21 → 9 (subtract 12)
9 → 21 (add 12)
21 → 11 (subtract 10)
11 → 21 (add 10)
21 → 13 (subtract 8)

The pattern alternates between subtracting an even number and adding the same number.
The subtraction numbers decrease by 2 each time (12, 10, 8). Following this, the next subtraction should be by 6.
So, we subtract 6 from 13:

program 7:
package Numbers;

public class Series6 {

    public static void main(String[] args) {
        int no=9;
        int count=0;
        while(count<8) {
            System.out.println(21);
            System.out.println(no);
            no=no+2;
            count=count+2;
        }

    }

}
output:
21
9
21
11
21
13
21
15

8.Look at this series: 5.2, 4.8, 4.4, 4, ... What number should come next?

Let's look at the pattern:
5.2 → 4.8 (subtract 0.4)
4.8 → 4.4 (subtract 0.4)
4.4 → 4 (subtract 0.4)

The pattern consistently subtracts 0.4.
Following this pattern, the next step would be to subtract 0.4 from 4:
4 - 0.4 = 3.6
So, the next number in the series is 3.6.

program 8:

public class Series7 {
    public static void main(String args[])
    {
    double no=5.2f;
    int count=0;
    while(count<6) {
        System.out.println(no);
        no=  no-0.4;
        count++;
    }
    }
}

output:
5.2
4.8
4.3999999999999995
3.9999999999999996
3.5999999999999996

9.Look at this series: 2, 4, 6, 8, 10, ... What number should come next?

This is a simple series where each number is increasing by 2:
2 → 4 (add 2)
4 → 6 (add 2)
6 → 8 (add 2)
8 → 10 (add 2)
Following this pattern, the next step would be to add 2 to 10:

program:9

package Numbers;

public class Series9 {

    public static void main(String[] args) {
        int no=2;
        int count=1;
        while(count<=6) {
            System.out.println(no);
            no=no+2;
            count=count+1;
        }
    }

}

output:
2
4
6
8
10
12

10.Look at this series: 31, 29, 24, 22, 17, ... What number should come next?

Let's look at the pattern in the series: 31, 29, 24, 22, 17.
31 to 29, the difference is -2.
29 to 24, the difference is -5.
24 to 22, the difference is -2.
22 to 17, the difference is -5.

It seems the pattern alternates between subtracting 2 and subtracting 5. If this pattern continues, the next step would be to subtract 2 from 17.

program 10:

package Numbers;

public class Series11 {

    public static void main(String[] args) {
        int no=31;
        int count=1;
        while(count<=5) {
            System.out.println(no);
            no=no-2;
            System.out.println(no);
            no=no-5;
        count=count+2;
    }

    }
}
output:
31
29
24
22
17
15

Patterns:

Kaviya.k — Thu, 13 Feb 2025 04:09:35 +0000

for loop:

When you know exactly how many times you want to loop through a block of code, use the for loop instead of a while loop.

Syntax:

for (statement 1; statement 2; statement 3) {
// code block to be executed
}

Statement 1 is executed (one time) before the execution of the code block.

Statement 2 defines the condition for executing the code block.

Statement 3 is executed (every time) after the code block has been executed.

Example:
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println(i);
}

}
}

output:
0
1
2
3
4

shape pattern:

package B1;

public class Shape {

    public static void main(String[] args) {
        //shape1();
        //shape2();
         //shape3();
         //shape4();
         //shape5();
         //shape6();
         //shape7();
    }

    private static void shape7() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if(row+col==10||row==col)
                System.out.print("* ");
                else if(row==1||col==1||row==9)
                System.out.print("* ");
                else
                System.out.print("  ");
            }
            System.out.println();
        }

    }
output:


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

    private static void shape6() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if(row+col==10||row==col)
                System.out.print("* ");
                else if(row==1||col==9||row==9)
                System.out.print("* ");
                else
                System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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


    private static void shape5() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if(row+col==10||row==col)
                System.out.print("* ");
                else if(col==1||col==9||row==1)
                System.out.print("* ");
                else
                System.out.print("  ");
            }
            System.out.println();
        }


    }
output:

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


    private static void shape4() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if(row+col==10||row==col)
                System.out.print("* ");
                else if(col==1||col==9||row==9)
                System.out.print("* ");
                else
                System.out.print("  ");
            }
            System.out.println();
        }



    }
output:

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


    private static void shape3() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if(row+col==10||row==col)
                System.out.print("* ");
                else if(col==1||col==9)
                System.out.print("* ");
                else
                System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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


    private static void shape2() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if(row==1||row==9||row==col)
                System.out.print("* ");
                else if(row+col==10||col==1||col==9)
                System.out.print("* ");
                else
                System.out.print("  ");
            }
            System.out.println();
        }

    }
output:

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


    private static void shape1() {
        for (int row = 1; row <= 9; row++) {
            for (int col = 1; col <= 9; col++) {
                if(row==1||row==9||row==col)
                System.out.print("* ");
                else if(row+col==10)
                System.out.print("* ");
                else
                System.out.print("  ");
            }
            System.out.println();
        }
        }

}
output:

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

Letters pattern:

package B1;
public class Spattern2 {

    public static void main(String[] args) {
        //patternE();
        //patternI();
        //patternL();
        //patternF();
        //patternH();
        //patternM();(TBD)
        //patternK();
    }

    private static void patternK() {
        for(int row = 1; row<=9; row++)
        {
            for(int col=1; col<=9; col++) {
                if(row+col==6|| col==1)
                    System.out.print("* "); 
                else if(col==row-4)
                    System.out.print("* "); 
                else
                    System.out.print("  "); 
        }
               System.out.println(); 
        }


    }
output:

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

    private static void patternM() {
        for(int row = 1; row<=9; row++)
        {
            for(int col=1; col<=9; col++) {
                if(col==1||col==9-1)
                    System.out.print("* "); 
                else if(row==col&&col<=9/2||row+col==9-1&&col>=9/2)
                    System.out.print("* "); 
                else
                    System.out.print("  ");
        }
               System.out.println(); 
        }


    }
output:

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


    private static void patternH() {
        for(int row = 1; row<=9; row++)
        {
            for(int col=1; col<=9; col++) {
                if(col==9|| row==5||col==1)
                    System.out.print("* "); 
                else
                    System.out.print("  "); 
        }
               System.out.println(); 
        }


    }
output:

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


    private static void patternF() {
        for(int row = 1; row<=9; row++)
        {
            for(int col=1; col<=9; col++) {
                if(row==1|| row==5||col==1)
                    System.out.print("* "); 
                else
                    System.out.print("  "); 
        }
               System.out.println(); 
        }


    }
output:

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


    private static void patternL() {
        for(int row = 1; row<=9; row++)
        {
            for(int col=1; col<=9; col++) {
                if(row==9||col==1)
                    System.out.print("* "); 
                else
                    System.out.print("  "); 
        }
               System.out.println(); 
        }
    }
output:

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


    private static void patternI() {
        for(int row = 1; row<=9; row++)
        {
            for(int col=1; col<=9; col++) {
                if(row==1||row==9||col==5)
                    System.out.print("* "); 
                else
                    System.out.print("  "); 
        }
               System.out.println(); 
        }
    }
output:

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





    private static void patternE() {
        for(int row = 1; row<=9; row++)
        {
            for(int col=1; col<=9; col++) {
                if(row==1||row==9||col==1)
                    System.out.print("* "); 
                else if(row==5)
                    System.out.print("* "); 
                else
                    System.out.print("  "); 
        }
               System.out.println(); 
        }
    }
    }
output:

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

Do and while loop:

Kaviya.k — Thu, 13 Feb 2025 03:11:31 +0000

while loop

Java while loop is a control flow statement used to execute the block of statements repeatedly until the given condition evaluates to false. Once the condition becomes false, the line immediately after the loop in the program is executed.

The while loop loops through a block of code as long as a specified condition is true.

Syntax of while loop in Java:

while (test_expression) {   

 // statements        

update_expression; 


}

Execution of While Loop in Java:

1.Control enters the while loop.
2.The condition is tested.
3.If true, execute the body of the loop.
4.If false, exit the loop.
5.After executing the body, update the loop variable.
6.Repeat from step-2 until the condition is false.

simple example:

public class Main {
  public static void main(String[] args) {
    int i = 0;
    while (i < 5) {
      System.out.println(i);
      i++;
    }  
  }
}

output:
0
1
2
3
4

The Do-While Loop:

This do-while loop is an exit controlled loop that checks the condition at the end of the code. This loop ensures that the code is executed at least once.

**simple example:**

package B10;

public class loop {

    public static void main(String[] args) {
        int no=1;
        do
        {
            System.out.println(no);
            no=no+1;
        }
        while(no<=5);
    }

}
output:
1
2
3
4
5

Differnce between while and do while loop:

Entry Control Loops

These control the entry to the loop. They check for a condition and the control is transferred inside the loop if, and only if, the condition is true. These loops are used when checking for a condition before execution is mandatory. Example include for and while loops.

Exit Control Loops

An exit control loop controls the exit. The exit control loop checks the condition for an exit. If the given condition for exit is true, control will exit from the loop body, or else control will enter again into the loop. Example is a do-while loop.

Increment and Decrement Operators:

Increment and Decrement Operators are Unary Operators commonly used in programming to increase or decrease the value of a variable by one, respectively.

Increment Operators:

Increment operators are used to increase the value of a variable by one. There are two types of increment operators:
The prefix increment operator (++x) and
The postfix increment operator (x++)

Prefix Increment Operator (++x):

The prefix increment operator increases the value of the variable by 1 before the value is used in the expression.
Syntax: ++x
Example: If x is initially 5, ++x will increment x to 6 and return the new value (6).

Postfix Increment Operator (x++):

The postfix increment operator increases the value of the variable by 1 after the value is used in the expression.
Syntax: x++
Example: If x is initially 5, x++ will return the current value of x (5) and then increment x to 6.

**Example program:**(Increment)

public class Main {
    public static void main(String[] args)
    {
        int x = 5;
        // Prefix increment: increment x by 1 and then print
        // the value (6)
        System.out.println(++x);
        // Postfix increment: print the value of x (6) and
        // then increment x by 1
        System.out.println(x++);
        // Output: 7
        System.out.println(x);
    }
}
output:
6
6
7

Decrement Operators:

Decrement operators are used in programming languages to decrease the value of a variable by one. Similar to increment operators, there are two types of decrement operators:
The prefix decrement operator (--x)
The postfix decrement operator(x--)

Prefix Decrement Operator (--x):
The prefix decrement operator decreases the value of the variable by 1 before the value is used in the expression.
Syntax: --x
Example: If x is initially 5, --x will decrement x to 4 and return the new value (4).

Postfix Decrement Operator (x--):

The postfix decrement operator decreases the value of the variable by 1 after the value is used in the expression.
Syntax: x--
Example: If x is initially 5, x-- will return the current value of x (5) and then decrement x to 4.

Example program:(Decrement)

public class Main {
    public static void main(String[] args)
    {
        int x = 5;
        // Prefix decrement: decrement x by 1 and then print
        // the value (4)
        System.out.println(--x);
        // Postfix decrement: print the value of x (4) and
        // then decrement x by 1
        System.out.println(x--);
        // Output: 3
        System.out.println(x);
    }
}
output:
4
4
3

References:
https://www.simplilearn.com/tutorials/javascript-tutorial/javascript-loops
https://www.geeksforgeeks.org/java-while-loop-with-examples/
https://www.w3schools.com/java/tryjava.asp?filename=demo_while_loop
https://studyopedia.com/java/loops-in-java/

GCD AND LCM:

Kaviya.k — Wed, 05 Feb 2025 04:08:14 +0000

Introduction to GCD and LCM:(TBD)

GCD (Greatest Common Divisor) and LCM (Least Common Multiple) are fundamental concepts in number theory and mathematics. They are used to find relationships between two or more numbers and play a significant role in various mathematical computations and problem-solving.

GCD:(TBD)

The GCD of two or more integers is the largest positive integer that divides each of the given numbers without leaving a remainder. In other words, it is the greatest common factor shared by the numbers. GCD is often denoted by the symbol "gcd(a, b)" or simply "(a, b)".
For example to :
The GCD of { 34,56 } is 2
The GCD of { 64,96 } is 32

How to Find GCD?:(TBD)
Write all the factors of each number.
Select the common factors.
Select the largest number, as GCD.

program:(TBD)

    public class FindGCDExample2  
    {  
    public static void main(String[] args)   
    {  
    int n1=50, n2=60;  
    while(n1!=n2)   
    {  
    if(n1>n2)  
    n1=n1-n2;  
    else  
    n2=n2-n1;  
    }  
    System.out.printf("GCD of n1 and n2 is: " +n2);  
    }  
    }  

Output:
GCD of n1 and n2 is: 10

LCM:(TBD)

The LCM of two or more integers is the smallest positive integer that is divisible by each of the given numbers. It is the least common multiple shared by the numbers. LCM is often denoted by the symbol "lcm(a, b)" or simply "[a, b]". For example to :
The LCM of { 34,56 } is 952
The LCM of { 64,96 } is 192

How to Find the Greatest Common Factor:(TBD)

Write all the factors of each number.
Select the common factors.
Select the greatest number, as GCF.

program:(TBD)
    public class LcmExample1  
    {  
    public static void main(String args[])   
    {  
    int a = 12, b = 9, gcd = 1;  
    //finds GCD  
    for(int i = 1; i <= a && i <= b; ++i)   
    {  
    //divides both the numbers by i, if the remainder   is 0 the number is completely divisible by i  
    //Checks that i is present in both or not  
    //returns true if both conditions are true  
    if(a % i == 0 && b % i == 0)  
    //assigns i into gcd  
    gcd = i;  
    }  
    //determines lcm of the given number  
    int lcm = (a * b) / gcd;  
    //prints the result  
    System.out.printf("The LCM of %d and %d is %d.", a, b, lcm);  
    }  
    } 
output: 
  The LCM of 12 and 9 is 36.

Task:

program 1:


package Numbers;

public class Pattern 
{
public static void main(String[] args) {
        int count=1;
        while (count<=5){
        System.out.println("1 2 3 4 5");
        count++;
        }
        }
                }
output:

1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

program 2:

package Numbers;

public class Pattern2 {

    public static void main(String[] args) {
        int count=1;
        while (count<5){
        System.out.println("1 0 1 0 1 ");
        count++;
        }
                }
                }

output:
1 0 1 0 1 
1 0 1 0 1 
1 0 1 0 1 
1 0 1 0 1

program 3:

package Numbers;

public class Multiply {

    public static void main(String[] args) {
        int num=1;
        while(num<=10) {
      System.out.println("3*"+ num +"="+(3*num));
            num++;
        }
}
}

output:

3*1=3
3*2=6
3*3=9
3*4=12
3*5=15
3*6=18
3*7=21
3*8=24
3*9=27
3*10=30

References:
https://www.javatpoint.com/lcm-of-two-numbers-in-java
https://www.javatpoint.com/java-program-to-find-gcd-of-two-numbers

While loop:

Kaviya.k — Mon, 03 Feb 2025 02:00:29 +0000

While loop:

Syntax of while loop in Java:

while (test_expression) {   

 // statements        

update_expression; 


}


condition is evaluated before each iteration of the loop
If condition is true, the code block inside the while loop will execute
The process repeats until condition is false

Execution of While Loop in Java:

Control enters the while loop.
The condition is tested.
If true, execute the body of the loop.
If false, exit the loop.
After executing the body, update the loop variable.
Repeat from step-2 until the condition is false.

Example 1: Display Numbers from 1 to 5

// Program to display numbers from 1 to 5

class Main {
  public static void main(String[] args) {

    // declare variables
    int i = 1, n = 5;

    // while loop from 1 to 5
    while(i <= n) {
      System.out.println(i);
      i++;
    }
  }
}

output:
1
2
3
4
5

Task1:

Program:
public class Count {

    public static void main(String[] args) {
    int count=1;
        while (count<=5){
        count=count+1;
        System.out.println("count: "+count);
        }
        }
        }

output:
count: 2
count: 3
count: 4
count: 5
count: 6

Task2:

Program:

public class Count1 {

    public static void main(String[] args) {
        int count=5;
        while (count>=1) {
        count=count-1;
        {
        System.out.println("count:" +count);
        }
        }
    }
}

output:
count:4
count:3
count:2
count:1
count:0

Task3:

Program:
public class Count2 {
    public static void main (String args[])
    {
    int count=0;
    while(count<10) {
    count=count+2;
    {
    System.out.println("count:" +count);
    }
    }
    }
}
output:
count:2
count:4
count:6
count:8
count:10

Task4:

program:
public class Count3 {
    public static void main (String args[])
    {
    int count=1;
    while(count<=10) {
    count=count+2;
    {
    System.out.println("count:" +count);
    }
    }
    }

}
output:

count:3
count:5
count:7
count:9
count:11

References:

https://www.geeksforgeeks.org/java-while-loop-with-examples/
https://www.programiz.com/java-programming/do-while-loop

switch and while loop:

Kaviya.k — Sun, 02 Feb 2025 12:00:23 +0000

Java Switch Statements:

        Instead of writing many if..else statements, you can use the switch statement.

       The switch statement selects one of many code blocks to be executed.Unlike if-then and if-then-else statements, the switch statement can have a number of possible execution paths. A switch works with the byte, short, char, and int primitive data types. It also works with enumerated types (discussed in Enum Types), the String class, and a few special classes that wrap certain primitive types: Character, Byte, Short, and Integer (discussed in Numbers and Strings).

Syntax:

switch(expression)
{
case value1 :
// Statements
break; // break is optional

case value2 :
// Statements
break; // break is optional
....
....
....
default :
// default Statement
}

Example: Size Printer Example
1

public class SizePrinter {

public static void main(String[] args) {

    int sizeNumber = 2; // Replace with your desired size (1, 2, 3, 4, or 5)

    switch (sizeNumber) {

        case 1:

            System.out.println("Extra Small");

            break;

        case 2:

            System.out.println("Small");

            break;

        case 3:

            System.out.println("Medium");

            break;

        case 4:

            System.out.println("Large");

            break;

        case 5:

            System.out.println("Extra Large");

            break;

        default:

            System.out.println("Invalid size number");

}

Output

Small

Some Important Rules for Java Switch Statements

Case values must be constants or literals and of the same type as the switch expression.
Duplicate case values are not allowed.
The break statement is used to exit from the switch block. It is optional but recommended to prevent fall-through.
The default case is optional and executes if no case matches the switch expression. It can appear anywhere within the switch block.

Note: Starting from Java 7, switch statements can use String type values. They can also handle wrapper classes like Integer, Short, Byte, Long.

Flowchart of Switch-Case Statement

This flowchart shows the control flow and working of switch statements:

switch statement flowchart in java

Note: Java switch statement is a fall through statement that means it executes all statements if break keyword is not used, so it is highly essential to use break keyword inside each case.

Example: Finding Day

Consider the following Java program, it declares an int named day whose value represents a day(1-7). The code displays the name of the day, based on the value of the day, using the switch statement.
1

// Java program to Demonstrate Switch Case

// with Primitive(int) Data Type

// Class

public class GFG {

// Main driver method

public static void main(String[] args)

    int day = 5;

    String dayString;

    // Switch statement with int data type

    switch (day) {

    // Case

    case 1:

        dayString = "Monday";

        break;

    // Case

    case 2:

        dayString = "Tuesday";

        break;

        // Case

    case 3:

        dayString = "Wednesday";

        break;

        // Case

    case 4:

        dayString = "Thursday";

        break;

    // Case

    case 5:

        dayString = "Friday";

        break;

        // Case

    case 6:

        dayString = "Saturday";

        break;

        // Case

    case 7:

        dayString = "Sunday";

        break;

    // Default case

    default:

        dayString = "Invalid day";

    System.out.println(dayString);

}

Output

Friday

Break in switch case Statements

A break statement is optional. If we omit the break, execution will continue into the next case.

It is sometimes desirable to have multiple cases without “break” statements between them. For instance, let us consider the updated version of the above program, it also displays whether a day is a weekday or a weekend day.
Example: Switch statement program without multiple breaks
1

// Java Program to Demonstrate Switch Case

// with Multiple Cases Without Break Statements

// Class

public class GFG {

// main driver method

public static void main(String[] args)

    int day = 2;

    String dayType;

    String dayString;

    // Switch case

    switch (day) {

    // Case

    case 1:

        dayString = "Monday";

        break;

    // Case

    case 2:

        dayString = "Tuesday";

        break;

        // Case

    case 3:

        dayString = "Wednesday";

        break;

    case 4:

        dayString = "Thursday";

        break;

    case 5:

        dayString = "Friday";

        break;

    case 6:

        dayString = "Saturday";

        break;

    case 7:

        dayString = "Sunday";

        break;

    default:

        dayString = "Invalid day";

    switch (day) {

        // Multiple cases without break statements

    case 1:

    case 2:

    case 3:

    case 4:

    case 5:

        dayType = "Weekday";

        break;

    case 6:

    case 7:

        dayType = "Weekend";

        break;

    default:

        dayType = "Invalid daytype";

    System.out.println(dayString + " is a " + dayType);

}

Output

Tuesday is a Weekday

Java Nested Switch Statements

We can use a switch as part of the statement sequence of an outer switch. This is called a nested switch. Since a switch statement defines its block, no conflicts arise between the case constants in the inner switch and those in the outer switch.
Example: Nested Switch Statement
1

// Java Program to Demonstrate

// Nested Switch Case Statement

// Class

public class GFG {

// Main driver method

public static void main(String[] args)

    // Custom input string

    String Branch = "CSE";

    int year = 2;

    // Switch case

    switch (year) {

    // Case

    case 1:

        System.out.println(

            "elective courses : Advance english, Algebra");

        // Break statement to hault execution here

        // itself if case is matched

        break;

        // Case

    case 2:

        // Switch inside a switch

        // Nested Switch

        switch (Branch) {

        // Nested case

        case "CSE":

        case "CCE":

            System.out.println(

                "elective courses : Machine Learning, Big Data");

            break;

        // Case

        case "ECE":

            System.out.println(

                "elective courses : Antenna Engineering");

            break;

            // default case

            // It will execute if above cases does not

            // execute

        default:

            // Print statement

            System.out.println(

                "Elective courses : Optimization");

}

Output

elective courses : Machine Learning, Big Data

Java Enum in Switch Statement

Enums in Java are a powerful feature used to represent a fixed set of constants. They can be used in switch statements for better type safety and readability.
Example: Use of Enum in Switch
1

// Java Program to Illustrate Use of Enum

// in Switch Statement

// Class

public class GFG {

// Enum

public enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat }

// Main driver method

public static void main(String args[])

    // Enum

    Day[] DayNow = Day.values();

    // Iterating using for each loop

    for (Day Now : DayNow) {

        // Switch case

        switch (Now) {

        // Case 1

        case Sun:

            System.out.println("Sunday");

            // break statement that hault further

            // execution once case is satisfied

            break;

        // Case 2

        case Mon:

            System.out.println("Monday");

            break;

        // Case 3

        case Tue:

            System.out.println("Tuesday");

            break;

        // Case 4

        case Wed:

            System.out.println("Wednesday");

            break;

        // Case 5

        case Thu:

            System.out.println("Thursday");

            break;

        // Case 6

        case Fri:

            System.out.println("Friday");

            break;

        // Case 7

        case Sat:

            System.out.println("Saturday");

}

Output

Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

Default statement in Java Switch Case

The default case in a switch statement specifies the code to run if no other case matches. It can be placed at any position in the switch block but is commonly placed at the end.
Example: Writing default in the middle of switch statements:
1

import java.io.*;

class GFG {

public static void main (String[] args) {

    int i=2;

      switch(i){

      default:

        System.out.println("Default");

      case 1:

        System.out.println(1);

        break;

      case 2:

        System.out.println(2);

      case 3:

        System.out.println(3);

}

Output

2
3

Example: Writing Default at the Beginning of Switch Statements
1

import java.io.*;

class GFG {

public static void main(String[] args)

    int i = 5;

    switch (i) {

    default:

        System.out.println("Default");

    case 1:

        System.out.println(1);

        break;

    case 2:

        System.out.println(2);

    case 3:

        System.out.println(3);

}

Output

Default
1

Case label variations

Case labels and switch arguments can be constant expressions. The switch argument can be a variable expression but the case labels must be constant expressions.

Example: Using Variable in Switch Argument
1

import java.io.*;

class GFG {

public static void main(String[] args)

    int x = 2;

    switch (x + 1) {

    case 1:

        System.out.println(1);

        break;

    case 1 + 1:

        System.out.println(2);

        break;

    case 2 + 1:

        System.out.println(3);

        break;

    default:

        System.out.println("Default");

}

Output

Example: Case Label Cannot Be Variable

A case label cannot be a variable or variable expression. It must be a constant expression.
1

import java.io.*;

class GFG {

public static void main(String[] args)

    int x = 2;

    int y = 1;

    switch (x) {

    case 1:

        System.out.println(1);

        break;

    case 2:

        System.out.println(2);

        break;

    case x + y:

        System.out.println(3);

        break;

    default:

        System.out.println("Default");

}

./GFG.java:16: error: constant expression required
case x+y:
^
1 error

Java Wrapper in Switch Statements

Java allows the use of wrapper classes (Integer, Short, Byte, Long, and Character) in switch statements. This provides flexibility when dealing with primitive data types and their corresponding wrapper types.
Example: Using Wrapper Classes
1

public class WrapperSwitchExample {

public static void main(String[] args) {

    Integer age = 25;

    switch (age) { // Extract primitive value for switch

        case 25:

            System.out.println("You are 25.");

            break;

        case 30:

            System.out.println("You are 30.");

            break;

        default:

            System.out.println("Age not matched.");

}

Output

You are 25.

Note: Regardless of its placement, the default case only gets executed if none of the other case conditions are met. So, putting it at the beginning, middle, or end doesn’t change the core logic (unless you’re using a less common technique called fall-through).

Example: Using Character Wrapper
1

public class WrapperSwitchExample {

public static void main(String[] args) {

    Character ch = 'c';

    switch (ch) { // Extract primitive value for switch

        case 'a':

            System.out.println("You are a.");

            break;

        case 'c':

            System.out.println("You are c.");

            break;

        default:

            System.out.println("Character not matched.");

}

Output

You are c.

Read More:

    Usage of Enum and Switch Keyword in Java
    String in Switch Case in Java
    Java Tutorial

Exercise:

To practice Java switch statements you can visit the page: Java Switch Case statement Practice
Conclusion

Switch statements in Java are control flow structures that allow you to execute specific blocks of code based on the value of a single expression. They can be considered an alternative to if-else-if statements and are useful for handling multiple conditions in a clean and readable manner.
Java Switch Statements- FAQs
How to use switch statements in Java?

To use switch statement in Java, you can use the following syntax:

switch (expression) {
   case value1:
       // code to execute if expression equals value1
       break;
   case value2:
       // code to execute if expression equals value2
       break;
   // … more cases
   default:
       // code to execute if none of the above cases match
}

*Can we pass null to a switch?
*
No, you can not pass NULL to a switch statement as they require constant expression in its case.

*Can you return to a switch statement?

No, switch statements build a control flow in the program, so it can not go back after exiting a switch case.

Flowchart of Switch-Case Statement:

Example program:

int day = 4;
switch (day) {
  case 1:
    System.out.println("Monday");
    break;
  case 2:
    System.out.println("Tuesday");
    break;
  case 3:
    System.out.println("Wednesday");
    break;
  case 4:
    System.out.println("Thursday");
    break;
  case 5:
    System.out.println("Friday");
    break;
  case 6:
    System.out.println("Saturday");
    break;
  case 7:
    System.out.println("Sunday");
    break;
}
// Outputs "Thursday" (day 4)

*Some Important Rules for Java Switch Statements
*
Case values must be constants or literals and of the same type as the switch expression.
Duplicate case values are not allowed.
The break statement is used to exit from the switch block. It is optional but recommended to prevent fall-through.
The default case is optional and executes if no case matches the switch expression. It can appear anywhere within the switch block.

Break in switch case Statements:

A break statement is optional. If we omit the break, execution will continue into the next case.

It is sometimes desirable to have multiple cases without “break” statements between them.

Switch and Ternary operator:

Kaviya.k — Sun, 02 Feb 2025 11:05:44 +0000

Java Switch Statements:

Instead of writing many if..else statements, you can use the switch statement.

Note: The working of the switch-case statement is similar to the Java if...else...if ladder. However, the syntax of the switch statement is cleaner and much easier to read and write.

How does the switch-case statement work?

The expression is evaluated once and compared with the values of each case.

If expression matches with value1, the code of case value1 are executed. Similarly, the code of case value2 is executed if expression matches with value2

If there is no match, the code of the default case is executed.

Flow chart:

Syntax:

switch(expression)
{
case value1 :
// Statements
break; // break is optional

case value2 :
// Statements
break; // break is optional
....
....
....
default :
// default Statement
}

Important Rules for Java Switch Statements:

Case values must be constants or literals and of the same type as the switch expression.
Duplicate case values are not allowed.
The break statement is used to exit from the switch block. It is optional but recommended to prevent fall-through.
The default case is optional and executes if no case matches the switch expression. It can appear anywhere within the switch block.

Example program:

public class Month
{
public static void main(String args[])
{
int day = 4;
switch (day) {
  case 1:
    System.out.println("Monday");
    break;
  case 2:
    System.out.println("Tuesday");
    break;
  case 3:
    System.out.println("Wednesday");
    break;
  case 4:
    System.out.println("Thursday");
    break;
  case 5:
    System.out.println("Friday");
    break;
  case 6:
    System.out.println("Saturday");
    break;
  case 7:
    System.out.println("Sunday");
    break;
}
}
}
output:
   Thursday

Break Keyword:

When Java reaches a break keyword, it breaks out of the switch block.

This will stop the execution of more code and case testing inside the block.

When a match is found, and the job is done, it's time for a break. There is no need for more testing.

Example program:

public class Break {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break; // Terminate switch after matching case
            case 4:
                System.out.println("Thursday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

output:
  wednesday

Default Case in Java switch-case

The switch statement also includes an optional default case. It is executed when the expression doesn't match any of the cases.

For example:

public class Main {
  public static void main(String[] args) {

    int expression = 9;

    switch(expression) {

      case 2:
        System.out.println("Small Size");
        break;

      case 3:
        System.out.println("Large Size");
        break;

      // default case
      default:
        System.out.println("Unknown Size");
    }
  }
}

output:
Unknown Size

Java Enum in switch statement:(TBD)

An Enum is a unique type of data type in java which is generally a collection (set) of constants. More specifically, a Java Enum type is a unique kind of Java class. An Enum can hold constants, methods, etc.

Example program:
enum Car {
   lamborghini,tata,audi,fiat,honda
}
public class Main1{
   public static void main(String args[]){
      Car c;
      c = Car.tata;
      switch(c) {
         case lamborghini:
            System.out.println("You choose lamborghini!");
            break;
         case tata:
            System.out.println("You choose tata!");
            break;
         case audi:
            System.out.println("You choose audi!");
            break;
         case fiat:
            System.out.println("You choose fiat!");
            break;
         case honda:
            System.out.println("You choose honda!");
            break;
         default:
            System.out.println("I don't know your car.");
            break;
      }
   }
}

output:
You choose tata!

Java switch statement with String:(TBD)

Java allows you to use string objects in the expression of switch statement. In order to use string

It must be only string object.

Object game = "Hockey"; // It is not allowed  
    String game = "Hockey"; // It is OK.

String object is case sensitive.

"Hickey" and "hocker" are not equal.

Example program:

// Java Program to implement String on switch statements in Java

class Main {
  public static void main(String[] args) {

    // create a string
    String language = "Java";

    switch(language) {

      case "Java":
        System.out.println(language + " is famous for enterprise applications.");
        break;

      case "JavaScript":
        System.out.println(language + " is famous for frontend and backend.");
        break;

      case "Python":
        System.out.println(language + " is famous for ML and AI.");
        break;

      default:
        System.out.println(language + " not found on record.");
        break;
    }
  }
}

output:
Java is famous for enterprise applications.

Ternary operator:

Java ternary operator is the only conditional operator that takes three operands. It’s a one-liner replacement for the if-then-else statement and is used a lot in Java programming. We can use the ternary operator in place of if-else conditions or even switch conditions using nested ternary operators.

Syntax:
variable = Expression1 ? Expression2: Expression3

If operates similarly to that of the if-else statement as in Exression2 is executed if Expression1 is true else Expression3 is executed.

if(Expression1)
{
variable = Expression2;
}
else
{
variable = Expression3;
}

Flowchart of Ternary Operation:

Example program:

class Ternary {
    public static void main(String[] args)
    {

        // variable declaration
        int n1 = 5, n2 = 10, max;

        System.out.println("First num: " + n1);
        System.out.println("Second num: " + n2);

        // Largest among n1 and n2
        max = (n1 > n2) ? n1 : n2;

        // Print the largest number
        System.out.println("Maximum is = " + max);
    }
}

output:
First num: 5
Second num: 10
Maximum is = 10

References:
https://www.geeksforgeeks.org/switch-statement-in-java/

https://www.w3schools.com/java/java_switch.asp

https://www.javatpoint.com/java-switch

if else and nested if in java:

Kaviya.k — Thu, 30 Jan 2025 18:38:59 +0000

If statement:
if a certain condition is true then a block of statements is executed otherwise not.

Syntax:

If (condition){
//code to be executed
}

program:
public class If {  
public static void main(String[] args) {  
      float a =2.2f; 
      float b =5.4f; 
        if(b>a)
         {  
          System.out.println(" B is greater than a");  
           }  
       }  
}  


Output:
B is greater than a

if-else statement:
In Java, the if-else condition is a set of rules or statements,It executes one block of code if a condition is true and another block if the condition is false.

Syntax:

If(condition){
// code if condition is true
}else{
//code if condition is false
}

**program**:

public class IfElse {

    public static void main(String[] args) {

        int n = 3;

        if (n > 5) {
            System.out.println("The number is greater than 5.");
        } 
         else  
        {
            System.out.println("The number is 5 or less.");
        }
    }
}


Output:
The number is 5 or less.

The else if Statement:

Use the else if statement to specify a new condition if the first condition is false.

Syntax:
if (condition1) {
// block of code to be executed if condition1 is true
} else if (condition2) {
// block of code to be executed if the condition1 is false and condition2 is true
} else {
// block of code to be executed if the condition1 is false and condition2 is false
}

**program:**

public class Greater
{
public static void main (String args[])
{
int no1 = 1000; 
        int no2 = 1000; 
        if(no1>no2)
          {
            System.out.println("no1 is greater");
          }
        else if(no2>no1)
         {
              System.out.println("no2 is greater");
         }      
        else 
           {
         System.out.println("Both are equal");
           }
}
}

output:
     Both are equal

Nested if in Java
Refers to having one if statement inside another if statement. If the outer condition is true the inner conditions are checked and executed accordingly.

*Syntax of Nested if *

if (condition1) {
if (condition2) {
if (condition3) {
// statements;
}
}
}

program:

    public class nested if
    {
    public static void main(String args[])
    {
        int a = 10;
        int b = 20;

        // Outer if condition
        if (a == 10) {

            // Inner if condition
            if (b != 20) {
                System.out.println("GeeksforGeeks");
            }

            else {
                System.out.println("GFG");
            }
        }
    }
}

Task: program:1

java

public class Age
{
public static void main (String args[])
{
 int age1=25;
 int age2=21;
    if(age1<age2)
{
       System.out.println("The condition is false");
}
    else 
{
       System.out.println("The condition is true");
}
}
}

output:
 The condition is true

python

age1 = 25
age2 = 21

if age1 < age2:
    print("The condition is false")
elif age2 < age1:
    print("The condition is true")

output:
The condition is true

java

program:2

public class If {  
public static void main(String[] args) {  
      float a =2.2f; 
      float b =5.4f; 
        if(b>a)
         {  
          System.out.println(" B is greater than a");  
           }  
       }  
}  

output:
B is greater than a

python

a = 2.2
      b = 5.4
if b > a:
    print("B is greater than a")

output:
  num is greater than or equal 120

java

program:3

public class Greater
{
public static void main (String args[])
{
int no1 = 1000; 
        int no2 = 1000; 
        if(no1>no2)
          {
        System.out.println("no1 is greater");
          }
        else if(no2>no1)
         {
           System.out.println("no2 is greater");
         }      
        else 
           {
      System.out.println("Both are equal");
           }
}
}

output:
Both are equal

python

no1 = 1000
no2 = 1000

if no1 > no2:
    print("no1 is greater")
elif no2 > no1:
    print("no2 is greater")
else:
    print("Both are equal")

output:
Both are equal

References:https://www.javatpoint.com/java-if-else
References:https://www.geeksforgeeks.org/java-if-else-statement-with-examples/
References:https://www.w3schools.com/java/java_conditions.asp