Coffee break #92. 20 Mga Madalas Itanong sa Panayam sa Java

Pinagmulan: Dev.to Kamusta mga kapwa developer, nag-compile ako ng listahan ng mga pangunahing tanong sa panayam sa Java na dapat malaman ng bawat coder.

1. Paano i-reverse ang isang string sa Java nang hindi gumagamit ng reverse() na pamamaraan?

Sagot: Walang karaniwang reverse() na pamamaraan sa Java , bagaman ang reverse() na pamamaraan ay umiiral sa ilang mga aklatan gaya ng StringBuffer o StringBuilder . Samakatuwid, ang tanong ng pagbabalik ng array ay madalas na lumalabas sa mga panayam. Nasa ibaba ang isang simpleng algorithm na maaaring magamit upang baligtarin ang isang array.

public class StringReverse {

    public static void main(String[] args) {

        String str = "Flexiple";
        System.out.println(reverse(str));
    }

    public static String reverse(String in) {
        if (in == null)
            throw new IllegalArgumentException("Null is not valid");

        StringBuilder out = new StringBuilder();

        char[] chars = in.toCharArray();

        for (int i = chars.length - 1; i >= 0; i--)
            out.append(chars[i]);

        return out.toString();
    }
}

2. Sumulat ng code snippet para ipatupad ang Fibonacci sequence gamit ang recursion

Sagot: Ang code snippet sa ibaba ay nagpapatupad ng Fibonacci sequence gamit ang recursion. Ang tanong na ito ay karaniwan din sa mga panayam sa Java.

public class FibonacciNumbers {
    public static int fibonacci(int n) {
        if (n <= 1)
            return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }


    public static void main(String args[]) {
        int n = 10;
        System.out.println(fibonacci(n));
    }
}

3. Paano mo aalisin ang mga puwang mula sa isang string sa Java?

Sagot: Ang strip() method ay isang string method na nag-aalis ng lahat ng leading at trailing space. Ang Strip() ay gumagamit ng Character.isWhitespace() na pamamaraan sa loob upang suriin kung may whitespace. Nakikita nito ang mga puwang gamit ang mga Unicode na character at ito ang inirerekomendang paraan upang alisin ang mga puwang. Ang mga alternatibong pamamaraan stripLeading() at stripTrailing() ay maaari ding gamitin . Makakatulong ang mga ito kung gusto mong alisin lang ang mga nangunguna o trailing na puwang ayon sa pagkakabanggit. Ang code sa ibaba ay isang halimbawa ng paggamit ng strip() method .

String s = "  flexiple ";

s = s.strip();

System.out.println(s);

4. Ano ang nagiging sanhi ng deadlock scenario? Sumulat ng code upang lumikha ng deadlock

Sagot: Ang isang deadlock scenario ay nangyayari kapag ang dalawang thread ay nangangailangan ng parehong mga lock upang maipatupad. Ang mga sitwasyong ito ay nangyayari kapag ang parehong mga thread ay nakakuha ng isang lock at naghihintay na makakuha ng isa pang lock. Gayunpaman, dahil ang parehong mga thread ay naghihintay para sa isa pa upang maipatupad, hinaharangan nila ang isa't isa, na nagiging sanhi ng isang deadlock. Ang mga multithreaded na programa ay dumaranas ng mga deadlock dahil ang naka-synchronize na keyword ay ginagamit upang gawing ligtas ang thread ng mga pamamaraan. Nangangahulugan ito na isang thread lamang ang maaaring mag-block at gumamit ng naka-synchronize na paraan. Dapat maghintay ang ibang mga thread para makumpleto ang kasalukuyang thread. Ang code sa ibaba ay lumilikha ng dalawang thread na deadlocked.

class Util
{
    static void sleep(long millis)
    {
        try
        {
            Thread.sleep(millis);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
class Shared
{
    synchronized void test1(Shared s2)
    {
        System.out.println("test1-begin");
        Util.sleep(1000);

        s2.test2();
        System.out.println("test1-end");
    }

    synchronized void test2()
    {
        System.out.println("test2-begin");
        Util.sleep(1000);

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

class Thread1 extends Thread
{
    private Shared s1;
    private Shared s2;

    public Thread1(Shared s1, Shared s2)
    {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public void run()
    {
        s1.test1(s2);
    }
}

class Thread2 extends Thread
{
    private Shared s1;
    private Shared s2;

    public Thread2(Shared s1, Shared s2)
    {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public void run()
    {
        s2.test2(s1);
    }
}

public class Deadlock
{
    public static void main(String[] args)
    {
        Shared s1 = new Shared();

        Shared s2 = new Shared();

        Thread1 t1 = new Thread1(s1, s2);
        t1.start();

        Thread2 t2 = new Thread2(s1, s2);
        t2.start();

        Util.sleep(2000);
    }
}

5. Sumulat ng Java Code upang I-print ang Petsa sa Tiyak na Format

Sagot: Ang klase ng SimpleDateFormat ay tumutulong sa pag-convert ng mga petsa mula sa isang format patungo sa isa pa. Binibigyang-daan din ng paraang ito ang mga user na gumamit ng format ng string ng petsa at baguhin ito sa nais na format. Kino-convert ng code sa ibaba ang petsa sa karaniwang format: DD/MM/YYYY

import java.text.SimpleDateFormat;
import java.util.Date;
public class CurrentDateTimeExample2 {
public static void main(String[] args) {
    SimpleDateFormat formatter = new SimpleDateFormat("DD/MM/YYYY HH:mm:ss");
    Date date = new Date();
    System.out.println(formatter.format(date));
}
}

Code snippet para i-convert ang petsa sa MM/DD/YYYY:

import java.text.SimpleDateFormat;
import java.util.Date;
public class CurrentDateTimeExample2 {
public static void main(String[] args) {
    SimpleDateFormat formatter = new SimpleDateFormat("MM/DD/YYYY HH:mm:ss");
    Date date = new Date();
    System.out.println(formatter.format(date));
}
}

6. Paano pag-uri-uriin ang isang HashMap ayon sa mga halaga nito?

Sagot: Ang HashMaps ay ginagamit upang ipatupad ang mga interface ng mapa. Nagbibigay-daan ang mga ito sa mga user na mag-imbak ng mga pares ng key-value, ngunit dapat na natatangi ang mga key. Ang HashMaps ay hindi inutusang mga koleksyon at ang pag-uuri ng mga ito ay walang katuturan, ngunit dahil ang pag-uuri ng mga hashmap ay maaaring medyo nakakalito, ang mga ito ay karaniwang tanong sa mga panayam sa Java. Ipinapakita ng code sa ibaba ang pagpapatupad ng HashMaps .

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class SortHashMap {

    public static void main(String[] args) {
        Map scores = new HashMap<>();

        scores.put("John", 6);
        scores.put("Carol", 8);
        scores.put("Martin", 9);
        scores.put("Mona", 7);
        scores.put("Eric", 5);

        System.out.println(scores);

        scores = sortByValue(scores);

        System.out.println(scores);

    }

    private static Map sortByValue(Map scores) {
        Map sorted = new LinkedHashMap<>();

        Set> entrySet = scores.entrySet();
        System.out.println(entrySet);

        List> entryList = new ArrayList<>(entrySet);
        System.out.println(entryList);

        entryList.sort((x, y) -> x.getValue().compareTo(y.getValue()));
        System.out.println(entryList);

        for (Entry e : entryList)
            sorted.put(e.getKey(), e.getValue());

        return sorted;
    }

}

7. Ano ang ginagawa ng paraang forEach()? Ipaliwanag gamit ang isang halimbawa

Ans: forEach() ay isang paraan na ginagamit upang umulit sa mga bagay sa Java. Ngunit hindi tulad ng iba pang mga loop, dito ang loop counter ay hindi ipinahayag o nasimulan, ngunit sa halip ang variable ay ipinasa bilang isang iterable. Samakatuwid, ang forEach() ay karaniwang ginagamit kasama ng mga array o mga klase ng koleksyon. Syntax:

for (type var : array)
{
    statements using var;
}

Halimbawa ng paggamit ng forEach() :

class ExampleForEach
{
    public static void main(String[] arg)
    {
        {
            int[] scores = { 10, 13, 9, 11, 11};

            int highest_score = maximum(scores);
            System.out.println(highest_scores);
        }
    }
    public static int maximum(int[] numbers)
    {
        int max = numbers[0];

        // for each loop
        for (int n : numbers)
        {
            if (n > max)
            {
                max = n;
            }
        }
    return max;
    }
}

8. Ano ang mga functional na interface at paano ito nilikha?

Sagot: Ang isang interface na naglalaman lamang ng isang abstract na pamamaraan ay tinatawag na isang functional na interface. Kasunod nito, ang mga functional na interface ay maaari lamang magkaroon ng isang function, gayunpaman maaari silang maglaman ng maramihang mga default na pamamaraan. Sa Java 8, ang mga expression ng lambda ay maaaring gamitin upang i-instantiate ang mga functional na interface, na ginagawang mas madali ang mga bagay. Mga halimbawa ng mga functional na interface: ActionListener , Comparable . Narito ang code na ginamit upang tukuyin ang functional na interface.

@FunctionalInterface
interface Foo {
    void test();
}

9. Ilarawan ang Overloading na may isang halimbawa

Sagot: Ang overloading ay ang proseso ng paglutas ng maraming pamamaraan na may parehong pangalan ngunit magkakaiba depende sa kanilang mga lagda, uri ng data o bilang ng mga parameter. Ang overloading ay nagbibigay-daan sa user na muling gumamit ng isang paraan sa halip na gumawa at mag-alala ng maraming pamamaraan. Sa madaling sabi, ang overloading ay nauugnay sa compile-time polymorphism. Halimbawang paraan ng overload code:

public class Sum {

    public int sum(int x, int y)
    {
        return (x + y);
    }

    public int sum(int x, int y, int z)
    {
        return (x + y + z);
    }

    public double sum(double x, double y)
    {
        return (x + y);
    }

    public static void main(String args[])
    {
        Sum s = new Sum();
        System.out.println(s.sum(10, 20));
        System.out.println(s.sum(10, 20, 30));
        System.out.println(s.sum(10.5, 20.5));
    }
}

10. Ilarawan ang Overriding na may isang halimbawa

Sagot: Ang overriding ay isang feature sa Java na nagbibigay-daan sa mga subclass o child class na magbigay ng hiwalay na pagpapatupad para sa isang umiiral na paraan sa parent class. Kapag ang isang pamamaraan sa isang subclass ay may parehong pangalan, parameter, at uri ng pagbabalik bilang parent class, ang pamamaraan ay na-override ang pamamaraan sa parent na klase. At ang bersyon ng pamamaraan na tinatawag ay tumutukoy kung aling paraan ang isasagawa. Ang overriding ay isang paraan upang makamit ang polymorphism sa runtime. Halimbawa ng override code ng pamamaraan:

class Parent {
    void show()
    {
        System.out.println("Parent's show()");
    }
}

class Child extends Parent {
    @Override
    void show()
    {
        System.out.println("Child's show()");
    }
}

class Main {
    public static void main(String[] args)
    {
        Parent obj1 = new Parent();
        obj1.show();

        Parent obj2 = new Child();
        obj2.show();
    }
}

11. Ano ang binary search? Paano ito ipinatupad?

Sagot: Ginagamit ang binary search algorithm upang maghanap ng value sa isang pinagsunod-sunod na array o uri ng koleksyon. Ang paraan ng paghahanap na ito ay makabuluhang mas mabilis kaysa sa mga linear na paraan ng paghahanap. Hinahati ng binary search ang array sa mas maliliit na hanay at pagkatapos ay inilalapat ang mga panuntunan upang suriin ang input key. Mga yugto ng pagpapatupad ng binary (binary) na paghahanap:

• Pagbukud-bukurin ang array sa pataas na pagkakasunud-sunod.
• Hanapin ang average na halaga ng array at ihambing ito sa key.
• Kung ang susi ay katumbas ng mean, ibalik ang totoo.
• Kung mali, tingnan kung mas malaki o mas mababa ang key kaysa sa average na halaga.
• Susunod, batay sa resulta, suriin ang susi sa itaas o mas mababang kalahati, ayon sa pagkakabanggit.
• Ulitin at ihambing ang bawat halaga sa susi.

Code snippet na nagpapatupad ng binary search:

import java.util.Scanner;

public class BinarySearch {

    public static void main(String[] args) {

        Scanner commandReader = new Scanner(System.in);
        System.out.println("Enter total number of elements : ");
        int length = commandReader.nextInt();
        int[] input = new int[length];

        System.out.printf("Enter %d integers %n", length);
        for (int i = 0; i < length; i++) {
            input[i] = commandReader.nextInt();
        }

        System.out.println("Please enter number to be searched in array
                                    (sorted order)");
        int key = commandReader.nextInt();

        int index = performBinarySearch(input, key);

        if (index == -1) {
            System.out.printf("Sorry, %d is not found in array %n", key);
        } else {
            System.out.printf("%d is found in array at index %d %n", key,
                                                         index);
        }

        commandReader.close();

    }


    public static int performBinarySearch(int[] input, int number) {
        int low = 0;
        int high = input.length - 1;

        while (high >= low) {
            int middle = (low + high) / 2;
            if (input[middle] == number) {
                return middle;
            } else if (input[middle] < number) {
                low = middle + 1;
            } else if (input[middle] > number) {
                high = middle - 1;
            }
        }
        return -1;
    }

}

12. Ano ang mga pinakamahusay na paraan upang maiwasan ang mga deadlock sa Java?

Sagot:

• Mga Nesting Lock: Ang pangunahing sanhi ng mga deadlock ay kapag ang mga lock ay ipinapasa sa maraming mga thread. Ang pag-iwas sa pagharang ng maramihang mga thread kung sakaling ang isang thread na may block ay maaaring makatulong na maiwasan ang mga deadlock.
• Paggamit ng Thread.join() : Ang mga deadlock ay maaari ding mangyari kapag ang isang thread ay naghihintay ng isang mapagkukunan mula sa isa pang thread. Gayunpaman, sa ganitong mga kaso, ang Thread.join() ay maaaring gamitin sa maximum na oras ng pagpapatupad.
• Paggamit lamang ng pag-lock kung kinakailangan: Magsanay sa paggamit ng mga kandado lamang sa mga elemento kung kinakailangan. Ang mga hindi kinakailangang kandado ang pangunahing sanhi ng mga deadlock.

13. Sumulat ng code upang ipatupad ang LRU caching sa Java

Sagot: Ang LRU ay nangangahulugang Least Used Cache. Ang LRU caching scheme ay ginagamit upang alisin ang huling ginamit na cache. Ang prosesong ito ay nangyayari kapag ang kasalukuyang cache ay puno na at ang bagong pahinang tinutukoy ay wala sa kasalukuyang cache. Ang code sa ibaba ay nagpapakita ng pagpapatupad:

import java.util.Deque;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Iterator;

public class LRUCache {

    private Deque doublyQueue;

    private HashSet hashSet;

    private final int CACHE_SIZE;

    LRUCache(int capacity) {
        doublyQueue = new LinkedList<>();
        hashSet = new HashSet<>();
        CACHE_SIZE = capacity;
    }

    public void refer(int page) {
        if (!hashSet.contains(page)) {
            if (doublyQueue.size() == CACHE_SIZE) {
                int last = doublyQueue.removeLast();
                hashSet.remove(last);
            }
        }
        else {/* The found page may not be always the last element, even if it's an
            intermediate element that needs to be removed and added to the start
            of the Queue */
            doublyQueue.remove(page);
        }
        doublyQueue.push(page);
        hashSet.add(page);
    }

    public void display() {
        Iterator itr = doublyQueue.iterator();
        while (itr.hasNext()) {
            System.out.print(itr.next() + " ");
        }
    }

    public static void main(String[] args) {
        LRUCache cache = new LRUCache(4);
        cache.refer(1);
        cache.refer(2);
        cache.refer(3);
        cache.refer(1);
        cache.refer(4);
        cache.refer(5);
        cache.refer(2);
        cache.refer(2);
        cache.refer(1);
        cache.display();
    }
}

14. Paano iniikot ang array depende sa posisyon ng K, halimbawa k = 2?

Sagot: Ang fragment ng code ay umiikot (ibabalik) ang array depende sa tinukoy na posisyon. Bagama't tila simple, sinusubok nito ang iyong pag-unawa sa mga loop at arrays at samakatuwid ay isang karaniwang tanong sa mga panayam sa Java.

public static int[] rotateBruteForce(int[] nums, int k) {
 for (int i = 0; i < k; i++) {
 for (int j = nums.length - 1; j > 0; j--) {
 // move each number by 1 place
 int temp = nums[j];
 nums[j] = nums[j - 1];
 nums[j - 1] = temp;
 }
 System.out.println("Array rotation after "+(i+1)+" step");
 printArray(nums);
 System.out.println();
 }
 return nums;
 }

15. Ano ang Queues sa Java? Ipatupad ang mga ito gamit ang mga array.

Sagot: Ang mga queue ay mga linear na istruktura na nagpapakita ng pagkakasunud-sunod ng mga operasyon sa isang first-come, first-serve na paraan. Nagbibigay ang Java ng mas simpleng pagpapatupad para sa mga abstract na uri ng data tulad ng mga pila, stack, at iba pa. Gayunpaman, ang pagpapatupad ng mga ito gamit ang isang array ay isang tanong na sumusubok sa iyong pag-unawa sa konsepto. Tandaan na ang pagpapatupad ng array ng isang queue ay hindi dynamic.

package org.arpit.java2blog;

public class QueueUsingArrayMain {

    private int capacity;
    int queueArr[];
    int front;
    int rear;
    int currentSize = 0;

    public QueueUsingArrayMain(int sizeOfQueue) {
        this.capacity = sizeOfQueue;
        front = 0;
        rear = -1;
        queueArr = new int[this.capacity];
    }

16. Ano ang HeapSort? Sumulat ng code upang ipatupad ito

Sagot: Ang HeapSort ay isang paraan ng pag-uuri batay sa binary heap na istraktura ng data. Ang binary heap ay isang binary tree kung saan ang mga elemento ay iniimbak sa paraang ang mga halaga sa parent node ay maaaring mas malaki (max-heap) o mas kaunti (min-heap) kaysa sa mga value sa child node. Ang code para ipatupad ang HeapSort ay ganito:

public class HeapSort {
    public void sort(int arr[])
    {
        int n = arr.length;

        // Build heap (rearrange array)
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);

        // One by one extract an element from heap
        for (int i = n - 1; i > 0; i--) {
            // Move current root to end
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // call max heapify on the reduced heap
            heapify(arr, i, 0);
        }
    }

    // To heapify a subtree rooted with node i which is
    // an index in arr[]. n is size of heap
    void heapify(int arr[], int n, int i)
    {
        int largest = i; // Initialize largest as root
        int l = 2 * i + 1; // left = 2*i + 1
        int r = 2 * i + 2; // right = 2*i + 2

        // If left child is larger than root
        if (l < n && arr[l] > arr[largest])
            largest = l;

        // If right child is larger than largest so far
        if (r < n && arr[r] > arr[largest])
            largest = r;

        // If largest is not root
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            // Recursively heapify the affected sub-tree
            heapify(arr, n, largest);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i = 0; i < n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 12, 11, 13, 5, 6, 7 };
        int n = arr.length;

        HeapSort ob = new HeapSort();
        ob.sort(arr);

        System.out.println("Sorted array is");
        printArray(arr);
    }
}

17. Ano ang Memoization?

Sagot: Ang memoization ay isang diskarte na tumutulong sa paglutas ng mga problema na dulot ng dynamic na programming. Tinitiyak ng prosesong ito na ang isang ibinigay na pamamaraan ay hindi isasagawa nang higit sa isang beses para sa parehong data ng pag-input. Ang mga ibinalik na halaga ay iniimbak sa mga hash table o hash na mapa at muling ginagamit kung kinakailangan. Ang code sa ibaba ay isang halimbawa ng memoization sa Fibonacci sequence.

import java.io.*;

class GFG
{

// Fibonacci Series
// using Recursion
static int fib(int n)
{

    // Base case
    if (n <= 1)
        return n;

    // recursive calls
    return fib(n - 1) +
        fib(n - 2);
}

// Driver Code
public static void main (String[] args)
{
    int n = 6;
    System.out.println(fib(n));
}
}

18. Sumulat ng isang piraso ng code upang ipatupad ang pag-uuri ng bubble

Sagot: Ang code sa ibaba ay isang solusyon para sa bubble sort, na isa ring karaniwang tanong sa mga panayam sa Java.

public class BubbleSortExample {
    static void bubbleSort(int[] arr) {
        int n = arr.length;
        int temp = 0;
         for(int i=0; i < n; i++){
                 for(int j=1; j < (n-i); j++){
                          if(arr[j-1] > arr[j]){
                                 //swap elements
                                 temp = arr[j-1];
                                 arr[j-1] = arr[j];
                                 arr[j] = temp;
                         }
                 }
         }
    }
    public static void main(String[] args) {
                int arr[] ={3,60,35,2,45,320,5};
                System.out.println("Array Before Bubble Sort");
                for(int i=0; i < arr.length; i++){
                        System.out.print(arr[i] + " ");
                }
                System.out.println();
                bubbleSort(arr);//sorting array elements using bubble sort
                System.out.println("Array After Bubble Sort");
                for(int i=0; i < arr.length; i++){
                        System.out.print(arr[i] + " ");
                }

        }
}

19. Ano ang mga istruktura ng data ng pagsubok sa Java?

Sagot: Ang Trie ay isang istraktura ng data na nag-iimbak ng data sa isang nakaayos na istraktura ng puno gamit ang mga key ng storage. Tinutukoy ng posisyon ng isang node sa puno ang susi na nauugnay sa node, at ang mga inapo ng node ay may karaniwang prefix. Salamat sa istrukturang ito, nag-aalok ang mga pagsubok ng mas mahusay na pagganap at mas mabilis ding kumukuha ng data. Gayunpaman, ang tanging downside sa paggamit ng kahoy ay nangangailangan ito ng mas maraming espasyo sa imbakan.

20. Sumulat ng code snippet para i-convert ang HashMap sa ArrayList

Sagot: Ang code sa ibaba ay ginagamit upang i-convert ang HashMap sa ArrayList .

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Java8MapToListExamples
{
    public static void main(String[] args)
    {
        //Creating a HashMap object

        HashMap studentPerformanceMap = new HashMap();

        //Adding elements to HashMap

        studentPerformanceMap.put("John Kevin", "Average");

        studentPerformanceMap.put("Rakesh Sharma", "Good");

        studentPerformanceMap.put("Prachi D", "Very Good");

        studentPerformanceMap.put("Ivan Jose", "Very Bad");

        studentPerformanceMap.put("Smith Jacob", "Very Good");

        studentPerformanceMap.put("Anjali N", "Bad");

        //Getting Set of keys

        Set keySet = studentPerformanceMap.keySet();

        //Creating an ArrayList of keys

        ArrayList listOfKeys = new ArrayList(keySet);

        System.out.println("ArrayList Of Keys :");

        for (String key : listOfKeys)
        {
            System.out.println(key);
        }

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

        //Getting Collection of values

        Collection values = studentPerformanceMap.values();

        //Creating an ArrayList of values

        ArrayList listOfValues = new ArrayList(values);

        System.out.println("ArrayList Of Values :");

        for (String value : listOfValues)
        {
            System.out.println(value);
        }

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

        //Getting the Set of entries

        Set> entrySet = studentPerformanceMap.entrySet();

        //Creating an ArrayList Of Entry objects

        ArrayList> listOfEntry = new ArrayList>(entrySet);

        System.out.println("ArrayList of Key-Values :");

        for (Entry entry : listOfEntry)
        {
            System.out.println(entry.getKey()+" : "+entry.getValue());
        }
    }
}