Question

In Java please.

This problem can be done in main. Apply the increment operator (++) 10 million times, first to an Integer reference and then to a variable of type int, each set initially to 1. Compare the running times.

To compare running times we use the method long System.currentTimeMillis()

that returns the current time in milliseconds.

For both the Integer reference x and the primitive y, the main method

• records the starting time in milliseconds,
• increments with ++ a variable 10,000,000 times,
• records the ending time in milliseconds, and
• displays the elapsed time, ending time - starting time.

Answer 1

Code:

public class Main
{
   public static void main(String[] args) {
   int y=1;
   Integer x=1;
   long startingtimeofi,endingtimeofi,startingtimeofI,endingtimeofI,elapsedtimeofi,elapsedtimeofI;
     
   startingtimeofi=System.currentTimeMillis(); //records the starting time in milliseconds,
while(y<=10000000)
   {
   y++; //increments a variable 10,000,000 times
   }
   endingtimeofi=System.currentTimeMillis();
   elapsedtimeofi=endingtimeofi-startingtimeofi; //calulating the elapsed time= ending time - starting time
   System.out.println("Running time for int y is "+elapsedtimeofi);//displays the elapsed time of int y
     
   startingtimeofI=System.currentTimeMillis(); ////records the starting time in milliseconds,
   while(x<=10000000)
   {
   x++; //increments a variable 10,000,000 times
   }
   endingtimeofI=System.currentTimeMillis();
   elapsedtimeofI=endingtimeofI-startingtimeofI; ////calulating the elapsed time= ending time - starting time
   System.out.println("Running time for Integer x is "+elapsedtimeofI);//displays the elapsed time Integer x
   }
}

Output:

Note:

• As seen in the output, The running time of variable of type int is less than that of Integer reference.
• The output keeps changing because execution time varies each time we execute, but the running time of variable of type int i will be less than that of Integer reference.

Please comment if you face any difficulty