DEV Community: Raj Pansuriya

Loops in JAVA

Raj Pansuriya — Thu, 18 Nov 2021 11:58:36 +0000

Let's suppose you want to print numbers from 1 to 5 or let's say you want to print Hello World! 5 times on console. One approach to the problem can be as below,

System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");

Now, what would you do if you have to print Hello World! a thousand times or a million times. Writing a million lines of code can be a solution but surely not an intelligent one. Not just the print statements, think of any set of instructions or tasks which you want to do repetitively. In cases like these, you can use loops. Loops are a utility to perform a task or set of tasks repetitively.

Types of loops

There are three types of loops we'll be looking into

for loops
while loops
do-while loops

For loops

Syntax

for (initialization; condition; increment/decrement) {
    body
}

Let's understand this by our previous example. Let's prin numbers from 1-5.

for(int num=1; num<=5; num++) {
    System.out.println(num);
}

Initialization:

By writing int num=1 we declare and initialize a variable num to value 1. Instead of declaring the variable inside the loop, we can also declare it before the loop and then just use it

int num;
for(num=1; num<=5; num++) {
    System.out.println(num);
}

Condition

In the second part, we write a condition that our loop will check on every iteration. num<=5 is the condition we wrote for our problem statement because we want to print the numbers from 1-5. There can be some different ways of writing conditions. The same condition num<=5 can also be written as num<6. That makes sense right? Let the num be less than or equal to 5 or let it be less than 6 both are just different ways to accomplish the same result in the end.

You can also use a variable to specify conditions. For example, if you want to print numbers from 1-n where n is an integer entered by the user, you can do something like

Scanner input = new Scanner(System.in);

System.out.print("Please enter a number: ");
int n = input.nextInt();

for (int num=1;num<=n ;num++ ) {
    System.out.println(num);
}

output

Increment/decrement

Increment or decrement of the iteration variable (num) as per the need. In our case we want the variable to increase from 1 up to 5.

There are several ways you can increment/decrement the iteration variable.

num = num +1: Increment by 1
num++: Increment by 1
num+=1: Increment by 1
num+=a: Increment by a (a is any integer)
num = num + a: Increment by a

And same for decrement

When we run the loop, the variable num is initialized to 1. Then the program checks for the condition, is 1<=5? The answer is true. The body of the loop is executed and then the num is incremented by specified values (in our case incremented by 1), hence now num=2. Then the program again checks for the condition, is 2<=5? The answer is true again so again the body is executed. This goes on until the 5 is printed and now the value of num=6 because of increment. Now when the program checks for the condition, it'll get a false value so the program now gets out of the loop.

While loops

Syntax

while (condition) {
    body
}

Let's try and implement our previous example, but this time with using while loop

int num = 1;
while (num<=5) {
    System.out.println(num);
    num++;
}

The working of a while loop is more or less the same as that of a for loop. We initialize a variable, we write a condition based on that variable, we write a body and then we increment the variable. The condition is checked at every iteration by the program.

Now that we have understood both the loops, the question arises when to use the while loop and when to use the for loop.

You can use both of the loops interchangeably as you prefer. The reason that they both exist is

Use the for loop when you know how many times the loop is gonna run

Use the while loop if you do not know how many times the loop is gonna run.

For example, if you are given a problem to run the loop until the user inputs the letter x. It's not possible to achieve this using for-loop but you can do this using while loop as follows

Scanner input = new Scanner(System.in);
char ch = input.next().trim().charAt(0);
while (ch!='x') {
    System.out.println("Hello");
    ch = input.next().trim().charAt(0);
}

So now the loop will continue until the user inputs letter x.

output

Do While loops

Syntax

do {
    body
} while (condition);

Loosely translated, a do-while loop can be read as

do something (body), while the condition is true.

Implementing our previous example using the do-while loop

int num=1;
do {
    System.out.println(num);
} while (num<=5);

Again, one might ask himself, when do we use a while loop and when to use a do-while loop? What's the difference between the two of them?

If you observe, you might notice the difference between the two loops.

In the case of while loops, the condition is checked first, and then the body is executed.

In case of do-while loops body is executed and then the condition is checked.

From these, we can deduce that there might be the case where while loop will not run at all, but in all possibilities a do while loop will run at least once.

Look at the following example

int num = 6;
while (num<=5) {
    System.out.println(num);
    num++;
}

Here the iteration variable is already violating the condition, so the while loop will not run at all.

Now see what happens if we run a do-while loop in the same conditions

int num=6;
do {
    System.out.println(num);
} while (num<=5);

As we can see, though the condition is already violated, the loop still runs one time, it executes the body, and then after checking the condition it gets terminated.

So in cases where you want your loop to run at least once, you can choose do-while over while loop.

That's all about loops. Kunal has discussed some really important examples regarding Fibonacci numbers, Digit counts, Number reversal which is wholly based on the concepts that we have learned in this article. Do check out his video.

Also, consider checking my repo for the code of those examples.

Raj-Pansuriya / java-dsa

Feel free to connect via socials

Twitter
LinkedIn
GitHub

Switch Statements in JAVA

Raj Pansuriya — Wed, 17 Nov 2021 16:25:16 +0000

We have already seen how to make decisions based on some conditions in the previous article. In this article, we will look at the switch statement which can be used to replace the if...else statements in some cases to reduce the complexity and improve the readability of the code.

Normally, if we have to choose one case among many choices, nested if-else or else if is used. But if the number of choices is large, switch..case is a better option as it makes code neat and easier to understand. In switch statements, we can jump to various cases based on our expression. Let’s see how.

Consider a case in which we want to print a message based on the name of fruit we get from the user

if (grade == 'A') {
    System.out.println("Excellent !");
} else if (grade == 'B') {
    System.out.println("Outstanding !");
} else if (grade == 'C') {
    System.out.println("Good !");
} else if (grade == 'D') {
    System.out.println("Can do better");
} else if (grade == 'E') {
    System.out.println("Just passed");
} else if (grade == 'F') {
    System.out.println("You failed");
} else {
            System.out.println("Invalid grade");

We can make this program more readable by using a switch..case instead of else if.

Switch Syntax

switch(expression) {
    case value1:
        statement(s)
        break;

    case value2:
        statement(s)
        break;

    /* you can give any number of cases */

    default:
        statement(s)
}

In switch(expression), the value of the expression is compared with the values of all the cases. If the value of the expression matches the value of a case, then the statement(s) corresponding to that case is executed.

So we can write the above example using switch case as

class Test {

    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
                System.out.println("Excellent !");
                break;
            case 'B':
                System.out.println("Outstanding !");
                break;
            case 'C':
                System.out.println("Good !");
                break;
            case 'D':
                System.out.println("Can do better");
                break;
            case 'E':
                System.out.println("Just passed");
                break;
            case 'F':
                System.out.println("You failed");
                break;
            default:
                System.out.println("Invalid grade");
        }
    }
}

Understanding break statement

Take a look at the following example

Let's say we want to print a message based on the fruit value entered by the user.

import java.util.Scanner;

public class Switch{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Enter a fruit: ");
        String fruit = input.next();

        switch(fruit){
            case "mango":
                System.out.println("King of fruits");
            case "apple":
                System.out.println("A sweet red fruit");
            case "orange":
                System.out.println("Round fruit");
            case "grapes":
                System.out.println("small fruit");

        }
    }
}

output

This is unexpected. When we entered orange the code should have only printed Round fruit but it printed all the next along with it.

By this, we understand the behavior of switch-statement. If we do not give a break statement to our switch cases, the switch not only executes the matched case but all the following cases until it encounters the next break statement. That's the reason when we enter mango, all the statements are printed by our program

That's the reason we have a break statement after every case so that the program will know that once a case is matched it should break out of the switch statement. So the correct code is

import java.util.Scanner;

public class Switch{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("Enter a fruit");
        String fruit = input.next();

        switch(fruit){
            case "mango":
                System.out.println("King of fruits");
                break;
            case "apple":
                System.out.println("A sweet red fruit");
                break;
            case "orange":
                System.out.println("Round fruit");
                break;
            case "grapes":
                System.out.println("small fruit");
                break;
        }
    }
}

output

Understanding default statement

Let's see what happens if we enter some irrelevant input in the above code

We get no output when we enter any fruit which is not in the given cases or anything gibberish. But the code should give some output because no-output would not make much sense to our user. Its cases like this when default case is used. The default will execute when none of the above cases execute.

import java.util.Scanner;

public class Switch{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Enter a fruit: ");
        String fruit = input.next();

        switch(fruit){
            case "mango":
                System.out.println("King of fruits");
                break;
            case "apple":
                System.out.println("A sweet red fruit");
                break;
            case "orange":
                System.out.println("Round fruit");
                break;
            case "grapes":
                System.out.println("small fruit");
                break;
            default:
                System.out.println("Please enter a valid fruit name");
        }
    }
}

output

As we can see, the program now prints a statement for invalid inputs.

You may have a default statement anywhere in the switch case and not at the end, but then you'll have to write a break statement following the default case so none of the following cases is executed when the default condition is met.

Notes for Switch

Cases have to be of the same type as expression, must be constant or literal.

The cases can not be an expression like marks < 50 It has to be either a constant or a literal
Duplicate cases are not allowed
Break is used to terminate
If break is not used, it will continue to execute all the next cases
Default will execute when none of the above cases execute
If the default is not at the end, put a break after it

Enhanced switch

Enhancements to switch statements were introduced by Java 12 and then further modified by Java 13.

Let’s dive into the important features of this improved version of the Switch statement.

Switch with arrows

The statements on the right side of an ⇾ are executed if an exact case matches on the left side.

for example, let say we take int input for a day of the week form the user and want to print the name of the day

switch (day) {
    case 1 -> {
        // you can add braces like this if you want to have multiline code
        System.out.println("Monday");
    }
    case 2 -> System.out.println("Tuesday");
    case 3 -> System.out.println("Wednesday");
    case 4 -> System.out.println("Thursday");
    case 5 -> System.out.println("Friday");
    case 6 -> System.out.println("Saturday");
    case 7 -> System.out.println("Sunday");
}

Supports multiple values per case

With multiple values being specified per case, it simplifies the code structure.

In our previous example, if we do not want the name of the day; instead we only want whether the day is a weekday or weekend

switch (day) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("Weekday");
        break;
    case 6:
    case 7:
        System.out.println("Weekend");
        break;
}

This code can even be enhanced as follows. The case values need to be separated by commas and the break should follow the case block.

switch (day) {
    case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
    case 6, 7 -> System.out.println("Weekend");

There are so many other new features about which you can read in this article

Nested switch case

In our last article, we saw nested if statements. Similarly, nested switch cases are basically switch-case inside a switch-case

You can have a look at an example of nested switch and other code samples we discussed in this article in my git repo.

Raj-Pansuriya / java-dsa

Feel free to connect via socials

Twitter
LinkedIn
GitHub

Conditionals in JAVA

Raj Pansuriya — Wed, 17 Nov 2021 16:16:49 +0000

What makes programming so much more powerful are conditional statements. This is the ability to test a variable against a value and act in one way if the condition is met by the variable or another way if not. They are also commonly called by programmers if statements.

conditional statements, conditional expressions, and conditional constructs are features of a programming language, which perform different computations or actions depending on whether a programmer-specified boolean condition evaluates to true or false.

Logical operators used to write conditions

Java supports the usual logical conditions from mathematics:

Less than: a < b
Less than or equal to: a <= b
Greater than: a > b
Greater than or equal to: a >= b
Equal to a == b
Not Equal to: a != b

These statements provide us either true or false value
Java has the following conditional statements:

Different types of conditionals

Use if to specify a block of code to be executed, if a specified condition is true
```
if (boolean expression true/false) {
// block of code to be executed if the condition is true
}
code...
...
...
```
If the condition is true then the code inside the code block is executed otherwise it is skipped and the program continues from the instruction after the if-block.

For example, let say we want to decide on a bonus for various employees based on their salaries and then add the bonus to their salaries to get the final amount to be paid to that employee.

if (salary > 20000) {
    salary = salary + 2000
}
System.out.println(salary)

1) salary = 5000
output: 5000

2) salary = 20000
output: 20000

3) salary = 21000
output: 21000 + 2000 = 23000

Use else to specify a block of code to be executed, if the same condition is false
```
if (boolean expression true/false) {
// block of code to be executed if the condition is true
}
else {
// block of code to be executed if the condition is false
}
code ...
.....
```
If the condition is true then the code inside the if-block is executed otherwise the code inside else-block is executed.

In our previous example, we might want to add a bonus of Rs.1000 for employees having salaries less than Rs.20000

if (salary > 20000) {
    salary = salary + 2000
}
else {
    salary = salary + 1000
}
System.out.println(salary)

1) salary=5000
output: 5000 + 1000 = 6000

2) salary=20000
output: 20000 + 1000 =  21000

3) salary=21000
output: 21000+2000=23000

Remember, only one of the two, either if or else blocks get executed. The two blocks are never executed simultaneously.

Use else if to specify a new condition to test if the first condition is false
```
if (condition_1) {
// block of code to be executed if the condition_1 is true
}
else if (condition_2) {
// block of code to be executed if condition_1 is false and condition_2 is true
}
else if (condition_3) {
// block of code to be executed if condition_2 is false and  condition_3 is true
}
else {
// block of code to be executed if all the above conditions are false
}
code...
...
...
```
You might have guessed the working of if-else-if statements. The program starts from the very first if statement, if the condition is true, the corresponding block is executed otherwise the program counter jumps onto the next if statement. At last, if none of the conditions is true then the last else-block is executed.

In our previous example, we might want to add a bonus of Rs.5000 having a salary more than or equal to Rs.40000

if (salary >= 40000) {
    salary += 5000        // same as salary = salary + 5000
}
else if (salary > 20000) {
    salary += 2000        // same as salary = salary + 2000
}
else {
    salary += 1000        // same as salary = salary + 1000
}
System.out.println(salary)

1) salary = 45000
output: 45000 + 5000 = 50000

2) salary = 40000
output: 40000 + 5000 = 45000

3) salary = 21000
output: 21000 + 2000 = 23000

4) salary = 20000
output: 20000 + 1000 = 21000

5) salary = 10000
output: 10000 + 1000 = 11000

Just like the if-else code, in the if-else-if code only one of the code blocks is executed at a time. i.e., in the given example only one of the four (the three if-block and one else-block) code blocks will be executed.

Nested if-else statements

Sometimes we may want to nest if statements so that we can check for more than one condition.

The syntax for a nested if...else is as follows −

if(Boolean_expression 1) {
   // Executes when the Boolean expression 1 is true
   if(Boolean_expression 2) {
      // Executes when the Boolean expression 2 is true
   }
}

In our previous example, we might want to add a bonus of Rs.3000 to the employees who have worked more than 5 years at our company. We can do that as follows

if (salary >= 40000) {
    salary += 5000        // same as salary = salary + 5000
    if (working_tenure > 5) {
        salary += 3000
    }
}
else if (salary > 20000) {
    salary += 2000        // same as salary = salary + 2000
    if (working_tenure > 5) {
        salary += 3000
    }
}
else {
    salary += 1000        // same as salary = salary + 1000
    if (working_tenure > 5) {
        salary += 3000
    }
}
System.out.println(salary)

Here we have added a nested if condition to all the previous if conditions that check the condition and add up the bonus of Rs.3000 if met true.

You can nest else if...else in a similar way as we have nested if statement.

Caution

Let's see some common mistakes which people tend to do while writing conditional statements.

Wrong order while specifying conditions in if-else-if

if (salary >= 20000) {
    salary += 2000        // same as salary = salary + 2000
}
else if (salary > 40000) {
    salary += 5000        // same as salary = salary + 5000
}
else {
    salary += 1000        // same as salary = salary + 1000
}
System.out.println(salary)

Look at the code above. The code seems perfectly fine at first. Now try running the code with a salary input of Rs. 50000. The output you will get will be 50000 + 2000 = 52000. But this does not make any sense. 50000 is greater than 40000 so the final amount should have been 55000. What is it that gave us the wrong output?

Remember when we discussed how if-else-if works, we said that

The next condition is checked ONLY AND ONLY if the previous condition is wrong.

Rs.50000 is greater than 40000 but it is also greater than 20000. That means our first condition is true so the program won't even bother to check further conditions and will skip them. Hence we get the wrong output. The correct (Logically correct to be precise) code for our problem statement would be

if (salary >= 40000) {
    salary += 5000        // same as salary = salary + 5000
}
else if (salary > 20000) {
    salary += 2000        // same as salary = salary + 2000
}
else {
    salary += 1000        // same as salary = salary + 1000
}
System.out.println(salary)

Understand that while writing if-else-if statements all our conditions have to be in DESCENDING/ASCENDING order so none of the conditions is skipped.

Ignoring the boundary cases while writing conditions While writing conditions we should always consider boundary cases. Boundary cases are extreme values where our condition met true or false.

For example, in the code cell below,

if (salary > 20000) {
    salary += 5000        // same as salary = salary + 5000
}
else if (salary < 20000) {
    salary += 2000        // same as salary = salary + 2000
}

boundary case is people having salary = 20000. While writing this code, we totally forgot to consider people with salary = 20000. So in the end, people having salary > 20000 will get a bonus of Rs.5000; people having salary < 20000 will get a bonus of Rs.2000 and people having salary = 20000 will get no bonus which is a really stupid thing to do as a manager. So the logically correct code would be

if (salary >= 20000) {
    salary += 5000        // same as salary = salary + 5000
}
else if (salary < 20000) {
    salary += 2000        // same as salary = salary + 2000
}

Always try to avoid logical mistakes while writing conditionals.

That's all for this one. Hope you all have got the gist of conditionals and how to use them. Go through my repo and play with conditional programs.

Raj-Pansuriya / java-dsa

Feel free to connect via socials

Twitter
LinkedIn
GitHub

Datatypes in JAVA

Raj Pansuriya — Mon, 15 Nov 2021 16:33:10 +0000

Primitive Datatypes

Primitive data types in Java are predefined by the Java language and named as the reserved keywords. A primitive data type does not share a state with other primitive values. Primitives are also the data types that one cannot break any further. For example, Raj is a data of String type. We can further break it into individual letters R, a, and j that are further unbreakable into any standalone datatype. All of the individual letters are said to be of char datatype. So the String is a non-primitive datatype and char is a primitive datatype.

Let's look at all the primitive data types supported by Java.

Note:- All the statements in Java language are ended by a colon ( ; ) symbol stating that the current statement ends and a new statement begins from that point onwards.

char: Used to store a single character or letter

char letter = 'r';

int: Used to store integers.

int roll_no = 10;

long: Used to store large integer values

long large_integer = 198732099873L;

float: Used to store decimal numbers

float marks = 77.5f;

double: Used to store large decimal numbers

double large_decimal = 8172612.769832;

boolean: The data types that have either true or false values. Very useful while writing conditional statements.

bool check = true;
bool var = false;

Also notice that the syntax to declare variables is as given in the above example.

datatype identifier = literal;

literal: These are the syntactical representation of our data. In very simple language these are the actual values of our variables

identifier: Name of variable, classes, methods, function are all known as an identifier. So when we declare a variable, a variable name is an identifier

Now one might wonder if we have int, what's the need of long datatype. The same goes with float and double; this has to do with the size of a datatype. An integer takes 4 bytes of memory so anything bigger than that has to be stored in a long type data and the same is for float.

IMP

All the decimal values by default are of type double. So if we want to store them in float type variable, we have to specify that by using an f at the end of our number.
All the integer values by default are of type int. The only reason to use long instead of int is to store larger values. We specify that by using L at the end of the number.

Do not worry much about these things now. We will study everything about size when we'll be discussing bitwise operators.

Inputs for various data types

As there are different data types, there are different methods given by the Scanner class to take their inputs.

int : nextInt()
float : nextFloat()
String : next() is used to take one-word inputs and nextLine() is used to take input more than a word. for exmaple if the input given is Hey Raj!!, only Hey will be taken if next() is used and complete input will be taken if nextLine() is used. Baiscally next() method ignores anything after first white space.

Below is a basic program demonstrating inputs we discussed so far.

import java.util.Scanner;

public class Input {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Enter your full name: ");
        String full_name = input.nextLine();
        System.out.print("Enter your first name: ");
        String name = input.next();
        System.out.print("Enter your division: ");
        String division = input.next();
        System.out.print("Enter your roll no: ");
        int rollno = input.nextInt();
        System.out.print("Enter your maths marks: ");
        float marks = input.nextFloat();

        System.out.print("Name : "+full_name);
        System.out.print("Division : "+division);
        System.out.print("Roll no. : "+rollno);
        System.out.print("Marks : "+marks);
    }
}

Type Conversion & Casting

If you try to enter an integer or float in a string-type variable you will get an error and the program will fail. The same is true when you enter a float to an int-type variable. On the other hand, if you provide an integer to float-type data, the integer automatically gets converted to float.

As you can see, in the above picture though the input given is 89 it gets converted to 89.0. Why does this happen? And why the reverse is not possible? Why do we get an error when given a float to an int type variable?

All of this can be understood by learning about type conversion and casting.

Conditions for Type Conversion

Two types should be compatible
- char & String
- int & float
Destination type should be greater than source type
- float is greater than int cause in addition to integers it also contains decimal numbers.
Due to this condition, float does not get converted to int

In some situations, we might want to convert all our data into a particular datatype which we can do explicitly. This is known as Type-casting.

For example, if we want all our data in int type by default and we want our program to tackle the condition where a user might input a float number. then we can convert the input number into integer explicitly using the following instruction

int num = (int)(input.nextFloat)

Now even if the user inputs a float number it will be accepted without any error because we have used the nextFloat() method instead of nextInt(). It will then be converted to integer type as our code demands.

Example,

int num = (int)(1323.79f)
System.out.println(num)

output:
1323

This was all about Typecasting and data types. Have a look at the git repo below to start with some basic programs and try to understand and run them.

Raj-Pansuriya / java-dsa

Change the program and play with them. You can always connect with me in case you have any doubts

Twitter LinkedIn GitHub

I/O in JAVA

Raj Pansuriya — Sat, 13 Nov 2021 18:26:12 +0000

In our last article, we discussed everything but the output statement in our sample code. Let us explore inputs, outputs, classes responsible for I/O and packages in Java.

What is a package in Java

In simple terms, a package is nothing but a folder in which our Java file will lie. Sometimes we may want to have a set of rules for our code files like

A function should be accessed by files in that folder only
A class and its methods should be accessed by particular folder files only
A file should be accessed by files in the app folder. It's scenarios like this when we can make use of packages and access modifiers. If you do not know what an access modifier is, no worries because we will be discussing that in detail later on. We have even used an access modifier named public which I explained in the last article.

You might stumble upon packages now and then in your java code. Especially if you use an IDE because IDE's are set to create a package for our program by default. Even if you do not use any IDE, you might use packages efficiently to have some security for your code.

Outputs in Java

We know that everything in Java works in classes. Java language provides us with some basic functionalities such as input, output, debugging, etc. which we can use while writing our program.

One such functionality is when we have to print something on our console. We use print or println function to print something on our console.

Now Java has a class called System in java.lang package (language package). You can open the file and inspect the System class if your Development environment (IDE or Text editor) supports it. You can try clicking on System while holding the ctrl key to open System class.

The System class has a variable of type PrintStream named out that is used to print some output when given a stream of characters. The out variable has various functions for giving various types of output. One of them is the println function which prints character output when given character input. In a nutshell, by writing System.out.println() we are accessing the println function to have the required output. Memorize it for now if any of the above does not make sense to you. It will make more sense when you know a bit more about classes.

print vs println

Both the function give us a standard output on the console with a minor difference that println adds a new line to the output. Take a look at the example below

public class Hello {
    public static void main(String[] args) {
        System.out.print("Hello World!!");
        System.out.print("My name is Raj!");
    }
}

output:
Hello World!!My name is Raj!

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World!!");
        System.out.println("My name is Raj!");
    }
}

output:
Hello World!!
My name is Raj!

As you can see, a new line gets added at the end when we use println.

Inputs in Java

As we have a System class for handling outputs, in the same way we have a class to handle inputs in Java known as the Scanner class. It's available in the java.util package. To use that class first we have to import java.util package in our program.

import java.util.Scanner;

Now how do we use a class, we create an object of it. new is the keyword used to make objects of a class. Now Scanner class has to be given an argument stating the source from where input is coming. The input may be from a file, it may be from a database, etc. In our case input is from the keyboard, so we will pass System.in
The syntax for this is:

import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
    }
}

Now using object input we can take inputs from our user.

import java.util.Scanner;

public class Input {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("please provide some input");

        System.out.println(input.next());
    }
}

The given program will take input from the user and then output it as it is. We have used the input.next() method which is used to take string inputs (Character type input). There are several other methods to have inputs of various data types.

We'll see those methods in our next article while we explore various datatypes supported by java. Till then feel free to connect with me on

Twitter LinkedIn GitHub

Structure of JAVA Code

Raj Pansuriya — Fri, 12 Nov 2021 08:16:57 +0000

Till our last article, we have JDK installed in our system. Now we are all set to write our first Java code. You can make a separate directory (recommended) to contain all your java codes and projects

$ mkdir dsa_with_java

now to create a new java file

$ cd dsa_with_java
$ touch Hello.java

Have a look at the java code below. This is how a very basic java code looks like. It might feel overwhelming at first to know that we have to write so much just to have Hello World!! as output, but once we discuss all the building blocks of the code everything will start making sense

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World!!");
    }
}

We will discuss everything that we have written in the code snippet shortly, but first, let's try and apply what we have already learned. Let's try and generate a byte code from the given code and try to have some output on our console.
As you can see, we only have a .java file currently in our folder.

Let's use the javac compiler to generate a .class byte code file.

$ javac Hello.java

This is the file responsible for the platform independence of the Java language. That means, we can share this file with anyone irrespective of the Operating system he/she is using and they would be able to run the program just fine. Let's try and run the program now.

$ java Hello

Voila!!! We have successfully written and run our first java program.
Now let's understand all the things that we wrote in our code and their significance. You might not understand some of these keywords which is fine because it will start making sense once we learn object-oriented programming. So if you get everything now, it's well and good, but even if you do not get some things it's OK!!

Some important things about a Java code

Everything we write in java is going to be in classes
Every file with a .java extension is a class itself
The Hello class in Hello.java has to be public. You can not have a class named anything other than the file name. for example a file name Main.java has to have a public class named Main
public: public means the class can be accessed from anywhere
class: class keyword tells java to make a class. for example class Hello means make a class named Hello
main function: Inside this public class we create a function named main. By convention, a java file must have a main function. It's the entry point for any java code. If there is no main function we won't be able to run that code. A function is nothing but a bunch of instructions.
public for function: by writing public in line 2, we are making our main function public to all other modules. Think about it, We just said that the main function is the entry point of our program. So does it not make sense to make it public so even other classes can also access it. That is the reason we always have our main function declared public.
static: Understand one thing, that if you have to use data or function of a class, you have to create an object of that class, and then only you can use those functions and data. Now main is the entry point of java. That means nothing exists in terms of code before executing the main function. But to use the main function we'll have to create an object of the Hello class. So we are stuck in a contradictory loop. To use a function we must have an object, but to create an object we should run the main function. So the thing is, we want to execute this main function without creating an object of Hello class. static is the keyword which provides us that power. main is the function that does not depend on objects and classes. Hence, it has to be a static function
void: void is the return type of function. In java, every function has its return type. for example, if we write a function to add two integers, its return type would be int because, in the end, the function will return us an integer (sum of two integers). In the same way, our main function here is just printing a simple message Hello World! and is not returning anything. Hence the return type void
String[] args: These are known as command-line arguments. We can provide command-line arguments to our program and make our code execute in a particular way.
We'll explore more about System.out.println in our coming articles. For now, consider it as a way to output some characters on the console.

Tips while writing a java code.

By convention, we write a class name in CapitalCase. It does not make any difference in the logic of the code even if you write it in a small case but it's a good practice to follow conventions of the language we are coding in.
If you do not want your java code and byte code in the same folder you can do that by passing the -d flag to the java compiler. This is a good practice actually to keep all your source code (.java files) in the src folder and all the byte code in the out folder. It makes things well structured and organized.

$ javac -d location/to/save/byte/code file.java

That's all for this article. In the next article, we'll explore supported data types by Java. Till then feel free to connect with me on my socials.

twitter
linkedin
github

Getting Started with Java - Installation

Raj Pansuriya — Thu, 11 Nov 2021 13:15:52 +0000

You can install the latest version of java for Windows and macOS from its official site. For Linux-based distributions command line is the recommended option. Follow the instructions:

Install java for MacOS
Install java for Windows
Install java for linux Note: Though you can download and install JDK for Linux from the official site, I would highly recommend you to use the official package manager for your distribution.

Java on Linux distributions

Ubuntu, Debian, and distributions that use apt as the package manager
Open your terminal and follow the guide

Update the package index
```
$ sudo apt-get update
```
Check if Java is not already installed:
```
$ java --version
```
If Java is already installed we'll get output similar to below
```
openjdk 17.0.1 2021-10-19
OpenJDK Runtime Environment (build 17.0.1+12)
OpenJDK 64-Bit Server VM (build 17.0.1+12, mixed mode)
```
If not, then install java
```
$ sudo apt-get install default-jdk
```
For arch and arch-based distributions

Update the system
```
$ sudo pacman -Syyu
```
Check if Java is not already installed:
```
$ java --version
```
Search for available JRE in the arch repository
```
$ pacman -Ss java | grep jre
```
Install the latest jre
```
$ sudo pacman -S jre-openjdk
```
Similarly, search for the latest JDK and install it
```
$ pacman -Ss java | grep jdk
```
```
$ sudo pacman -S jdk-openjdk
```

The next thing you may want to install is an Integrated Development Environment (IDE). There are so many IDE's available for Java development. One of the best being IntelliJ IDEA. You may even consider setting a Java Development Environment in your preferred text editor such as VSCode or Atom, etc. I leave these things to your liking.

That's all for this one. Feel free to connect with me

Introduction to Java - Compiler Architecture

Raj Pansuriya — Wed, 10 Nov 2021 15:06:08 +0000

In previous articles, we discussed that we write all our code in a human-readable format. We also got to know that computers can only understand machine language i.e., the language of 0's & 1's. We know that there is an intermediate agent known as a compiler that translates human-readable code to machine-readable code.

In this article, we'll be exploring more about compiler (Java compiler in depth). We'll look into the basic building blocks of java, how a java code executes, the basics of java language, how everything works internally from writing a java code to its execution, what are the different components of the java compiler, and so on.

While exploring our computer storage, one might observe that different types of files possess different extensions. a PowerPoint file have .pptx extension, a doc file have .docx extension, a pdf file have .pdf file extension, a picture may have .jpg/.png extension etc. In the same way, a java file will have a .java extension.

So the .java file will contain all our code in human-readable form. The code might be any set of instructions as per rules (syntax) of the Java language.

How JAVA is Platform Independent

In some programming languages such as C, C++ the compiler converts the .c or .cpp file directly into machine code giving us a .exe file that is platform dependent. If we try to execute such a .exe file on a different Operating System (OS) than what it was created on, we won't be able to do so. Once the type of OS is changed, the code needs to be re-compiled. This means a c/c++ code compiled on windows will not execute on a Linux OS or a MAC OS and vice-versa.

Unlike those programming languages, when a java compiler compiles a .java file, it converts it into something known as byte code. Some important points about byte code are:

This code file will have .class extension
This code will still not be understood by a computer, which means it won't directly run on a system
We'll need something called Java Virtual Machine (JVM) to execute this code

Now one might have so many different questions such as what is byte code? Why do we have a byte code? What is JVM? What does JVM do? How does all of this relate to the platform independence of JAVA? etc. Let's answer all of them one by one.

Consider byte code as some intermediate language of java. Java Virtual Machine acts as an interpreter for byte code. That means when the byte code is run by JVM, it gets converted to machine code and hence is finally ready to be executed.

The byte code once compiled, can be used to generate machine code on all types of operating systems. Say a byte code is generated on macOS, we can still use that byte code to generate machine code on Linux/Windows OS. This is how Java gets its platform-independent behavior because, unlike other programming languages, we do not have to recompile the program every time we change our OS.

Architecture of JAVA

Java Development Kit (JDK)

Provides an environment to develop and run Java programs
It is a package that consists of :
1. Development tools: Provide an environment to develop a java program
2. Java Runtime Environment (JRE): to execute java programs
3. A compiler javac: Converts java code into byte code. ( .java -> .class )
4. Archiver jar: If we want to archive our files
5. Docs generator javadoc: to generate docs of our application
6. interpreter & loader
In short, if we want to write and develop java codes, we need to have JDK

Java Runtime Environment (JRE)

It is a package that provides an environment to only run the java programs
It consists of :
1. Deployment Technologies
2. User Interface toolkits
3. Integration Libraries
4. Base libraries
5. JVM
After we get the byte code ( .class file ), at run time:
1. loader loads all the necessary classes needed to execute the program.
2. JVM sends code to byte code verifier to check the format of the code.

Compile Time

During compile-time, the source code written by us ( .java file) is coverted t byte code ( .class file) by java compiler (javac).

Run Time

Most of the runtime period is dominated by JVM and its components.

Class loader (Working of JVM)

Loading :
- Reads .class file and generate binary data in form of object
- The object of .class is generated in heap memory. The object contains source code, necessary data, any other necessary java libraries which we may have referenced in our code, etc.
- In simple terms, we can say that the program is loaded in the RAM of the computer in the loading process
Linking :
- JVM verifies the .class file to avoid any errors/any things prohibited by Java
- Allocates memory for class variables & default values because all the variables, constants, functions, methods, etc. needs to be allocated the proper amount of memory in RAM
- Replace all the symbolic references with direct references. for example, if our code has a statements

a = 10
b = 20
c = a + b

then a has to be replaced with 10, b with 20, and c with 10+20.

Initialization :
- All static variable are assigned their values defined in the code and static block. We'll be seeing static variables in detail in our further articles when we'll discuss OOP. For now, understand static variables as variables that are independent of the object of the class.

Now that we have source code, data, and other libraries properly loaded, verified, and linked; it's time to generate machine code from that.

JVM Execution

Interpreter :
- Line by line execution of .class file
Note: Because the interpreter interprets the byte code line-by-line, it will read and interpret any function or variable over and over again if every time it's called. That means a function is converted to machine code every time it's used in source code, which is not really efficient. To solve this problem we have, Just in Time compiler ( JIT ).
Just In Time Compiler ( JIT ) :
- JIT provides direct machine code for methods that are repeated in source code to avoid re-interpretation
- Makes execution faster

JRE vs JVM

Think of JRE as a box and JVM as the content inside the box, the main working machine being JVM. JVM does all the necessary processing on source code but the things which JVM might require such as dependent libraries, base libraries in order to do that procession are held and provided by JRE. Whenever JVM needs any help, its main point of contact is JRE.

We can say that JRE = JVM + some other files & tools

Collectively

We write java code in human-readable form
Compiler javac inside JDK compiles it to form a .class file of byte code
JVM runs and the byte code and give us an executable code which is then run via JRE

Reference

In next article, we'll start with our Hello World Java code. Till then feel free to connect with me on my socials!!!

Flow of Program

Raj Pansuriya — Tue, 09 Nov 2021 08:15:19 +0000

In this article we'll learn about control flows, flowcharts and pseudocode of a program.

Flowcharts

Flowcharts is just a visual represemtation of the logic we think or an algorithm we create to solve a particular problem.
As every language we speak has some sort of grammer and rules to follow, think of flowcharts as a pictorial language where certain symbols carry specific meanings.

start/end: indicates Start or End of the program
arrows: Used to relate various representative shapes. Used to show flow direction of the program
input/output: Input that we take from user and output that we provide to our user
process: Anything and everything (operations) that we do on imput data to produce output data
decision: We use this shape to decide between one or more options to proceed further. For example, we might want to change flow of our code based upon the fact whether a student got more or less than 60 marks in exam

Let us understand these things using some simple examples...
1.Take a name from user and print 'Hello name'

2.Take salary input form user. Add a bonus of Rs.2000 if the salary is greater than Rs.10000 else add a bonus of Rs.1000

In the above flowchart, we used diamond shape to write an if statement (if salary>1000)

3.Input a number and print whether its prime or not

We know that prime numbers numbers are the numbers which are only divisible by 1 & the number itself. So the 1st thought to approach this problem could be,

Check for all the numbers between 1 & the target number, if any number divides the target number. If any of them can completely divide the target number then the target number is not prime otherwise its a prime number.

In the above flowchart, there is a % operator which some of you might not be familiar with. % operator basically shows reminder when number at LHS (left hand side) is divided by number at RHS (right hand side)

4 % 2 =0   # because 4 is completely dividible by 2
5 % 2 =1   # because 2x2 is 4 and 1 is the reminder of division

Another thing which one can observe is that we have created a loop to check all the numbers between 1 & the target number. Its also evident from the flowchart cause we have a cyclic figure between the conditions, signifying a loop. We will learn about loops in depth in out further articles, for now I just want you to get a basic gist of it!

Pseudocode

Sometimes we want to share our logic or algorithm with someone and we really do not care about the rules of programming language that the person want to use. We just need to share our logic irrespective of the syntactical specifications. At such times we can use pseudocode. Pseudocode in simple terms can be stated as a rough code for our logic.

Lets try and understand this with our previous example.

START
input num
count = 2
while count <= num:
    if (num % count)=0:
        output "NOT Prime"
    count = count + 1
end while
output "Prime"
END

As we can see we use if conditions and loops as conditionsals. We also used them in the flowchart. One can say that flowchart and pseudocodes are just different ways of representing a logic or an algorithm without caring about syntax (A rough idea of the code.)

Now lets try and optimize above logic. Lets take example of number 28

# Factors of 28
1x28 = 28
2x14 = 28
4x7 = 28
7x4 = 28
14x2 = 28
28x1 = 28

This is what we were doing in the prime number example, we were looking for all the factors of a number and if any number has more than 2 (1 & the target number) factors then the number is not prime.

In the above cell we can see that there is repetetion when we check for those factors. Once we have checked 2x14=28 there is no need to check 14x2=28 agian. We are repeating ourselves. This unnecessarily increases time & memory required to process our code. So check only for

# Factors of 28
1x28 = 28
2x14 = 28
4x7 = 28

~~7x4 = 28~~
~~14x2 = 28~~
~~28x1 = 28~~

Similarly for 36 we check only till 6 for 49 we check only till 7 and so on. If we observe carefully we can easily find the pattern. For every target number, we only have to check till its square root

sqrt(28)=5.29
sqrt(36)=6
sqrt(49)=7

These minute changes might feel insignificant when we are dealing with smaller numbers like 28, 36, and 49 but tehy make huge difference when the target number is in millions or billions.

for example, if we want to check prime status of a number 876187398013 it will require 876187398013 iterations by our initial logic but only sqrt(876187398013) = 936048 iterations by our optimized logic.

So our optimized pseudocode and the flowchart for the program is

START
input num
count = 2
while count <= sqrt(num):
    if (num % count)=0:
        output "NOT Prime"
    count = count + 1
end while
output "Prime"
END

flowchart

Hope ya'll have got an idea of how the flow direction of program works and how we can tray and test our logic without actually writing the code using flowcharts and pseudocodes.

Reference

Introduction to Programming

Raj Pansuriya — Mon, 08 Nov 2021 15:15:41 +0000

Programming

Programming in simple terms can be stated as a way of instructing computer to perform some task. We write a code and pass it to computer and the computer then performs tasks accordingly. The computer can only understand language of 0's and 1's, so we can say that programming at its heart is nothing but passing a stream of 0's and 1's computer.
Now, if internally its only 0's and 1's it would be very difficult for us to write all the instruction as a combination of 0's and 1's only. That is the reason we have different programming languages which allow us to write all those instructions in human redable format. Eventually computer is going to translate all that code into 0's and 1's but atleast we are saved from the the pain of writing all instructions in its naive form.

Types of programming languages

Procedural language

These types of languages follow a top-bottom approach. That means, a series of well structured steps and procedures are specified to compose a program
It contains a systematic order of statements, functions and commands to complete a task for example

Input 1st no.
input 2nd no.
add both numbers
print the answer

Functional languages

In this programming approach, we write a code in pure functions only. A function in simple language is a block of code (set of instructions) bundled together.
Used in situations where we have to perform the different operations on same type of data.

For example, let's say we have to print number of words containing in files and have 20 such files. Does it make sense to write the same code from scratch for each file. Instead what we can do is write a function to do the task and then just pass each file to that function (or in simple terms apply that function to each file).

Doing this not only saves time but is also helpful when we want to change the code due to some reason. Intead of having to chnage 20 differnet code files we can simply change the general function and we are good to go!

These types of language follow first class function properties. If we can reassign a function to another function then the language is said to follow first class function properties. for example,

function_1:
    some code block

instruction 1
instrcution 2

function_2=function_1
# here we assigned function_2 to be equal to function_1.
# This is known as 1st class function behaviour

An example of such programming language can be python. Mind that python may not follow purely functional language approach, I'm just saying that python does have first class functions.

Object Oriented Programming (OOP)

Revolves around objects
object = code + data

Let's say we have to gift 10 fruit baskets to our friends. We collected (40-Apples), (50-Oranges) and (70-Bsnanas) and divided them equally in those baskets. Now if someone asks us what fruit are we giving them, we do not have a single answer as the basket is composed of three different types of fruits. So then whats going to be the collective type of the basket. It'll be a custom type.

In the same way, when we are to group data of different datatypes like integer,decimal,character etc. the collective datatype of the data is custom datatype and one single unit of that data is said an object.

So the idea of OOP is to divide the code into different chunks of code in order to develope, debug, reuse and maintain the software efficiently.

Static vs Dynamic languages

Static	Dynamic
Type checking is done at compile time.`int a = 10`, we have to specify the type of `a` before assigning it a value.	Type checking is done at runtime.`a = 10`, computer will automatically understand that `a` is of integer type as the values assigned is 10.
Errors will be shown at compile time.`int a = 25.4' will give an error after the compilation itself because we are assigning a decimal to an int type integer.	Errors might not show till the program is run.`'a' + 10 //ERROR` all the statements before this particular statement will get executed (if none of them has any error ofcourse) and at the time of this statement itself we get an error because we are trying to add and integer and a character
We have to declare datatype before using a variable `int a = 10`	No need to declare the datatype `a = 10`
We may have to write a little more code as compared to dynamic language, but we have more control over the program.	Saves time in writing code but might give an error at runtime.

Now that we have got a basic background, let's try and understand some basic things which occur when we write some code.

Memory Management

a = 10

In the given instruction, a is known as a reference-variable and the value 10 is known as an object

There are two types of memories namely heap-memory and stack-memory.

When the instruction a = 10 is executed, the variable a is stored in stack-memory and it points towards the object 10 which is stored in heap-memory.

So whenever our code needs to access the value of a, it looks into stack by which it gets a pointer to a value of heap memory upon following which it gets actual value of the variable a.

Important

More than one reference variables can point to same object

for example same person is called by different names by his family, friends teachers, etc.

Value of an object is changes for all the reference variables even if it is changed by any one reference variable

for example, if the person named Kunal has lunch, automatically baby, son and brother also had lunch.

Objects with no reference variables are removed when garbage collection hits and the memory is freed.

for example,

a = 10

Now,we reassign a to 37

a = 37

So the 10 will be removed from memory by garbage collector and the memory will be freed

Note:

Compile time: The period where code from human redable format is being converted to machine redable format(machine code; 0's & 1's)
Run time: The period where our code is being executed
There are no separate partitions or disks as heap and stack, it is just how the memory is managed by CPU. There is only one RAM which is managed in the said way

Reference

EOFError: EOF when reading a line

Raj Pansuriya — Fri, 12 Feb 2021 12:27:32 +0000

So as we can see in the pictures above, despite having produced the expected output, our test case fails due to a runtime error EOFError i.e., End of File Error. Let's understand what is EOF and how to tackle it.

What is EOFError

In Python, an EOFError is an exception that gets raised when functions such as input() or raw_input() in case of python2 return end-of-file (EOF) without reading any input.

When can we expect EOFError

We can expect EOF in few cases which have to deal with input() / raw_input() such as:

Interrupt code in execution using ctrl+d when an input statement is being executed as shown below
Another possible case to encounter EOF is, when we want to take some number of inputs from user i.e., we do not know the exact number of inputs; hence we run an infinite loop for accepting inputs as below, and get a Traceback Error at the very last iteration of our infinite loop because user does not give any input at that iteration

n=int(input())
if(n>=1 and n<=10**5):
phone_book={}
for i in range(n):
feed=input()
phone_book[feed.split()[0]]=feed.split()[1]
while True:
name=input()
if name in phone_book.keys():
print(name,end="")
print("=",end="")
print(phone_book[name])
else:
print("Not found")

The code above gives EOFError because the input statement inside `while` loop raises an exception at last iteration

Do not worry if you don't understand the code or don't get context of the code, its just a solution of one of the problem statements on HackerRank 30 days of code challenge which you might want to [check](https://www.hackerrank.com/challenges/30-dictionaries-and-maps/problem)
The important part here is, that I used an infinite while loop to accept input which gave me a runtime error.

###How to tackle EOFError
We can catch EOFError as any other error, by using try-except blocks as shown below :

try:
input("Please enter something")
except:
print("EOF")

You might want to do something else instead of just printing "EOF" on the console such as:

n=int(input())
if(n>=1 and n<=10**5):
phone_book={}
for i in range(n):
feed=input()
phone_book[feed.split()[0]]=feed.split()[1]
while True:
try:
name=input()
except EOFError:
break
if name in phone_book.keys():
print(name,end="")
print("=",end="")
print(phone_book[name])
else:
print("Not found")

In the code above, python exits out of the loop if it encounters EOFError and we pass our test case, the problem due to which this discussion began...
![image](https://dev-to-uploads.s3.amazonaws.com/i/nmlt8x65v42bl926l5a4.png)

Hope this is helpful
If you know any other cases where we can expect EOFError, you might consider commenting them below.

#30DaysofFlutter

Raj Pansuriya — Tue, 02 Feb 2021 14:28:24 +0000

First things First: What is Flutter

Flutter is Google’s open source UI toolkit for building beautiful, natively compiled applications for mobile, web, and desktop from a single codebase. It’s one of the fastest growing, most in-demand cross platform frameworks to learn and is used by freelance developers and large organizations around the world.

In Flutter everything is a Widget. So you build your App with existing Widgets and build new ones. You can use existing Widgets and build new Widgets. You can think of it as jig-saw puzzle, where you put together several pieces (Widgets) to complete the puzzle (application).

30 Days of flutter

#30DaysOfFlutter is an open for all initiative by Flutter Community to help developers who have experience in building apps using different SDKs and technology and aspiring app developers learn more about building apps using Flutter.

Day 1

In the orientation session, We spent some time to appreciate efforts of Flutter-Community for flutter's journey from being just an open-source project to becoming one of the most liked and preferred platform by developers.
Here are some glimpse...

Then we had a thorough walk-through about the resources we will be using and to get along with the flutter environment followed by live installation of Flutter

As we went through the session we also got to know, various ways to interact with the Community and to even contribute to the flutter project by making our own widgets and also various other ways of contribution.

If you have still not registered for the #30DaysofFlutter challenge, you still have a chance to register.
Spare some time and visit Flutter-community website, get connected to become part of such an amazing open-source community!!

I hope this article will help you understanding more about Flutter and its wonderful Community.

DEV Community: Raj Pansuriya

Loops in JAVA

Types of loops

For loops

While loops

Do While loops

Raj-Pansuriya / java-dsa

Switch Statements in JAVA

Switch Syntax

Understanding break statement

Understanding default statement

Notes for Switch

Enhanced switch

Nested switch case

Raj-Pansuriya / java-dsa

Conditionals in JAVA

Logical operators used to write conditions

Different types of conditionals

Nested if-else statements

Caution

Raj-Pansuriya / java-dsa

Datatypes in JAVA

Primitive Datatypes

IMP

Inputs for various data types

Type Conversion & Casting

Conditions for Type Conversion

Raj-Pansuriya / java-dsa

I/O in JAVA

What is a package in Java

Outputs in Java

print vs println

Inputs in Java

Structure of JAVA Code

Some important things about a Java code

Tips while writing a java code.

Getting Started with Java - Installation

Java on Linux distributions

Introduction to Java - Compiler Architecture

How JAVA is Platform Independent

More on Platform Independence

Architecture of JAVA

Java Development Kit (JDK)

Java Runtime Environment (JRE)

Compile Time

Run Time

Class loader (Working of JVM)

JVM Execution

JRE vs JVM

Collectively

Reference

Flow of Program

Flowcharts

Pseudocode

Reference

Introduction to Programming

Programming

Types of programming languages

Static vs Dynamic languages

Memory Management

Important

Reference

EOFError: EOF when reading a line

What is EOFError

When can we expect EOFError

#30DaysofFlutter

First things First: What is Flutter

30 Days of flutter

Day 1