Print Natural numbers using two Even-Odd printing Thread

Print Natural numbers using Even-Odd Thread

There are two Threads, one Thread will print the even sequence and another will print the Odd sequence.

Use these Threads to print the sequence in the natural order.

PrintOdd.java

class PrintOdd implements Runnable {

     public static boolean oddFlag = true;

     public void run() {

           for(int i = 1; i <= 9;) {

                if(oddFlag) {

                     System.out.print(i+" ");

                     oddFlag = false;

                     i = i + 2;

                }

           }

     }

}

PrintEven.java

class PrintEven implements Runnable {

     public void run() {

           for(int i = 2; i <= 10;) {

                if(!PrintOdd.oddFlag) {

                     System.out.print(i+" ");

                     PrintOdd.oddFlag = true;

                     i = i + 2;

                }

           }

     }

}

PrintNatural.java

public class PrintNatural {

     public static void main(String args[]) {

           PrintEven prEven = newPrintEven();

           PrintOdd prOdd = newPrintOdd();

           Thread evenThread = newThread(prEven);

           Thread oddThread = newThread(prOdd);

           evenThread.start();

           oddThread.start();

     }

}

Output:

1

2

3

4

5

6

7

8

9

10

How to get the name of the current executing method in java?

Using reflection:

/** using reflection trace. */

Method method = new Object(){}.getClass().getEnclosingMethod();

String methodName = method.getName();

However, a new anonymous inner class will be created during compile time (e.g. MethodNameTest$1.class). So this will create a .class file for each method that deploys this trick.

Advantage of trick is that getEncosingMethod()

It returns java.lang.reflect.Method which can be used to retrieve all other information of the method including annotations and parameter names. This makes it possible to distinguish between specific methods with the same name (method overload).

Using stackTrace:

/** using stack trace. */

StackTraceElement[]stackTrace=Thread.currentThread().getStackTrace()

String nameUsingTrace = stackTrace[1].getMethodName();

import java.lang.reflect.Method;

public class MethodNameTest {

     public static void main(String[] args) {

           checkMethodName();

     }

     private static void checkMethodName() {

           /** using stack trace. */

           StackTraceElement[] stackTrace =                 

                       Thread.currentThread().getStackTrace();

           String nameUsingTrace = stackTrace[1].getMethodName();

          

           System.out.println("print method name using stack trace : "

                     + nameUsingTrace);

           /** using reflection trace. */

           Method method =

                 new Object(){}.getClass().getEnclosingMethod();

           String methodName = method.getName();

           System.out.println("print method name using reflection : "

                     + methodName);

     }

}

Output:

print method name using stack trace : checkMethodName

print method name using reflection : checkMethodName

ArrayList vs HashMap in Java

	ArrayList	HashMap
Interface	Implementation of java.util.List Interface.	Implementation of java.util.Map interface.
Storage	It used to store the object.	It is used to store the object in key-value pair. Where key and value are different objects.
Methods to implement	No method is required to implement. However contains() method uses the equals() method to check the existence of the object.	For HashMap, class which is used as key must implements equals() and hashCode() method correctly. Better hashcode() implementation will lead to better performance.
Ordering	ArrayList maintain order of object.	HashMap doesn't provide any order guarantee.
Duplicate	ArrayList allows duplicates	HashMap doesn't allow duplicates key, though it allows duplicate values.
Resizing	Size increase 50% after resizing.	Size increase 100%. Load factor plays the vital role to resize the HashMap.

Array vs ArrayList

	Array	ArrayList
Size	Array is a fixed length data structure. Length of array cannot changed once it created.	ArrayList is a variable length Collection class. Resizing operation in ArrayList is slow down performance as it creates new Array and copying content from old Array to new Array.
Generics	Array doesn’t support the Generics, as Array instance knows about what kind of type it can hold and throws ArrayStoreException.	ArrayList allows you to use Generics to ensure type-safety.
Wrapper	Array allows to store both primitives and Objects in Java.	ArrayList doesn’t allow to store primitives in ArrayList, it can only contain Objects. ArrayList<Integer> integerList = new ArrayList<Integer>(); integerList.add(1); Primitive data type will be autobox into the Integer object while storing.
Size Initialize	We can create instance of ArrayList without specifying size.	It is mandatory to provide size of Array while creating.
Multi-dimensional	Array can be multi-dimensional.	Array list is single dimensional.
Performance	Fast.	Slow because resizing.
Iterator	Using for, foreach	Using foreach, Iterator, List Iterator.

Pancake sort in java

Pancake sort:

Pancake sorting is the colloquial term for the mathematical problem of sorting a disordered stack of pancakes in order of size when a spatula can be inserted at any point in the stack and used to flip all pancakes above it.

A pancake number is the maximum number of flips required for a given number of pancakes.

flip(array, i): Reverse array from 0 to i.

Pseudo code Pancake sort:

1) iMax = Index of Largest element in unsorted array.

Find index of the maximum element index in arr[0..unsorted_array_size -1].

2) Call flip(array, iMax)

It will flip all element of array from 0 to iMax index.

The largest element will be the first element in the array.

3) Call flip(array, unsorted_array_size -1)

Flip complete unsorted array which result to put the largest element at the end of the unsorted array.

Complexity :

Total O(n) flip operations are performed in where each flip will take O(n) time. Therefore complexity is O(n^2).

Example

19

23

6

15

45

30

14

1. Find Max element index from 0 to N-1

iMax = 4

19

23

6

15

45

30

14

2. flip(0,iMax)

45

15

6

23

19

30

14

3. flip(0,N-1)

14

30

19

23

6

15

45

Repeat Step #1 to Step #3:

1. Find Max element index from 0 to N-2

iMax = 1

14

30

19

23

6

15

45

2. flip(0,iMax)

30

14

19

23

6

15

45

3. flip(0,N-2)

15

6

23

19

14

30

45

class PancakeSort {

     /**Perform Pancake sort. */

     static intpancakeSort(int array[]) {

           int n = array.length;

           /** */

           for (intunsortASize=n; unsortASize>1;--unsortASize) {

                /**

                 * Find index of the maximum element

                 * in arr[0.. unsortArrSize-1]

                 * */

                int idxMax = findMax(array,unsortASize);

               

                /**

                 * Move the maximum element to end of current

                 * array if it's not already at the end*

                 */

                if (idxMax != unsortASize-1) {

                    

                     /**flip will put the max element to beginning.*/

                     flip(array, idxMax);

                     /**

                      * flip will put the max element in the last

                      * of unsorted array.

                      **/

                     flip(array, unsortASize-1);

                }

           }

           return 0;

     }

     /**

      * Returns index of maximum element in unsorted array.

      **/

     static intfindMax(int array[], int n) {

           int idxMax = 0;

           for (inti = 0; i < n; ++i) {

                if (array[i] > array[idxMax]) {

                     idxMax = i;

                }

           }

           return idxMax;

     }

     /**

      * Reverses array[0..idx].

      **/

     static voidflip(int array[], int idx) {

           int temp, start = 0;

           while (start < idx) {

                temp = array[start];

                array[start] = array[idx];

                array[idx] = temp;

                start++;

                idx--;

           }

     }

     /** Utility function: print array*/

     static voidprintArray(int arr[]) {

           StringBuilder sb = newStringBuilder();

           for (intelement : arr) {

                sb.append(element).append(" ");

           }

           System.out.println(sb.toString());

     }

     /** Test Pancake sort. */

     public static void main (String[] args) {

           int array[] = {23, 10, 20, 11, 12, 6, 7};

          

           System.out.println("Unsorted Array: ");

           printArray(array);

          

           PancakeSort.pancakeSort(array);

          

           System.out.println("Sorted Array: ");

           printArray(array);

     }

}

Output:

     Unsorted Array:

     23 10 20 11 12 6 7

     Sorted Array:

     6 7 10 11 12 20 23