Oracle has invited java bloggers at Hyderabad campus on 13th June 2015 and we celebrated Java 's 20th birthday. Few days back, I got an invitation mail for this event and I was more than happy to join them.

It was really pleasure to meet other java bloggers and interact with them. It started with warm welcome by Ms. Vandana Shenoy( Directory Corporate Communications, Oracle) and she introduced the presenters.First speaker was Sanket Atal ( Group Vice President, India R&D, Oracle) and he gave presentation titled “Java – 20 years of Innovation”. It started with history of java to promising future of java. If you want to go through 20 year of the java, you can read more at oracle timeline
There were some quiz questions in between and it was pretty cool.


After that, there was a talk from java champion, Hashad Oak. He raised few very good points such as
  • Warm welcome nature of java.
  • Is syntax really important?
  • Java bloggers have a great responsibility for carrying a warm culture to the future developers
  • Promising future of java.

It was followed speech by Mr. Debraj Dutta, a winner of Oracle IOT challenge. He presented his "Bot so" robot which was really great. It uses raspberry pi and It actually takes command from twitter, then capture images and upload to google drive and share same at twitter privately.



After that, we cut yummy java 20 cake and celebrated java's 20th birthday.




In the end, I would like to thank Oracle for inviting to this event and I look forward more such events from Oracle. Below is the group picture of the event











In this post, we will see how  can we iterate a map in java. There are four ways of iterating over a map, HashMap or TreeMap.

Java HashMap tutorial:

    HashMap in java How HashMap works in java hash and indexfor method in HashMap hashcode and equals method in java How to sort HashMap by keys and values Difference between HashMap and HashSet Difference between HashMap and Hashtable How to iterate over HashMap
  1. Using keyset() and for each loop(Java 5)
  2. Using keyset() and java Iterator
  3. Using EntrySet() and for each loop(Java 5)
  4. Using EntrySet() and java Iterator
if you remove elements while iterating , then 1st and 3rd option  will throw java.util.ConcurrentModificationException.
If you understand internal working of HashMap, then it may be easier for you to iterate an HashMap

Lets take an example:
1. IterateMapMain.java 
package org.arpit.java2blog;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;

public class IterateMapMain {

 public static void main(String args[])
 {
  // HashMap with Country as key and capital as value
  HashMap<String,String> countryCapitalMap=new HashMap<String,String>();
  countryCapitalMap.put("India","Delhi");
  countryCapitalMap.put("Japan","Tokyo");
  countryCapitalMap.put("France","Paris");
  countryCapitalMap.put("Russia","Moscow");

  // Iterating Using keySet() and for each loop
  System.out.println("Iterating Using keySet() and for each loop");
  for (String countryKey:countryCapitalMap.keySet()) {
   System.out.println("Country:"+ countryKey +" and  Capital:"+countryCapitalMap.get(countryKey));

  }
  System.out.println("-----------------------------");

  // Iterating Using keySet() and java iterator
  System.out.println("Iterating Using keySet() and java Iterator");
  Iterator<String> countryKeySetIterator=countryCapitalMap.keySet().iterator();
  while(countryKeySetIterator.hasNext()){
   String countryKey=countryKeySetIterator.next();
   System.out.println("Country:"+ countryKey +" and Capital:"+countryCapitalMap.get(countryKey));

  }
  System.out.println("-----------------------------");

  // Iterating Using entrySet() and for each loop
  System.out.println("Iterating Using entrySet() and for each loop");
  for (Entry<String,String> entry:countryCapitalMap.entrySet()) {
   System.out.println("Country:"+ entry.getKey() +" and  Capital:"+entry.getValue());

  }
  System.out.println("-----------------------------");

  // Iterating Using entrySet() and java iterator
  System.out.println("Iterating Using entrySet() and and java Iterator");
  Iterator<Entry<String,String>> entryIterator=countryCapitalMap.entrySet().iterator();
  while(entryIterator.hasNext())
  {
   Entry<String,String> entry=entryIterator.next();
   System.out.println("Country:"+ entry.getKey() +" and  Capital:"+entry.getValue());

  }
  System.out.println("-----------------------------");

 }

}

Run it and you will get following output:
Iterating Using keySet() and for each loop
Country:France and  Capital:Paris
Country:Russia and  Capital:Moscow
Country:Japan and  Capital:Tokyo
Country:India and  Capital:Delhi
-----------------------------
Iterating Using keySet() and java Iterator
Country:France and Capital:Paris
Country:Russia and Capital:Moscow
Country:Japan and Capital:Tokyo
Country:India and Capital:Delhi
-----------------------------
Iterating Using entrySet() and for each loop
Country:France and  Capital:Paris
Country:Russia and  Capital:Moscow
Country:Japan and  Capital:Tokyo
Country:India and  Capital:Delhi
-----------------------------
Iterating Using entrySet() and and java Iterator
Country:France and  Capital:Paris
Country:Russia and  Capital:Moscow
Country:Japan and  Capital:Tokyo
Country:India and  Capital:Delhi
-----------------------------

In this post, we will see how  can we iterate a list in java. There are four ways of iterating over a list.
  • For loop
  • For each loop(Java 5)
  • While loop
  • Iterator
Below example will help you to understand, how to iterate list in java. I am taking custom object list to understand better

1. Country.java 
package org.arpit.java2blog;
public class Country {

 String name;
 long population;
 
 public Country(String name, long population) {
  super();
  this.name = name;
  this.population = population;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public long getPopulation() {
  return population;
 }
 public void setPopulation(long population) {
  this.population = population;
 } 
  
}
2. IterateListMain.java 
package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.Iterator;

public class IterateListMain {
 /**
     * @author Arpit Mandliya
     */
    public static void main(String[] args) {
          
        Country india=new Country("India",1000);
        Country japan=new Country("Japan",10000);
          
        Country france=new Country("France",2000);
        Country russia=new Country("Russia",20000);
        
        // We are going to iterate on this list and will print 
        //name of the country 
        ArrayList<Country> countryLists=new ArrayList<Country>();
        countryLists.add(india);
        countryLists.add(japan);
        countryLists.add(france);
        countryLists.add(russia);
        
        // For loop
        System.out.println("Iterating using for loop : ");
        for (int i = 0; i < countryLists.size(); i++) {
   Country countryObj=countryLists.get(i);
   System.out.println(countryObj.getName());
  }
        System.out.println("-----------------------------");
       
       // For each loop
        System.out.println("Iterating using for each loop : ");
        for (Country countryObj:countryLists) {
   System.out.println(countryObj.getName());
  }
        System.out.println("-----------------------------");
       
       // While loop
        System.out.println("Iterating using while loop : ");
        int i=0;
        while(i<countryLists.size())
        {
         Country countryObj=countryLists.get(i);
   System.out.println(countryObj.getName());
   i++;
        }
        
        System.out.println("-----------------------------");
      
        // Iterator
        System.out.println("Iterating using iterator : ");
        Iterator<Country> iteratorCountryLists= countryLists.iterator();
        while(iteratorCountryLists.hasNext())
        {
         System.out.println(iteratorCountryLists.next().getName());
        }
        
    }
}
Run it and you will get following output:
Iterating using for loop : 
India
Japan
France
Russia
-----------------------------
Iterating using for each loop : 
India
Japan
France
Russia
-----------------------------
Iterating using while loop : 
India
Japan
France
Russia
-----------------------------
Iterating using iterator : 
India
Japan
France
Russia


One of the common interview question is "What is difference between ArrayList and LinkedList".Before we actually see differences,let me give you brief introduction of both.

ArrayList

  • ArrayList is implementation of list interface.
  • ArrayList is not synchonized(so not thread safe)
  • ArrayList is implemented using array as internal data structure.It can be dynamically resized .

LinkedList

  • LinkedList is implementation of list and deque interface.
  • LinkedList is not synchronized
  • LinkedList is implemented using doubly linked list as internal data structure.

ArrayList vs LinkedList:

Parameter
ArrayList
LinkedList
Internal data structure
It uses dynamic array to store elements internally
It uses doubly Linked List to store elements internally
Manipulation
If  We need to insert or delete element in ArrayList, it may take O(n), as it internally uses array and we may have to shift elements in case of insertion or deletion
If  We need to insert or delete element in LinkedList, it will take O(1), as it internally uses doubly LinkedList 
Search
Search is faster in ArrayList as uses array internally which is index based. So here time complexity is O(1)
Search is slower in LinkedList as uses doubly Linked List internally So here time complexity is O(n)
Interfaces
ArrayList implements List interface only, So it can be used as List only
LinkedList implements List,Deque interfaces, so it can be used as List,Stack or Queue

When to use ArrayList or LinkedList?

It actually depends on our need.
  • If we have more insertion or deletion then we should use LinkedList.
  • If we have less insertion or deletion and more search operations then we should use ArrayList.
Please go through  core java interview questions for more interview questions.

Thread class's join method can be used to stop current execution of thread until thread it joins, completes its task. So basically , it waits for the thread on which join method is getting called, to die.

There are three variant of join method:

public final void join() throws InterruptedException :
Thread on which join method is getting called to die.

public final void join(long millis) throws InterruptedException:
This method when called on the thread, it waits for either of following:
  • Thread on which join method is getting called, to die. 
  • Specified milliseconds
public final void join(long millis,int nanos) throws InterruptedException:
This method when called on the thread, it waits for either of following:
  • Thread on which join method is getting called, to die. 
  • Specified milliseconds + nano seconds

Example:

Lets take simple example:
package org.arpit.java2blog.thread;

public class MyRunnable implements Runnable{

 public void run()
 {
  try {
   System.out.println(Thread.currentThread().getName()+" Start");
   // thread sleeps for 4 secs
   Thread.sleep(4000);
   System.out.println(Thread.currentThread().getName()+" end");
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }  
 } 
}
Create ThreadExampleMain.java
package org.arpit.java2blog.thread;

public class ThreadExampleMain {
 
 public static void main(String args[])
 {
               
  System.out.println("Main thread execution starts");
  MyRunnable mr=new MyRunnable();
  
  Thread t1=new Thread(mr,"Thread 1");
  Thread t2=new Thread(mr,"Thread 2");
  Thread t3=new Thread(mr,"Thread 3");
  
  t1.start();
  // lets waits for  t1 to die
  try {
   t1.join();
  } catch (InterruptedException e) {
   
   e.printStackTrace();
  }
 
 
  t2.start();
  try {
 // lets waits for 1 sec or t2 to die which ever occurs first 
  t2.join(1000);
   
  } catch (InterruptedException e1) {
   
   e1.printStackTrace();
  }
  t3.start() ;
  
  // complete all threads before completing main thread
  try {
   t2.join();
   t3.join();
   
  } catch (InterruptedException e1) {
   
   e1.printStackTrace();
  }
  System.out.println("Main thread execution ends");   
 }
}

When you run above program, you will get following output.
Main thread execution starts
Thread 1 Start
Thread 1 end
Thread 2 Start
Thread 3 Start
Thread 2 end
Thread 3 end
Main thread execution ends

Lets analysis output now.
  1. Main thread execution starts
  2. Thread 1 starts(Thread 1 start) and as we have put t1.join() , it will wait for t1 to die(Thread 1 end). 
  3. Thread 2 starts(Thread 2 start) and waits for either 1 seconds or die but as we have put sleep for 4 seconds in run method, it will not die in 1 second. so main thread resumes and Thread 3 starts(Thread 3 start)
  4. As we have put t2.join() and t3.join(). These 2 threads will get completed before exiting main thread.So Thread 2 will end(Thread 2 end ) and then thread 3 will end(Thread 3 end).
  5. Main thread execution ends.

Sleep method of java.lang.Thread is used to pause current execution of thread for specific period of time.

Some important points about sleep method are :
  • It causes current executing thread to sleep for specific amount of time.
  • Its accuracy depends on system timers and schedulers.
  • It keeps the monitors it has acquired, so if it is called from synchronized context, no other thread can enter that block or method.
  • If we call interrupt() method , it will wake up the sleeping thread.
    synchronized(lockedObject) {   
      Thread.sleep(1000); // It does not release the lock on lockedObject.
      // So either after 1000 miliseconds, current thread will wake up, or after we call 
      //t. interrupt() method.
      
  
Example: Create a class FirstThread.java as below.
package org.arpit.java2blog.thread;

public class FirstThread implements Runnable{

 public void run()
 {
  System.out.println("Thread is running");
 }
 
}
Create main class named ThreadSleepExampleMain.java
package org.arpit.java2blog.thread;

public class ThreadSleepExampleMain {
 
 public static void main(String args[])
 {
  FirstThread ft= new FirstThread();
  
  Thread t=new Thread(ft);
  t.start();
  long startTime=System.currentTimeMillis();
  try {
                // putting thread on sleep
   Thread.sleep(1000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  long endTime=System.currentTimeMillis();
  long timeDifference=(endTime-startTime);
  System.out.println("Time difference between before and after sleep call: "+timeDifference);
 }

}

When you run above program, you will get following output.
Thread is running
Time difference between before and after sleep call: 1001
You can see there is delay of 1 milliseconds. As mentioned earlier,its accuracy depends on system timers and schedulers.

Thread can be called as light weight process. Java supports multithreading , so it allows your application to perform two or more task concurrently.  Multithreading can be of advantage specially when now a days, machine has multiple CPUs, so multiple tasks can be executed concurrently.

Whenever we call main method in java, it actually creates a single main thread. Although it creates other threads too but those are related to system and known as daemon threads. So if we want to create more threads to execute task concurrently , we can use multiThreading.

Thread can be created in two ways.
  • By extending Thread class
  • By implementing Runnable interface

By extending Thread class:

You can create your own thread by extending Thread class and override run method. You need to create object of that class and then call start() method on it to execute thread as different threads.
Create a class FirstThread.java as below.
package org.arpit.java2blog.thread;

public class FirstThread extends Thread{

 public void run()
 {
  System.out.println("Thread is running");
 }
 
}
In above program, we have created our own thread by extending Thread class and overriding run method.
Create main class named ThreadExampleMain.java
package org.arpit.java2blog.thread;

public class ThreadExampleMain {
 
 public static void main(String args[])
 {
  FirstThread ft= new FirstThread();
  ft.start();
 }

}

In above program ,we are creating a object of FirstThread class and calling start method to execute the thread.
When you run above program, you will get following output.
Thread is running

By implementing Runnable  interface:

The other way is , you need to implement Runnable interface and override public void run() method. You need to instantiate the class, pass created object to Thread constructor and call start method on thread object to execute thread as different threads.
Create a class FirthThread.java as below.
package org.arpit.java2blog.thread;

public class FirstThread implements Runnable{

 public void run()
 {
  System.out.println("Thread is running");
 }
 
}
In above program, we have created our own class and implemented Runnable interface and overridden run() method.
Create main class named ThreadExampleMain.java
package org.arpit.java2blog.thread;

public class ThreadExampleMain {
 
 public static void main(String args[])
 {
  FirstThread ft= new FirstThread();
  Thread t=new Thread(ft);
  t.start();
 }

}

In above program ,we are creating a object of FirstThread class and passing it to Thread constructor and calling start method to actually execute.The start method will eventually call run method of FirstThread class.
When you run above program, you will get following output.
Thread is running

Thread vs Runnable which is better?

Implementing Runnable interface is considered to be better approach than Extending Thread due to following reasons.
  • Java does not support multiple inheritance so if you extend Thread class and you can not extend any other class which is needed in most of the cases. 
  • Runnable interface represents a task and this can be executed with help of Thread class or Executors. 
  • When you use inheritance, it is because you want to extend some properties of parent, modify or improve class behavior. But if you are extending thread class just to create thread, so it may not be recommended behavior for Object Oriented Programming.




"How will you calculate complexity of algorithm" is very common question in interview.How will you compare two algorithm? How running time get affected when input size is quite large? So these are some question which is frequently asked in interview.In this post,We will have basic introduction on complexity of algorithm and also to big o notation

What is an algorithm?

An algorithm is step by step instructions to solve given problem.
Lets take a simple example.You want to write an algorithm for listening particular song.
1) Search for song on computer.
2) Is song available?
            i.If Yes,Then listen that song.
           ii.If no,download that song and then listen that song.
So we are solving a problem by step by step procedure.This step by step instructions is called Algorithm.

Why do you need to evaluate an algorithm?

You need to evaluate an algorithm so that you can find most optimize algorithm for solving given problem and also considering various factors and constraints.
For example:
You want to go from city A to City B.Then there are various choices available i.e. by flight,bus or train.So you need to choose among different options depending on your budget and urgency.

Counting number of instructions: 

Number of instructions can be different for different programming languages.
Lets count number of instruction for searching a element in a array.
int n=array.length
for (int i = 0; i < n; i++) {

 if(array[i]==elementToBeSearched)
         return true;
 }
   return false;
Lets assume our processor takes one instruction for each of the operation:
  • For assigning a value to a variable
  • For comparting two values
  • Multiply or addition
  • Return statement
In Worst case:
If element which we want to search is last element in sorted array then it will be worst case here.
So :
if(array[i]==elementToBeSearched) ,i++ and i<n will executed n time

i=0,i<n, return true or false will be executed one time.

Here f(n)=3n+3

Asymptotic behaviour :

Here We will see how f(n) performs with larger value of n.Now in above function, we have two parts i.e. 3n and 3. Here you can note two points:
  • As n grows larger, we can ignore constant 3 as it will be always 3 irrespective of value of n. It makes sense as you can consider 3 as initialization constant and different language may take different time for initialization.So other function remains f(n)=3n.
  • We can ignore constant multiplier as different programming language may compile the code differently. For example array look up may take different number of instructions in different languages. So what we are left with is f(n)=n

How will you compare algorithms?

You can compare algorithms by its rate of growth with input size n
Lets take a example.For solving same problem, you have two functions:
f(n) =4n2 +2n+4 and f(n) =4n+4
For f(n) =4n2 +2n+4
so here
f(1)=4+2+4
f(2)=16+4+4
f(3)=36+6+4
f(4)=64+8+4
....
As you can see here contribution of n2 increasing with increasing value of n.So for very large value of n,contribution of n2 will be 99% of value on f(n).So here we can ignore low order terms as they are relatively insignificant as described above.In this f(n),we can ignore 2n and 4.so
n2 +2n+4 -------->n2

For f(n) =4n+4
so here
f(1)=4+4
f(2)=8+4
f(3)=12+4
f(4)=16+4
....
As you can see here contribution of n increasing with increasing value of n.So for very large value of n,contribution of n will be 99% of value on f(n).So here we can ignore low order terms as they are relatively insignificant.In this f(n),we can ignore 4 and also 4 as constant multiplier as seen above so
4n+4 -------->n

So here n is highest rate of growth.
Point to be noted :
We are dropping all the terms which are growing slowly and keep one which grows fastest.

Big O Notation:

This notation is used for theoretical measure of  execution  of an algorithm. It gives tight upper bound of a given function. Generally it is represented as f(n)=O(g(n)) and it reads as "f of n is big o of g of n".

Formal definition:
f(n) = O(g(n)) means there are positive constants c and n0, such that 0 ≤ f(n) ≤ cg(n) for all n ≥ n0. The values of c and n0 must not be depend on n. 



When you say O(g(n)) , It means it will never be worst than g(n). Having said that it means O(g(n)) includes smaller or same order of growth as g(n).
So O(n) includes O(n),O(logn) and O(1).
So O(g(n)) is a good way to show complexity of algorithm.

Lets take some example and calculate value for c and n0.
1. f(n)=4n+3
Writing in a form of f(n)<=c*g(n) with f(n)=4n+3 and g(n)=5n

4n+3<=5n for n0=3 and c=5.

or 4n+3<=6n for n0=2 and c=6
Writing in a form of f(n)<=c*g(n) with f(n)=4n+3 and g(n)=6n
so there can be multiple values for n0 and c for which f(n)<=c g(n) will get satisfied.

2. f(n)=4n2 +2n+4
Writing in a form of f(n)<=c*g(n) with f(n)=4n2 +2n+4 and g(n)=5n2
4n2 +2n+4<=5n2 for n0=4 and c=5

Rules of thumb for calculating complexity of algorithm:

Simple programs can be analyzed using counting number of loops or iterations.

Consecutive statements:
We need to add time complexity of consecutive statements.
       
                   int m=0; // executed in constant time c1
                   m=m+1;  // executed in constant time c2
  

f(n)=c1+c2;
So O(f(n))=1

Calculating complexity of a simple loop:
Time complexity of a loop can be determined by running time of statements inside loop multiplied by total number of iterations.
         int m=0; // executed in constant time c1
         // executed n times
         for (int i = 0; i < n; i++) {
             m=m+1;  // executed in constant time c2
  }
f(n)=c2*n+c1;
So O(n)=n

Calculating complexity of a nested loop:
It is product of iterations of each loop.
         
          int m=0; executed in constant time c1
          // Outer loop will be executed n times 
   for (int i = 0; i < n; i++) {
          // Inner loop will be executed n times
  for(int j = 0; j < n; j++)
  {
   m=m+1; executed in constant time c2
  }
 }
f(n)=c2*n*n + c1
So O(f(n))=n2

If and else:
When you have if and else statement, then time complexity is calculated with whichever of them is larger.
    
           int countOfEven=0;//executed in constant time c1
        int countOfOdd=0; //executed in constant time c2
           int k=0; //executed in constant time c3
//loop will be executed n times  
  for (int i = 0; i < n; i++) {
          if(i%2==0) //executed in constant time c4
            { countOfEven++; //executed in constant time c5
              k=k+1; //executed in constant time c6
            }
          else
            countOfOdd++; //executed in constant time c7
 }
                     
f(n)=c1+c2+c3+(c4+c5+c6)*n
So o(f(n))=n

Logarithmic complexity

Lets understand logarithmic complexity with the help of example.You might know about binary search.When you want to find a value in sorted array, we use binary search.
  
public  int binarySearch(int[] sorted, int first, int last, int elementToBeSearched) {
     int iteration=0;
     while (first < last) {
      iteration++;
      System.out.println("i"+iteration);
         int mid = (first + last) / 2;  // Compute mid point.
         System.out.println(mid);
         if (elementToBeSearched < sorted[mid]) {
          last = mid;     // repeat search in first half.
         } else if (elementToBeSearched > sorted[mid]) {
             first = mid + 1;  // Repeat search in last half.
         } else {
             return mid;     // Found it. return position
         }
     }
     return -1;    // Failed to find element
 }
Now lets assume our soreted array is:
  
int[] sortedArray={12,56,74,96,112,114,123,567};
and we want to search for 74 in above array. Below diagram will explain how binary search will work here.

When you observe closely, in each of the iteration you are cutting scope of array to the half. In every iteration, we are overriding value of first or last depending on soretedArray[mid].
So for
0th iteration : n
1th iteration: n/2
2nd iteration n/4
3rd iteration n/8.
Generalizing above equation:
For ith iteration : n/2i

So iteration will end , when we have 1 element left i.e. for any i, which will be our last iteration:
1=n/2i;
2i=n;
after taking log
i= log(n);
so it concludes that number of iteration requires to do binary search is log(n) so complexity of binary search is log(n)
It makes sense as in our example, we have n as 8 . It took 3 iterations(8->4->2->1) and 3 is log(8).
So If we are dividing input size by k in each iteration,then its complexity will be O(logk(n)) that is log(n) base k.

Lets take an example:
  int m=0; 
         // executed log(n) times
         for (int i = 0; i < n; i=i*2) {
             m=m+1; 
  }
Complexity of above code will be O(log(n)).

Exercise:

Lets do some exercise and find complexity of given code:

1.
   
         int m=0; 
         for (int i = 0; i < n; i++) {
             m=m+1; 
  }
Ans:
   
         int m=0; 
         // Executed n times
         for (int i = 0; i < n; i++) {
             m=m+1; 
  }
Complexity will be O(n)

 2.
   
        int m=0;
         for (int i = 0; i < n; i++) {
             m=m+1; 
  }
   for (int i = 0; i < n; i++) {
       for(int j = 0; j < n; j++)
             m=m+1; 
  }
}
Ans:
   
        int m=0;
       // Executed n times
         for (int i = 0; i < n; i++) {
             m=m+1; 
  }
    // outer loop executed n times
   for (int i = 0; i < n; i++) {
 // inner loop executed n times
       for(int j = 0; j < n; j++)
             m=m+1; 
  }
}
Complexity will be :n+n*n --->O(n2)

3.
   
        int m=0;
       
    // outer loop executed n times
   for (int i = 0; i < n; i++) {
 // middle loop executed n/2 times
       for(int j = n/2; j < n; j++)
          for(int k=0;k*k < n; k++ )
             m=m+1; 
  }
        }
}
Ans:
   
        int m=0;
       
    // outer loop executed n times
   for (int i = 0; i < n; i++) {
 // middle loop executed n/2 times
       for(int j = n/2; j < n; j++)
      // inner loop executed log(n) times
          for(int k=0;k*k < n; k++ )
             m=m+1; 
  }
       }
}
Complexity will be n*n/2*log(n)--> n2log(n)

 4.
   
 int m=0;
       
    
   for (int i = n/2; i < n; i++) {
       for(int j = n/2; j < n; j++)
          for(int k=0;k < n; k++ )
             m=m+1; 
  }
Ans:
 int m=0;
       
    // outer loop executed n/2 times
   for (int i = n/2; i < n; i++) {
 // middle loop executed n/2 times
       for(int j = n/2; j < n; j++)
      // inner loop executed n times
          for(int k=0;k < n; k++ )
             m=m+1; 
  }
Complexity will be n/2*n/2*n --> n3
 

Java tutorial for beginners Copyright © 2012