Classloader is a subsystem of JVM which is used to load class files. Whenever we run the java program, it is loaded first by the classloader. There are three built-in classloaders in Java.

1. Bootstrap ClassLoader: This is the first classloader which is the superclass of Extension classloader. It loads the rt.jar file which contains all class files of Java Standard Edition like java.lang package classes, java.net package classes, java.util package classes, java.io package classes, java.sql package classes, etc.
2. Extension ClassLoader: This is the child classloader of Bootstrap and parent classloader of System classloader. It loads the jar files located inside $JAVA_HOME/jre/lib/ext directory.
3. System/Application ClassLoader: This is the child classloader of Extension classloader. It loads the class files from the classpath. By default, the classpath is set to the current directory. You can change the classpath using "-cp" or "-classpath" switch. It is also known as Application classloader.

Intermediate Operations: 

• Process the stream elements.
• Typically transforms a stream into another stream.
• Are lazy, i.e., not executed till a terminal operation is invoked.
• Does internal iteration of all source elements.
• Any number of operations can be chained in the processing pipeline.
• Operations are applied as per the defined order.
• Intermediate operations are mostly lambda functions.

Terminal Operations:

• Kick-starts the Stream pipeline.
• used to collect the processed Stream data.

Example 

int count = Stream.of(1, 2, 3, 4, 5)

.filter(i -> i <4) // Intermediate Operation filter

.count(); // Terminal Operation count

Quick Sort Algorithm

Pseudo Code for recursive QuickSort function : 

/* low  --> Starting index,  high  --> Ending index */

quickSort(arr[], low, high)

{

    if (low < high)

    {

        /* pi is partitioning index, arr[pi] is now

           at right place */

        pi = partition(arr, low, high);

        quickSort(arr, low, pi - 1);  // Before pi

        quickSort(arr, pi + 1, high); // After pi

    }

}

Partition Algorithm 

There can be many ways to do partition, following pseudo code adopts the method given in CLRS book. The logic is simple, we start from the leftmost element and keep track of index of smaller (or equal to) elements as i. While traversing, if we find a smaller element, we swap current element with arr[i]. Otherwise we ignore current element. 

/* low  --> Starting index,  high  --> Ending index */

quickSort(arr[], low, high)

{

    if (low < high)

    {

        /* pi is partitioning index, arr[pi] is now

           at right place */

        pi = partition(arr, low, high);

        quickSort(arr, low, pi - 1);  // Before pi

        quickSort(arr, pi + 1, high); // After pi

    }

}

Pseudo code for partition()  

/* This function takes last element as pivot, places

   the pivot element at its correct position in sorted

    array, and places all smaller (smaller than pivot)

   to left of pivot and all greater elements to right

   of pivot */

partition (arr[], low, high)

{

    // pivot (Element to be placed at right position)

    pivot = arr[high];  

 

    i = (low - 1)  // Index of smaller element and indicates the 

                   // right position of pivot found so far

    for (j = low; j <= high- 1; j++)

    {

        // If current element is smaller than the pivot

        if (arr[j] < pivot)

        {

            i++;    // increment index of smaller element

            swap arr[i] and arr[j]

        }

    }

    swap arr[i + 1] and arr[high])

    return (i + 1)

}

Illustration of partition() : 

arr[] = {10, 80, 30, 90, 40, 50, 70}

Indexes:  0   1   2   3   4   5   6 

low = 0, high =  6, pivot = arr[h] = 70

Initialize index of smaller element, i = -1

Traverse elements from j = low to high-1

j = 0 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])

i = 0 

arr[] = {10, 80, 30, 90, 40, 50, 70} // No change as i and j 

                                     // are same

j = 1 : Since arr[j] > pivot, do nothing

// No change in i and arr[]

j = 2 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])

i = 1

arr[] = {10, 30, 80, 90, 40, 50, 70} // We swap 80 and 30 

j = 3 : Since arr[j] > pivot, do nothing

// No change in i and arr[]

j = 4 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])

i = 2

arr[] = {10, 30, 40, 90, 80, 50, 70} // 80 and 40 Swapped

j = 5 : Since arr[j] <= pivot, do i++ and swap arr[i] with arr[j] 

i = 3 

arr[] = {10, 30, 40, 50, 80, 90, 70} // 90 and 50 Swapped 

We come out of loop because j is now equal to high-1.

Finally we place pivot at correct position by swapping

arr[i+1] and arr[high] (or pivot) 

arr[] = {10, 30, 40, 50, 70, 90, 80} // 80 and 70 Swapped 

Now 70 is at its correct place. All elements smaller than

70 are before it and all elements greater than 70 are after it.

Source Code:-

 Daily Java Tips Follow Click here👉👉👉  d_programming_ 👈👈👈Official Instagram

package main.algorithm;

// Java implementation of QuickSort
import java.io.*;

class QuickSort{

    // A function to swap two elements
   public static void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /* This function takes last element as pivot, places
    the pivot element at its correct position in sorted
    array, and places all smaller (smaller than pivot)
    to left of pivot and all greater elements to right
    of pivot */
    static int partition(int[] arr, int low, int high)
    {

        // pivot variable
        int pivot = arr[high];

        // Index of smaller element and
        // indicates the right position
        // of pivot found so far
        int i = (low - 1);

        for(int j = low; j <= high - 1; j++)
        {

            // If current element is smaller
            // than the pivot
            if (arr[j] < pivot)
            {

                // Increment index of
                // smaller element
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, high);
        return (i + 1);
    }

    /* The main function that implements QuickSort
            arr[] --> Array to be sorted,
            low --> Starting index,
            high --> Ending index
    */
    static void quickSort(int[] arr, int low, int high)
    {
        if (low < high)
        {

            // pi is partitioning index, arr[p]
            // is now at right place
            int pi = partition(arr, low, high);

            // Separately sort elements before
            // partition and after partition
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    // Function to print an array
    static void printArray(int[] arr, int size)
    {
        for(int i = 0; i < size; i++)
            System.out.print(arr[i] + " ");

        System.out.println();
    }

    // Main Code
    public static void main(String[] args)
    {
        int[] arr = { 10, 7, 8, 9, 1, 5 };
        int n = arr.length;

        quickSort(arr, 0, n - 1);
        System.out.println("Sorted array: ");
        printArray(arr, n);
    }
}

// This code is contributed by d programming

Output: Sorted array is
3 7 8 16 18 27

 Heap Sort Algorithm in Java

package main.algorithm;

public class HeapSort {
    public static 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
    static 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();
    }

    // Main Method
    public static void main(String args[])
    {
        int arr[] = { 8, 3, 18, 27, 16, 7 };
        int n = arr.length;
         sort(arr);

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

Output: Sorted array is
3 7 8 16 18 27

 Jump Search Algorithm in JAVA

For example, suppose we have an array arr[] of size n and block (to be jumped) size m. Then we search at the indexes arr[0], arr[m], arr[2m]…..arr[km] and so on. Once we find the interval (arr[km] < x < arr[(k+1)m]), we perform a linear search operation from the index km to find the element x.

Let’s consider the following array: (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610,712). Length of the array is 16. Jump search will find the value of 55 with the following steps assuming that the block size to be jumped is 4. 

STEP 1: Jump from index 0 to index 4; 

STEP 2: Jump from index 4 to index 8; 

STEP 3: Jump from index 8 to index 12; 

STEP 4: Since the element at index 12 is greater than 55 we will jump back a step to come to index 8. 

STEP 5: Perform linear search from index 8 to get the element 55.

What is the optimal block size to be skipped? 

In the worst case, we have to do n/m jumps and if the last checked value is greater than the element to be searched for, we perform m-1 comparisons more for linear search. Therefore the total number of comparisons in the worst case will be ((n/m) + m-1). The value of the function ((n/m) + m-1) will be minimum when m = √n. Therefore, the best step size is m = √n.

Source Code:-

package main.algorithm;

public class JumpSearch {
    public static int jumpSearch(int[] arr, int x) {
        int n = arr.length;

        // Finding block size to be jumped
        int step = (int) Math.floor(Math.sqrt(n));

        // Finding the block where element is
        // present (if it is present)
        int prev = 0;
        while (arr[Math.min(step, n) - 1] < x) {
            prev = step;
            step += (int) Math.floor(Math.sqrt(n));
            if (prev >= n)
                return -1;
        }

        // Doing a linear search for x in block
        // beginning with prev.
        while (arr[prev] < x) {
            prev++;

            // If we reached next block or end of
            // array, element is not present.
            if (prev == Math.min(step, n))
                return -1;
        }

        // If element is found
        if (arr[prev] == x)
            return prev;

        return -1;
    }

    // Main program to test function
    public static void main(String[] args) {
        int arr[] = {0, 1, 1, 2, 3, 5, 8, 13, 21,
                34, 55, 89, 144, 233, 377, 610, 712};
        int x = 55;
        // Find the index of 'x' using Jump Search
        int index = jumpSearch(arr, x);
        // Print the index where 'x' is located
        System.out.println("\nNumber " + x + " is at index " + index);
    }
}

Output: Number 55 is at index 10

 Binary Search Algorithm in Java

Source Code:-

package main.algorithm;


class BinarySearch {
    // Returns index of x if it is present in arr[l..
    // r], else return -1
    public static int binarySearch(int arr[], int l, int r, int x)
    {
        if (r >= l) {
            int mid = l + (r - l) / 2;

            // If the element is present at the
            // middle itself
            if (arr[mid] == x)
                return mid;

            // If element is smaller than mid, then
            // it can only be present in left subarray
            if (arr[mid] > x)
                return binarySearch(arr, l, mid - 1, x);

            // Else the element can only be present
            // in right subarray
            return binarySearch(arr, mid + 1, r, x);
        }

        // We reach here when element is not present
        // in array
        return -1;
    }

    // Main method to test above
    public static void main(String args[])
    {
        int arr[] = { 2, 3, 4, 10, 40 };
        int n = arr.length;
        int x = 10;
        int result = binarySearch(arr, 0, n - 1, x);
        if (result == -1)
            System.out.println("Element not present");
        else
            System.out.println("Element found at index " + result);
    }
}
/* This code is contributed by D Programming */

Output: Element found at index 3

Linear Search Algorithm in Java

A simple approach is to do a linear search.

• Start from the leftmost element of arr[] and one by one compare x with each element of arr[]

• If x matches with an element, return the index.

• If x doesn’t match with any of elements, return -1.

Source Code:-

// Java code for linearly searching x in arr[]. If x
// is present then return its location, otherwise
// return -1

class LinearSearch
{
    public static int search(int arr[], int x)
    {
        int n = arr.length;
        for (int i = 0; i < n; i++)
        {
            if (arr[i] == x)
                return i;
        }
        return -1;
    }
    public static void main(String args[])
    {
        int arr[] = { 2, 3, 4, 10, 40 };
        int x = 10;

        // Function call
        int result = search(arr, x);
        if (result == -1) {
            System.out.print("Element is not present in array");
        } else{
            System.out.print("Element is present at index " + result);
        }
    }
}/* This code is contributed by D Programming */

Output: Element is present at index 3

Bubble Sort Algorithm 

package main;

public class BubbleSort {
    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[] ={55,88,54,277,45,320,99,3,77,11};

        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] + " ");
        }

    }
}

Output: Array Before Bubble Sort
55 88 54 277 45 320 99 3 77 11 
Array After Bubble Sort
3 11 45 54 55 77 88 99 277 320 

Removing Duplicate Values From List in JAVA8

Source Code 👇👇👇

package Learn;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

public class Main {
public static void main(String[] args) {
List<Integer> list=Arrays.asList(1,2,3,2,4,5,3,6,6,7);
HashSet<Integer> set=new HashSet<Integer>(list);
set.forEach(System.out::println);

}
}