Archive for category: Java

This post is a continuation of the previous video lecture on Recursion. The current post and the associated video lecture explain more on recursion in Java. We target the following problem — how to compute the summation of all the integer numbers between 1 and n, using recursion.

Recall from the previous post that we can go over a series of numbers using recursion. In the previous lecture, we used recursion to print all the integer numbers between 1 and n. The recursive method had a void return type. That is, the method did not return any value but the execution only. In the current post, the recursive method has an int return type.

The problem description

In the current post and the in the video, we apply a mathematical operation (summation) over a series of integer numbers. The recursive method in the current post has an integer return type. Basically, we are solving an exercise question that I provided in the previous post.

Again, the exercise question we are targeting is — Add all the numbers between 1 and n, of course, using recursion. A condition is: n>0.

We can write the series of integer numbers as:

1+2+3+4+… … … +n

Also, instead of writing 1+2+3+4+ …. +n, we can rewrite the series as

n+ ….. … … +4+ 3+ 2+1

That is, I can write the numbers backward, without changing the content of the series.

We can put some more values, in terms of n, here in the sequence. It is just inclusion of more terms of n in place of some of the dots. The series is the same as before.

n+(n-1)+(n-2)+ ….. … … +4+ 3+ 2+1

Note that, n is the largest number in the series. The next number is one less than n, which is (n-1). The number after that is 2 less than n. Therefore, it is (n-2), so and so forth. The numbers added in the series become smaller and smaller, ending with 4+3+2+1.

We do not add anything smaller than 1 in the series because there is a condition with the problem description that n>0. That means, any number in the series has to be greater than 0 because any number can be considered n since it is the variable to this problem.

The associated video lecture

The following video lecture contains a video-version of this post.

Looking at a series as a function

Let us say that the function that sums up all the integer numbers between 1 and n is called adder. adder is a function of n. We write it as the word adder, and then within parenthesis we write (n). That is the function is written as adder(n).

We write:

adder(n)=n+ ……… +4+ 3+ 2+1

Or, adder(n)=n+(n-1)+(n-2)+ ….. … … +4+ 3+ 2+1

An iterative solution

It is easy to write a method to implement the function adder(n) using a loop. Let us write a Java method that implements the iterative adder(n) function.

import java.util.Scanner;
class Summation{
  public static void main(String[] args){
    Scanner myScanner = new Scanner(System.in);
    System.out.print("What is the value of n: ");
    int n=myScanner.nextInt();
    int s=adder(n);
    System.out.println("The summation is: "+s);
  }
  static int adder(int n){
    int sum=0;
    int i;
    for (i=n; i>0 ; i=i-1 ){
      sum=sum+i;
    }
    return sum;
  }
}

Notice that the method adder in the code has a for-loop that helps iterating over all the integer numbers starting from n ending at 1. The loop adds each number to the sum variable during the iterations. The method returns the integer, sum, which holds the summation of all the numbers.

Note from a previous lecture on methods that we have to declare the adder method as a static one, because we are calling adder from the main method, which is a static one.

The output of the iterative solution

Let us save the file, compile it, and run it. Here is the output.

My Computer$ javac Summation.java 
My Computer$ java Summation
What is the value of n: 5
The summation is: 15
My Computer$ java Summation
What is the value of n: 100
The summation is: 5050
My Computer$

Notice that the user enters n equal 5 and the program prints 15, which is the summation 5+4+3+2+1.

The user enters 100 in place of n and the program prints 5050, which is the summation of all the integer numbers between 1 to 100.

The program is working perfectly. However, the problem description states that we should not use a loop, rather we should use recursion to solve this problem.

Therefore, let us change the method adder in such a way that it does not contain any loop.

Looking at a series as a recursive function

We already wrote an iterative method static int adder(int n), as our solution. We need to modify that method to get rid of the loop.

Here is the sequence we want to code:

n+(n-1)+(n-2) ….. … … +4+ 3+ 2+1

As explained before, at first we have n. The next number is one less than n, which is n-1. The number after that is 2 less than n. Therefore, it is n-2, so and so forth. Finally, the numbers added become smaller and smaller, such as, 4, 3, 2, and 1.

Mathematically,

adder(n)= n+(n-1)+(n-2)+ ….. … … +4+ 3+ 2+1

Now, notice that, the part that contains (n-1)+(n-2) ….. … … +4+ 3+ 2+1, can be considered adder(n-1).

Hence, we can write

adder(n)=n + adder(n-1)

adder(n-1) already has every term from n-1 down to 1 in it. Therefore, adding n with adder(n-1) will give adder(n).

As an example, when n=5:

adder(5)=5+4+3+2+1

With n=4, adder(4)=4+3+2+1

Therefore, we can replace the 4+3+2+1 part of the adder(5) equation, by adder(4)

That is, we can rewrite:

adder(5)=5+adder(4)

therefore, the general equation is:

adder(n)=n + adder(n-1)

Notice that the above mathematical definition of adder(n) is already a recursive equation. In the left side, we have the function adder with parameter n. In the right side we have the same function “adder” but with a smaller parameter, (n-1).

The problem description already states that n should be greater than 0. That means, if the recursion ever reaches to a parameter with value 0, we should return something that does not contribute to the summation. Something that does not contribute to a summation is zero. That mean, no harm is done if we add 0 to anything. Therefore, we will return a 0 instead of further going inside another recursion, when the parameter itself is 0. Hence we have a base case, which is returns 0 when n becomes smaller than 1.

Let us code the items we discussed.

The recursive solution to the problem

We need to delete the loop entirely from the method adder of the iterative solution. Let us keep the sum variable. The variable sum now should be n+adder(n-1) based on our discussion above. We are still returning sum, just like when we had a loop. The recursion will do the work of looping.

The recursive solution is as follows. We only made changes to the adder method.

import java.util.Scanner;
class Summation{
  public static void main(String[] args){
    Scanner myScanner = new Scanner(System.in);
    System.out.print("What is the value of n: ");
    int n=myScanner.nextInt();
    int s=adder(n);
    System.out.println("The summation is: "+s);
  }
  static int adder(int n){
    if (n<1){
      return 0;
    }
    int sum=0;
    sum=n + adder(n-1);
    return sum;
  }
}

The following part of the adder method is the base case.

    if (n<1){
      return 0;
    }

The line

sum=n + adder(n-1);

has the recursive call to adder, where (n-1) portion of the problem is solved. That is, one adder method performs one addition only; the rest of the additions are performed in other recursive calls.

The output of the recursive solution

The output of the recursive program is no different than its iterative version. Note that we solved the same problem using iterative and recursive solutions. Therefore, their outputs for the same n will be the same.

Tracing the recursive solution

I highly suggest that you watch the YouTube video above to view how I traced the program for n=3. After watching the video, trace the program with n=4 and n=5, as a practice.

As I said in the earlier lecture, many sophisticated algorithms in artificial intelligence rely on recursion because recursion automatically saves the local variables and the parameters in each call. If you trace the recursive version of the program we have written in the current post, you will see that n has different values in each call.

The reality of a recursive solution

Recursion is an elegant technique. The reality of recursion is that you will prefer an iterative solution over a recursive one if the iterative one is easy to code. Sometimes, recursive solutions are easier to code but can be slower than its iterative version.

The tradeoff between ease of coding and how fast your program runs is a topic that is generally discussed in an Algorithms course. The specific topic is known as algorithm complexity. May be, some day we will discuss about algorithm complexity too.

For now, let us keep practicing and developing our programming skills.

Concluding remarks

If you have not yet subscribed to Computing4All.com and to our YouTube channel, please do so to receive notifications on our new articles and videos. Let us know if you have any questions via comments below.

This article covers details on methods. It explains why we need to use methods in our programs, how to pass data to a method using parameters, and retrieve information from it via a return statement.

A method is a block of code to perform some specific tasks. One method can be called by another method an arbitrary number of times. That means a programmer can write a method when she or he feels that the lines of codes written in the method will be used multiple times. 

The use of methods can significantly reduce the length of your code. In many computer languages, methods are known as functions because a method is supposed to code some functionality.

The following video lecture explains methods in Java with examples and tracing.

Structure of a method in Java

Even though we did not explain what methods are in our previous articles, you are already familiar with one method. That method is the “main” method that we have been writing in each of our programs throughout our video lecture series on Java programming.

A method has the following format.

ReturnType MethodName (Parameters){
	// The body of the method
 	——-
	return …
}

The first line of a method is known as the header. A header generally contains a return type, a method name, and some parameters. Then we write the body of the method. The body contains a standard Java code. It may contain return statements too.

A return type

A return type states what kind of information a method will send to its caller. It can be int, double, float, or any primitive data type. It can be even an object or even an array reference. 

Method name

After the return type in the header, we write the method name. The method name cannot be the same as any existing syntax. Also, it has naming rules like — it cannot start with a numerical digit. Uppercase letters are considered different than lower case. It must be one token — which means that there cannot be spaces in the name of the method.

Method parameters

Within parentheses in the header line, we provide parameters. Parameters are inputs to the method. A caller method can send data content to a method using the parameters. We can provide multiple parameters. 

The body of a method

We write the body of a method within curly brackets. The body of the code will contain standard Java codes that we are already familiar with. The body can use the parameters as regular variables. It may create new variables, as well. One can return data to the caller by using a return statement. 

A return statement

Depending on the logic used in the method, the return statement may appear multiple times in the body, but only one of those return statements will execute. Execution of a return statement will take the program to the caller method, from where this method was called. That is, the execution of a return statement ends the execution of the method where it is situated.

The returned data type must match with the ReturnType mentioned in the header of the method.

Which method the Java virtual machine executes first?

The Java virtual machine recognizes the main method and always calls it first. Regardless of where we write our methods, before or after the main method, the Java virtual machine will always start the program from the main method.

A simple method without any parameter and returns

Let us write our first method, that is not the main method. Let us write a method named myGoodMethod before the main method. 

class MethodTest{
  static void myGoodMethod(){
    System.out.println("Hi, my name is Shahriar.");
  }
  
  public static void main(String[] args){
    myGoodMethod();
  }
}

Explaining static 

In the code above, we start the header line of the method myGoodMethod with the syntax static. At this point, it is hard to explain why we are using this syntax static because we have not yet taught the object-oriented paradigm of Java in our Java lecture series. The explanation that does not include the object-oriented concepts is as follows. From a static method, one can only call other static methods. Since our main method is a static one, and we call the newly created method from our main method, we have to make our new method a static one too.

Return type -void

After writing static, we need to write a return type. As said earlier, a return type states what kind of information this method will send to its caller. The method, myGoodMethod, does not return anything. It just prints something. We need to tell Java virtual machine that the method will not return anything. The syntax that states that we will not return anything is void. 

Method name, myGoodMethod

After writing the syntax “void”, we have to write the method name, which is myGoodMethod. It could be any other name that does not conflict with any existing Java syntax.

No parameter

In parentheses, we provide nothing. Keeping the parameter list empty indicates that the caller can send nothing through the parameter of this method.

The body of the method

In the body of the method, that is within the curly brackets, we write our code. We wrote a System.out.println statement to print, “Hi, my name is Shahriar.”

Calling myGoodMethod from the main method

Now, we can call myGoodMethod from any method. Therefore, we can call myGoodMethod from the main method. To call the method myGoodMethod, we just have to write myGoodMethod in the main method. We also have to provide the necessary parameters in parentheses. In this case, we do not have any parameters. Therefore, we put an empty set of stating and ending parentheses. Then we put a semicolon like any standard java instructions.

The output of the program

Executing the program will print, “Hi, my name is Shahriar.” That means, our main method successfully executed the method named myGoodMethod.

How can we use a parameter in a Java method?

Let us discuss how we can use a parameter. We will change our code a little bit. The goal is to make our method myGoodMethod suitable for printing any name, not just a specific one. We will send the name as a parameter of the method. The method will print the name that it receives.

Here is the modified code.

class MethodTest{
  static void myGoodMethod(String anyName){
    System.out.println("Hi, my name is "+anyName+".");
  }
  
  public static void main(String[] args){
    myGoodMethod("Jane");
    myGoodMethod("John");
    myGoodMethod("Snow White");
  }
}

A parameter in myGoodMethod

When we declare a parameter, we declare it as a variable. We plan to send a name, which is of String type. Therefore, we state that the parameter is of String data type in the parameter part of the header. Then we give the parameter a name. The name of the variable is anyName. Now, the paramter anyName can be used to send a name from the caller method. 

Using the parameter

Whatever content the parameter variable anyName contains, we want the System.out.println method to print that. In place of “Shahriar”, we will print the content of the String variable anyName. In the System.out.println, we write “Hi, my name is”, then we add the variable anyName, and then we add a full-stop symbol.

Now, the method is ready to accept any name from its caller.

Calling with arguments

From the main method, let us call the same method three times, with three different names as the parameter.

In the first call, we provide “Jane” as the argument.

The second call has the argument “John”. 

In the third call, we send “Snow White”.

The instances we pass from the caller are sometimes called arguments. That is Jane, john, and Snow White are three arguments we are passing to the method myGoodMethod via three calls.

The parameter anyName is the variable that captures each of the arguments. 

The output of the program

Once we run this program, we should see three lines starting with “Hi, My name is”, but each line will have a different name, Jane, John, and Snow White. 

Here is the output of the program.

Hi, my name is Jane.
Hi, my name is John.
Hi, my name is Snow White.

Now, we know how to send a parameter. Let us extend this code a bit and learn how to send two arguments in each call.

Sending two arguments in a method

Sending two or more arguments to a method is not that difficult. We can provide parameters separated by commas. 

In our running example, we will use a second paramter to include age of the person whose name is in the first parameter.

Here is the modified class.

class MethodTest1{
  static void myGoodMethod(String anyName, int theAge){
    System.out.println("Hi, my name is "+anyName+". I am  "+theAge);
  }
  
  public static void main(String[] args){
    myGoodMethod("Jane", 20);
    myGoodMethod("John", 19);
    myGoodMethod("Snow White", 23);
  }
}

In this case, let us say that age is an integer. Therefore, we write int then a variable name theAge. We separate the two paramters, anyName and theAge, by a comma.

Now, we can use the variable theAge to pass an integer along with the string anyName.

We change our System.out.println method to the following one, which includes both the variables, anyName and theAge.

System.out.println("Hi, my name is "+anyName+". I am "+theAge);

In the main method, in each of these calls, we have to provide two parameters. The first parameter must be a string, which is inside quotes just like before. There should be a second parameter, which must be an integer because this is how we designed our method named myGoodMethod (String anyName, int theAge).

With each name, we provide a second argument in each call, which is an integer. The call myGoodMethod(“Jane”, 20); indicates that Jane is 20 years old. The next two calls in the main method imply that John is 19 years old, and Snow White is 23 years old. 

Once we execute the program, the corresponding age is printed with each name. Here is the output of the program.

Hi, my name is Jane. I am 20
Hi, my name is John. I am 19
Hi, my name is Snow White. I am 23

Another program with parameters and a return value

So far, we have seen how we can pass arguments to a method. We have not yet seen how we can return something from a method to the caller.

We can use the return statement and the return type to return content to the caller.

Let us work on a different problem now.

The problem and the solution

Let i and j be two integers. i<=j. Compute the summation of all the integers starting from i ending at j.

That is, if i=3 and j=6, then find the summation 3+4+5+6.

For the numbers 3, 4, 5, and 6, the summation will be 18. 

We will write a method that will take i and j as its parameters. The method will return the summation of all integer numbers between i and j. That is, if i is 3 and j is 6, then 18 will be returned by the method. 

Here is the program.

class MethodTest2{
  static int sumitoj(int i, int j){
    int sum=0;
    int a;
    for (a=i; a<=j; a=a+1){
      sum=sum+a;
    }
    return sum;
  }
  
  public static void main(String[] args){
    int s;
    s=sumitoj(3, 6);
    System.out.print("The summation of all integers ");
    System.out.println("between 3 and 6 is "+s);

    s=sumitoj(10, 20);
    System.out.print("The summation of all integers ");
    System.out.println("between 10 and 20 is "+s);
    
    s=sumitoj(1, 100);
    System.out.print("The summation of all integers ");
    System.out.println("between 1 and 100 is "+s);
  }
  
}

Parameters

The name of the method is sumitoj. sumitoj has two parameters, i and j. It returns an integer because the summation of some integers is an integer. The summation can be considered long too but we will keep the return type an integer with an assumption that the summation will not exceed the range on an integer variable. 

Summing the numbers

In the body of the method sumitoj, we declare an integer variable named sum. We will go over every integer between i and j and put the summation in the variable sum.

sum=0 in the beginning.

We write a for loop. We use a loop variable named a. The variable “a” starts from i, goes over every integer, and ends at j.

Inside the loop, we add whatever number we see in the variable “a” with the current sum. Then we remember this summation in the sum variable by assigning the summation to the variable sum (sum=sum+a;). 

Once the execution comes outside the loop, the variable sum contains the summation of all the numbers between i and j.

Return

We then return the value of sum. To do that, we write the following statement.

return sum;

sum is an integer. The return type is also an integer, as we declared. Therefore, the method should work fine.

Calling sumitoj from the main method

We call the method, sumitoj, from the main method three times with parameters

• 3 and 6,
• 10 and 20, and
• 1 to 100.

sumitoj(3, 6) returns 18, as expected. sumitoj(10, 20), and sumitoj(1, 100) return 165 and 5050, respectively. The output of the program reflects the summations. Here is the output of the program.

The summation of all integers between 3 and 6 is 18
The summation of all integers between 10 and 20 is 165
The summation of all integers between 1 and 100 is 5050

The video lecture linked with this article provides a detailed tracing of the program. The video further clarifies how methods execute in a Java program.

Concluding remarks

A programmer generally writes methods for most commonly used functionalities. Instead of writing the same code over and over in the main method, we can call the corresponding method with different arguments.

We will be back with more content soon. To keep in touch, subscribe to our website computing4all.com and to our video channel where we upload our video lectures.

Hope to see you soon in another video. Thank you.

A single dimensional array or a one-dimensional array can hold more than one element. Using an array, one can avoid the use of too many variables to store the same data types. As an example, a programmer can use an array variable to refer to the GPA scores of many students. In this article, I will discuss how to declare, initialize, and use a single dimensional array.

The items we are going to discuss in this article are as follows:

1. Why do we need an array variable?
2. How can we declare an array of a primitive data type?
3. How can we initialize the array with values? 
4. Example usage of an array: Sum the numbers stored in an array.

A video to support the discussions of this article is provided below.

Why do we need an array variable?

Suppose that we need to store how many miles each of ten people walked in a month. We will use an integer number for the mileage of each person. In our code, we can write ten variables for ten persons. Such as,

int milep1;
int milep2;
int milep3;
int milep4;
int milep5;
int milep6;
int milep7;
int milep8;
int milep9;
int milep10;

Let us assume that we already know what mileage values should be in the variables. Ten people walked 20, 22, 40, 18, 23, 25, 29, 35, 21, and 17 miles, respectively. Therefore, we can assign the values during the declaration time of the variables.

int milep1=20;
int milep2=22;
int milep3=40;
int milep4=18;
int milep5=23;
int milep6=25;
int milep7=29;
int milep8=35;
int milep9=21;
int milep10=17;

The problem of using too many variables

One problem of using too many variables is that our code cannot be easily generalized. That is, the program will always work only for ten people because it has ten fixed variables to store the monthly mileage of ten people. 

What would happen if we have 20 people? We will need to write another program that has 20 variables. What if we have 1000 people? We will need to write that has one thousand variables to store the walking distance of one thousand people.

Writing variables for so many people is not feasible.

A single dimensional array in Java

We can consider a single dimensional array to be a row of consecutive variables — each cell in the row stores one piece of information, such as the monthly walking mileage of a person. Therefore, instead of creating ten different variables for the walking mileage of ten different people, we will create one array that contains ten cells.

Let us say, the name of the array is “mileage”. The content of the array would be the numbers 20, 22, 40, 18, 23, 25, 29, 35, 21, and 17, that we wan to store for ten people.

We refer each of these cells by a location number. It is intuitive to call these cells the first cell, the second cell, the third cells, so and so forth up to the tenth cell. 

In Java, the first cell has a location number of 0.

The second cell has a location number of 1.

The third cell has a location number of 2.

So and so forth.

Note that the tenth cell of this array has a location number of 9.

Each location number or a position in an array is called an index. That is, indices start from 0. The last index of the “array” is equal to the “length of the array” minus 1. Therefore, in this array, the last index is 10-1=9.

How can we declare an array of a primitive data type?

One can declare an array of any data type using the following syntax format. 

dataType[] variableName;

In place of the word dataType, we can write whatever primitive data type is appropriate for our program. Some examples of primitive data types are int, double, long, byte, float, and char. In place of variableName, we can write whatever valid name we want to give our variable.

For our running example of walking-mileage, we will use an integer array. Therefore, the declaration will be:

int[] mileage;

Example declarations of some other primitive data types are as follows.

For an array, named mydoublearray, of double-size elements, we use:

double[] mydoublearray;

For an array, named mylongarray, containing long integers, we write:

long[] mylongarray;

That is, we can directly use the element data type and put the start and end square brackets and then provide the array name to declare an array variable.

The difference between a primitive variable and an array variable

An array variable is slightly more complicated than a regular variable. A regular primitive data type variable contains one value only. In contrast, the array variable does not hold one element. Instead, an array variable refers to the starting of several consecutive elements.

If we consider an array a house, the cells are analogous to the rooms of the house. The index refers to a room. The array variable-name refers to the address of the house. 

Similar to the house scenario, the array variable mileage we declared for our running example is an address in the main memory referring to the beginning of our array. That means we still have to create the cells starting from that address. 

Allocating space for the content of the one-dimensional array

To create the actual space to hold a certain number of integers, we have to specifically mention how many cells of integers we want in the array.

The command involves a syntax called new. The following line demonstrates how we can allocate memory for ten cells of integers using the new syntax.

mileage= new int[10];

The syntax new reserves a certain number of cells for a variable. “mileage=new int[10];” will reserve space for 10 integer cells for the array variable mileage.

Instead of writing “int[] mileage;” in one line and then the “mileage=new int[10];” syntax in a second line, we can directly declare and apply the “new” syntax in the same line like the following one.

int[] mileage= new int[10];

Initially, each cell of a newly created array contains a zero as its content. Afterward, we can change the content. 

How to initialize an array

How can we access each cell of the array? Say, we want to put 20, 22, 40, 18, 23, 25, 29, 35, 21, and 17 respectively in the cells of the array mileage. 

A cell of an array can be accessed by using its index number.

If we want to copy 20 in the first index of the mileage variable, we will write the following code.

mileage[0] = 20;

This command will copy 20 from the right side of the assignment operation, and put it in the index location of 0 of the mileage variable. Similarly, we can put rest of the numbers in the desired locations using more assignments.

mileage[1] = 22;
mileage[2] = 40;
mileage[3] = 18;
mileage[4] = 23;
mileage[5] = 25;
mileage[6] = 29;
mileage[7] = 35;
mileage[8] = 21;
mileage[9] = 17;

The commands have copied content in our entire array. That is, we can access the cells of an array, by writing the index in square brackets after the array name. 

How can we print the elements of an array using a loop?

To print all the numbers in the array, we will go over all the indices. Remember that indices start from 0 and end at “length of the array” minus 1. Therefore, to go over every index, we will need to write a loop that iterates over 0 to the length of the array minus 1.

We can retrieve the length of the array by writing myArray.length, where myArray is the name of the array variable. For our running example, mileage.length retrieves the length of the array.

The following code will print all the numbers in the array on the terminal.

class ArrayExample{
   public static void main(String[] args){
     int[] mileage;
     mileage[0] = 20;
     mileage[1] = 22;
     mileage[2] = 40;
     mileage[3] = 18;
     mileage[4] = 23;
     mileage[5] = 25;
     mileage[6] = 29;
     mileage[7] = 35;
     mileage[8] = 21;
     mileage[9] = 17;
     int i;
     for (i=0;i<=mileage.length-1; i=i+1){
       System.out.print(mileage[i]+" ");
     }
     System.out.println();
   }
 }

In the code above, we have a for-loop. We use an integer variable named i that moves from one index to another. i starts at 0. i is always smaller than or equal to 9 for our array mileage. We write i<=mileage.length-1 in the for-loop. mileage.length is 10 in our running example. Therefore, mileage.length-1 is 9. That is, inside the for-loop, i will vary from 1 to 9.

Of course, we will go to all consecutive indices, so we write i=i+1, in the third part of the for-syntax, indicating that we need the virtual machine to increment the value of i by one at the end of each iteration for the loop.

Inside the loop, all we have to do is to write a System.out.print statement. Within the parentheses, we have to print the content in the ith index of the array mileage. 

That is, we print the content of the cell in index i of the array mileage[i]. We also include a space character after printing mileage[i], so that consecutive numbers are separated when printed.

Outside the loop, we write a “System.out.println();” statement. This statement will ensure that there is a newline after the numbers are printed. That is, the command prompt will appear in another line, not in the same line where the numbers are printed.

After compiling and running the program, we will have all the numbers printed on the terminal.

Direct initialization of an array

We can initialize the array directly during the declaration time. There is a way to initialize during declaration, which implicitly has a new syntax. Instead of writing the initialization lines with ten assignments, we could declare the array variable and initialize it in one line, using the following syntax.

int[] mileage= {20, 22, 40, 18, 23, 25, 29, 35, 21,17};

That is, we can put all the numbers separated by commas within a pair of start and end curly brackets to avoid writing ten additional lines of code. The modified code is the following one.

class ArrayExample{
  public static void main(String[] args){
    int[] mileage = {20, 22, 40, 18, 23, 25, 29, 35, 21, 17};
    int i;
    for (i=0;i<=mileage.length-1; i=i+1){
      System.out.print(mileage[i]+" ");
    }
    System.out.println();
  }
}

The output of the program will remain the same.

Although such direct initialization of arrays is popular in academic settings, in practical programming, there is not much scope to leverage the benefit of direct initialization. In a real-life program, you will ask the user for how many numbers there should be in the array. Then you will use the new syntax to create an array of that size. Then you will ask the user to enter the content of the array. 

Since we are still learning how to use an array, we will keep using such direct initialization for convenience. 

Example usage of an array: Sum all elements

As an example, we will sum up all the elements of the array. Notice that we can use a similar loop to the one that we used to print the elements. 

We will create a variable named sum, which will have zero in it in the beginning. We will go over every element using the index, and add the corresponding content in the array to the sum variable.

The updated program below includes the code for summing up the elements in the previous code.

class ArrayExample{
  public static void main(String[] args){
    int[] mileage = {20, 22, 40, 18, 23, 25, 29, 35, 21, 17};
    int i;
    for (i=0;i<=mileage.length-1; i=i+1){
      System.out.print(mileage[i]+" ");
    }
    System.out.println();
    int sum=0;
    for (i=0;i<=mileage.length-1; i=i+1){
      sum=sum+mileage[i];
    }
    System.out.println("Total mileage: "+sum);
  }
}

The second for loop in the code is for the summation of all the elements. Before the second loop, we declared the integer variable sum. Once we are inside the loop, we deal with the ith index. Our target is to add the content of the ith index of the mileage array to the sum variable.

As an example, when i=5, inside the loop sum should already hold the summation result of all the contents between indices zero to four. 

To add the content of the ith index, with whatever content we have in the sum variable, we write sum+mileage[i]. This is written on the right side of the assignment. The summation result is put back to the variable sum by writing “sum=sum+mileage[i];” inside the loop. 

After the loop ends, we print the value of sum, which contains the summation of all the elements of the array variable mileage.

The program will print total mileage walked by ten people. Here is the screenshot after running the updated program.

The program prints the numbers in the array. Then it prints the summation result.

Exercise

• Write a program that starts with an array of ten integers. Print all the integers on the terminal. Then print the biggest number in the array.
• Write a program that starts with an array of ten integers. Print all the integers on the terminal. Then print the smallest number in the array.

Concluding remarks

If you haven’t subscribed to our website Computing4All.com and to the YouTube channel where we host our video lectures, please do so to receive notifications on our new articles and videos.

Please do not hesitate to contact us via the comments section below.

Java do-while loop is one of the three looping techniques available with the language. The other two loops are: for loop and while loop. do-while is a little bit different than for or while loops. In the “for” or “while” loop, generally, a condition is checked in the beginning to realize whether the execution should go inside the loop, or not. In contrast, do-while checks for the requirement of iteration at the end of the loop. As a result. do-while would execute the code-block inside the loop at least once.

Java do-while Loop

Java do-while loop has the following structure.

do {
     // Code-block
} while (condition);

The condition is generally an expression that results in either true or false. If the condition results in true, another iteration of the code-block will occur. If the condition becomes false, the loop terminates and executes anything found after the while loop.

Problem Used in the Video

In the video, we demonstrate how to write a program using java do-while loop to repeat the same task based on user preference. The task that the program repeats is the addition of two number provided by the user. The following image provides a screenshot of the program.

Notice that the program asks for two numbers from the user. The program prints the summation of the two numbers. Then it gives the user to enter ‘y’ to continue and any other letter to quit the program. The user repeats the task several times by entering ‘y’. When the user enters ‘n’ to quit, the program outputs “Good bye.” and terminates.

We wrote the program using a Java do-while loop. Here is the solution.

The Solution

The solution is provided in the space below.

import java.util.Scanner;

class DoWhileTest{
  public static void main(String[] args){
    double a;
    double b;
    Scanner scan = new Scanner(System.in);
    char decision;
    String str;
    do{
      System.out.print("Enter the first number: ");
      a=scan.nextDouble();
      System.out.print("Enter the second number: ");
      b=scan.nextDouble();
      System.out.println("The addition result is: "+(a+b));
      System.out.print("Enter y to perform more additions.");
      System.out.println("Any other letter to quit.");
      str=scan.next();
      decision = str.charAt(0);
    }while (decision=='y');
    System.out.println("Good bye.");
  }
}

The Video Lecture on Java do-while Loop

The video lecture below explains a lot of details on Java do-while loop.

Transcription of the Audio of the Video

In this video, we are going to discuss another looping technique known as do-while loops. We will discuss the structure of the do-while loop and compare it with other looping techniques in Java. Definitely, we will write a program to explain how a do-while loop works.

Why do you need a do-while loop?

Hi, I am Dr. Shahriar Hossain. Today, I am going to explain do-while loops in Java. From the previous videos, we are already familiar with for-loops and while-loops. Now the question is, why do we need a third type of loop, named do-while? Its a Good question. A do-while loop is a special kind of looping technique that is suitable for a situation when execution of a code-block is required at least for once.

Now, you may ask if a programmer needs to absolutely know about do-while loops. The answer is, a programmer can avoid do-while loops and use for or while loops with some tricks to do the same work. However, knowing do-while loops makes a programmer’s life easier in some situations.

Moreover, if you have to sit for a programming exam, or go for an interview, you absolutely need to be familiar with do-while loops. Do-while is one of the three looping techniques. As a programmer, we should be familiar with all the three type of loops: for, while, and do-while.

The structure of Java do-while loop and how it compares with other loops

Anyway, let us take a quick look at the structure of a do-while loop.

// Show Handwritten animation

do {
	// code-block
} while (condition);
-----
while (condition){
	// code-block
}
-----
for (initialization; condition; change){
	// code-block
}

The do-while loop starts with the word do. Then the scope of the code-block starts with a curly bracket. At the end of the code block, you end the scope using a closing curly bracket. Then the syntax “while” is written at the end with a condition. We have to put a semicolon at the end of the do-while loop.

Notice that do-while is quite different than while loop and for loop. Do-while is different in the sense that in while and in for loops, the condition is executed before going inside the scope. If the condition results in “true” in a for or while loop, the execution goes inside. If the condition results in false, the condition does not go inside.

In contrast, there is no condition before going inside the code-block of the do-while loop. That means the code-block will execute at least once. At the end, you have the condition with the while. Every time, the code block is executed, the condition-check will evaluate whether another repetition of the code-block is required. If the condition is true, then the code-block will be executed again. Otherwise, the execution will move forward to whatever statements are there outside the do-while loop.

What is a common use of Java do-while loop

A common use of do-while is to check if the user wants to repeat the same work. Let us discuss a program that uses do-while to repeat the same work as long as the user wants it to repeat.

<<Show the terminal output of the program first>>

Consider that we have an amazing program that can add two double-precision numbers. The program asks the user for two numbers. The program then reports the addition result. After the addition, the program asks the user if she/he would like to add more numbers. If the user enters ‘y’ for yes, then the program will ask again for two numbers that the user wants to add.

After the user enters two new numbers, the program will report the new addition result, and ask if the user wants to do more additions. The process will keep repeating as long as the user enters ‘y’. If the user enters ‘n’, then the program will say “Good bye” and terminate.

Starting the code

Let us write code for this program.

At first let us write a program that asks for two numbers, reports the summation result, and then terminates. Later we will modify the code to repeat the task.

Scanner

We already know how to write a Scanner object and ask the user to enter two numbers. We keep the two numbers in two variables named a and b. After receiving the numbers from the user, all we have to do is, to print the summation of the two numbers.

If we compile the java file and run the generated class file, we will notice that the program asks for two numbers from the user, then the program reports the summation, and finally the program terminates.

Java do-while loop

Now, what we want to do is the following – we want to use a do-while loop to repeat this part of the code, where we ask the user for two numbers, and then print the summation result.

Let us write the “do” syntax, and put our code inside the scope of the loop. The loop ends with the syntax “while” and then in parentheses we will need to provide the condition that is responsible for the repeat. Note that we have to put a semicolon at the end of the do-while loop.

Now, we still do not have any information that we can use for the condition that should go here. In fact, with the current code-block, we did not collect any information from the user regarding her or his desire to repeat the addition for another set of numbers.

A character variable

Let us declare a character variable that will help us to store a letter representing user’s desire to repeat. A character variable is able to keep only a letter, digit, or a symbol in it. For example, at can hold, ‘a’, ‘b’, ‘c’, or any letter. A character can hold even a digit like ‘1’ or ‘2’, or ‘3’. It can even hold symbols like ‘+’, ‘-’, or ‘*’. There is a wide range of characters, letters, digits, or symbols that it can hold.

We will ask the user to enter ‘y’ if she or he wants to do another addition. We will ask the user to enter anything else if she or he does not want to do any more addition. We will store whatever the user entered in the character variable named decision, we just created.

Get user-intention regarding repetition

We use the scanner object to get the user input for a character value. Unfortunately, the scanner object does not have a direct method to read a character. We have to read whatever the user enters using a the next() method. We have to keep the information in a String object. str is the String variable. Then we have to retrieve whatever we have in the first position of the String str and put it in the character variable decision. The value zero in the parentheses of charAt gives the first character. Characters in a String starts from 0. That is, the first character of a String has a location of 0, the second character has a location 1, the third character has a location of 2, so and so forth.

Anyway, we just need to take a look at the first character, whether it is ‘y’ or not. If the first character is ‘y’, it will be in location 0 of the String str. Hence, the variable decision will contain ‘y’.

If we find that the variable decision is not ‘, then we do not have repeat anymore.

Now, notice that the repetition of this do-while is dependent on whether the variable decision is ‘y’ or not. Therefore, we can write the condition here as decision ==‘y’. That means, if the decision variable is the character ‘y’, then repeat, otherwise do not repeat.

Single quotes for a character

Note that a character is placed within a single start quote and a single end quote. Without the quotes, the compiler will think that ‘y’ is a variable and will throw and error stating that the variable y is not declared in this program. Therefore, to indicate that we are referring to the exact character value ‘y’, we have to provide the single quotes.

The goodbye message

After the do-while loop terminates, we want the program to write a “Good bye” message. Therefore, we write a System.out.printlin method outside of the do-while loop.

Save, compile, and run

Let us save the file, compile the code,  and execute the generated class file. The user is asked for two numbers. The user enters the two numbers. The program reports the addition result. Then the program asks to enter y, if the user wants to do more additions. The user types ‘y’ and hits the enter button. The program asks for the numbers again. The addition result is displayed. Then the program again asks whether the user wants to do more additions. The user can keep entering ‘y’ here and keep doing additions. When the user enters anything other than ‘y’, the program says “Good bye” and then terminates.

Notice again, how we wrote our program. The code block executes at least once. The decision whether to repeat the code-block or not is made at the end. This structure of do-while is different than for loop and while loop in this way.

Concluding remark

Through this video, we have covered the third looping technique used in Java.  We already learned nested for-loops one of the previous videos. Similar to nested for-loops, you can write nested do-while loops. You can even write one do-while-loop inside a for-loop, or even one for-loop inside a do-while-loop. I hope the concept of looping is clear to you. Please let us know if you have any question through the comment section below. If you haven’t subscribed to our website Computing4All.com and to the YouTube channel where this video is hosted, please do so to receive notifications on our new articles and video lectures.

We wish you become successful in learning to code. Again, please do not hesitate to contact us via the comments section below, if you have any question. Or, even to introduce yourself. See you soon in another video.

Subscribe

Name

Email*

As stated in the previous video lecture, nested loops refer to the repetition of another repeated task. The nested loops we discussed in the last lecture were not dependent on each other in determining how many times a loop should iterate. In the exercise of this lecture, we demonstrate how we can ensure that the inner loop iterates a different number of times in each repetition of the outer loop.

We ended the last lecture with an exercise problem. In this lecture, we are going to solve that exercise.

Problem Description of the Exercise

Write a program using nested for loop to print the following pattern of asterisks on the terminal.

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

The Solution used in the Video Lecture

We wrote the following code in the video to solve the problem described above. Save the program in a file named NestedTri.java.

class NestedTri{
    public static void main(String[] args){
        int i;
        int j;
        for (i=1;i<=10;i=i+1){
            for (j=1;j<=10-(i-1);j=j+1){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

The Video Lecture

The YouTube video lecture is embedded below.

Transcription of the Audio of the Video

Hi,
This is Dr. Monika Akbar. I hope that you are enjoying Java programming. In the previous video lecture, we discussed nested loops. We will discuss nested looping in this video too, but there will be some added complexity in it.

You may recall that, we provided an exercise at the end of the previous video. We will solve that exercise here today. Even if you solved the exercise, I suggest that you watch this video because, through the exercise, we will explain nested loops that are connected. The exercise today will demonstrate how the inner loop can be dependent on the outer loop. Here is the exercise problem:

Problem description

Print 10 lines, where the first line, contains 10 asterisks, the 2^nd line contains 9 asterisks, the 3^rd line contains 8 asterisks, the 4^th line contains 7 asterisks, so and so forth. The sample output is provided below.

[Show the sample output.]

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

[End of sample output]

Again, by watching the video, you will learn nested looping, where the inner loop depends on the outer loop to determine how many times the inner loop should iterate.

Problem analysis

Let us analyze the problem a bit first.

Notice that the output of the problem must contain 10 lines of stars. The first line contains 10 stars. The number of stars reduces by one in the following line. The reduction continues till the tenth line.

Notice that the first line has 10 minus zero asterisks.

Line 2 has 10 minus 1 asterisks.

Line 3 has 10 minus 2 asterisks.

Line 4 has 10 minus 3 asterisks.

So and so forth.

Finally the 10^th line has 10 minus 9 asterisks, which is just one star.

If the problem was to print 10 asterisks in each of the 10 lines, we could directly use the technique we learned in the previous lecture. That is, we could write two for loops, where the inner for loop prints 10 asterisks in one line, and the outer for loop repeats the inner for loop 10 times.

Output

Running this code on the terminal will give ten rows, where each row contains 10 asterisks. However, this is not what we want. We need to reduce number of asterisks in the consecutive lines.

[Show the output.]

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

[End of show the output.]

More analysis of nested loops

Notice that the outer for loop controls which line is going to be printed. That is the variable “i” controls the line number. The inner for loop is responsible for printing certain number of asterisks in a line. Now, We have to change the inner for loop because we are changing the number of stars to be printed for any line. The inner for loop is controlled by the variable “j”.  We will change the inner for loop in such a way that it executes lesser and lesser number of times in subsequent lines.

Recall that, the first line should have all the 10 stars.

The second line should have 10 minus 1 stars, which is 9 stars

The third line should have 10 minus 2 stars, which is 8 stars,

The fourth line should have 10 minus 3 stars, which is 7 stars,

So and so forth.

In the code, in our inner loop, how many stars should be printed is basically controlled by this condition. Currently, the inner for loop is printing 10 stars every time because of this condition.

Now, how can we tell the program that we want to print lesser number of stars than 10, based on – in which line of asterisks – we are currently in. Notice that, the value of the variable “i” holds the information of the current line number. We can use the variable “i” to design how many less number of stars than 10 should be printed.

Controlling the inner loop using the control variable of the outer loop

Recall that, when we are in Line 1, we should print all 10 stars using the inner for loop. Therefore, we want to subtract zero from 10. Since the variable “i” has the value 1 when we are in line 1. We want to subtract i-1 from 10 when the variable “i” is 1. i-1 results in zero because variable “i” is 1.

When we are in Line 2, we want to subtract 1 from 10. In line 2, the value of the variable “i” is 2. Therefore, i-1 is equal to 1. Therefore, by subtracting i-1 from 10, we will be able to print 9 stars.

When we are in Line 3, the value of the variable “i” is 3. Therefore, i-1 will reduce 2 stars from 10, which is 8 stars.

So far, it seems putting 10- (i-1) to control the range of j will work for the first line, the second line, and the third line of asterisks. In fact, it will work for all the following lines.

Output

Let us save the file, compile it, and run the generated class file. We can see that we have the desired output, where the first line contains 10 stars, the second one contains 9 stars, the third one contains 8 stars, so and so forth.

Concluding remarks

The exercise today has shown how we can connect the inner loop with the outer one. There are many other applications that will require such connected nested loops. We will learn them over time with more complex problems.

If you have not yet subscribed to our website Computing4All.com and to this YouTube channel, please do so to confirm that you receive notifications on our new articles and videos. We will see you again in the next video. Wish you a wonderful day, evening, or night, whatever is upcoming. Thank you!