Java Programming

Java is a multi-platform, object-oriented, and network-centric language used for everything from mobile apps to enterprise software.

PROGRAMS

ODD OR EVEN

Check whether a given number is odd or even.

PRIME NUMBER

Check if a number is prime.

FACTORIAL

Calculate the factorial of a number using recursion.

PALINDROME

Check if a number is a palindrome.

SUM OF N NATURAL NUMBERS

Find the sum of the first N natural numbers.

FIBONACCI SERIES

Generate the Fibonacci series using recursion.

REVERSE A NUMBER

Reverse the digits of an integer.

GCD OF TWO NUMBERS

Find the Greatest Common Divisor (GCD) of two numbers.

ARMSTRONG NUMBER

Check if a number is an Armstrong number.

LINEAR SEARCH

Implement the linear search algorithm.

BINARY SEARCH

Implement the binary search algorithm.

BUBBLE SORT

Sort an array using Bubble Sort.

MERGE SORT

Sort an array using Merge Sort.

INSERTION SORT

Sort an array using Insertion Sort.

QUICK SORT

Sort an array using Quick Sort.

SELECTION SORT

Sort an array using Selection Sort.

HEAP SORT

Sort an array using Heap Sort.

STACK

Implement a basic stack using Java's Collection Framework.

QUEUE

Implement a priority queue using Java's Collection Framework.

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = reader.nextInt();
        if (num % 2 == 0) {
            System.out.println(num + " is even");
        } else {
            System.out.println(num + " is odd");
        }
    }
}

public class Prime {
    public static void main(String args[]) {
        int i, m = 0, flag = 0;
        int n = 17; // The number to check
        m = n / 2;
        if (n == 0 || n == 1) {
            System.out.println(n + " is not a prime number");
        } else {
            for (i = 2; i <= m; i++) {
                if (n % i == 0) {
                    System.out.println(n + " is not a prime number");
                    flag = 1;
                    break;
                }
            }
            if (flag == 0) {
                System.out.println(n + " is a prime number");
            }
        }
    }
}

class Factorial {
    static int factorial(int n) {
        if (n == 0)
            return 1;
        else
            return (n * factorial(n - 1));
    }
    public static void main(String args[]) {
        int number = 5;
        int fact = factorial(number);
        System.out.println("Factorial of " + number + " is: " + fact);
    }
}

class Palindrome {
    public static void main(String args[]) {
        int r, sum = 0, temp;
        int n = 454; // Number to check
        temp = n;
        while (n > 0) {
            r = n % 10;
            sum = (sum * 10) + r;
            n = n / 10;
        }
        if (temp == sum)
            System.out.println("It is a palindrome number");
        else
            System.out.println("It is not a palindrome");
    }
}

public class SumOfNaturalNumber {
    public static void main(String[] args) {
        int i, num = 10, sum = 0;
        for (i = 1; i <= num; ++i) {
            sum = sum + i;
        }
        System.out.println("Sum of First " + num + " Natural Numbers is = " + sum);
    }
}

class Fibonacci {
    static int n1 = 0, n2 = 1, n3 = 0;
    static void printFibonacci(int count) {
        if (count > 0) {
            n3 = n1 + n2;
            n1 = n2;
            n2 = n3;
            System.out.print(" " + n3);
            printFibonacci(count - 1);
        }
    }
    public static void main(String args[]) {
        int count = 10;
        System.out.print(n1 + " " + n2); // printing 0 and 1
        printFibonacci(count - 2); // n-2 because 2 numbers are already printed
    }
}

public class ReverseNumber {
    public static void main(String[] args) {
        int number = 987654, reverse = 0;
        while (number != 0) {
            int remainder = number % 10;
            reverse = reverse * 10 + remainder;
            number = number / 10;
        }
        System.out.println("The reverse of the given number is: " + reverse);
    }
}

public class FindGCD {
    public static void main(String[] args) {
        int num1 = 12, num2 = 8, gcd = 1;
        for(int i = 1; i <= num1 && i <= num2; ++i) {
            // Checks if i is a factor of both integers
            if(num1 % i == 0 && num2 % i == 0)
                gcd = i;
        }
        System.out.println("GCD = " + gcd);
    }
}

public class ArmstrongNumber {
    static boolean isArmstrong(int n) {
        int temp, digits = 0, last = 0, sum = 0;
        temp = n;
        while (temp > 0) {
            temp = temp / 10;
            digits++;
        }
        temp = n;
        while (temp > 0) {
            last = temp % 10;
            sum += (Math.pow(last, digits));
            temp = temp / 10;
        }
        return n == sum;
    }
    public static void main(String args[]) {
        int num = 153;
        if (isArmstrong(num)) {
            System.out.print("Armstrong");
        } else {
            System.out.print("Not Armstrong");
        }
    }
}

public class LinearSearch {
    public static int linearSearch(int[] arr, int key) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == key) {
                return i;
            }
        }
        return -1;
    }
    public static void main(String a[]) {
        int[] a1 = { 10, 20, 30, 50, 70, 90 };
        int key = 50;
        System.out.println(key + " is found at index: " + linearSearch(a1, key));
    }
}

class BinarySearch {
    public static void binarySearch(int arr[], int first, int last, int key) {
        int mid = (first + last) / 2;
        while (first <= last) {
            if (arr[mid] < key) {
                first = mid + 1;
            } else if (arr[mid] == key) {
                System.out.println("Element is found at index: " + mid);
                break;
            } else {
                last = mid - 1;
            }
            mid = (first + last) / 2;
        }
        if (first > last) {
            System.out.println("Element is not found!");
        }
    }
    public static void main(String args[]) {
        int arr[] = { 10, 20, 30, 40, 50 };
        int key = 30;
        int last = arr.length - 1;
        binarySearch(arr, 0, last, key);
    }
}

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]) {
                    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 };
        bubbleSort(arr);
        System.out.println("Array After Bubble Sort");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

class MergeSort {
    void merge(int arr[], int l, int m, int r) {
        int n1 = m - l + 1;
        int n2 = r - m;
        int L[] = new int[n1];
        int R[] = new int[n2];
        for (int i = 0; i < n1; ++i) L[i] = arr[l + i];
        for (int j = 0; j < n2; ++j) R[j] = arr[m + 1 + j];
        int i = 0, j = 0;
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    void sort(int arr[], int l, int r) {
        if (l < r) {
            int m = (l + r) / 2;
            sort(arr, l, m);
            sort(arr, m + 1, r);
            merge(arr, l, m, r);
        }
    }
}

public class InsertionSort {
    public static void insertionSort(int array[]) {
        int n = array.length;
        for (int j = 1; j < n; j++) {
            int key = array[j];
            int i = j - 1;
            while ((i > -1) && (array[i] > key)) {
                array[i + 1] = array[i];
                i--;
            }
            array[i + 1] = key;
        }
    }
    public static void main(String a[]) {
        int[] arr1 = { 9, 14, 3, 2, 43, 11, 58, 22 };
        insertionSort(arr1);
        System.out.println("After Insertion Sort");
        for (int i : arr1) {
            System.out.print(i + " ");
        }
    }
}

public class QuickSort {
    int partition(int a[], int start, int end) {
        int pivot = a[end];
        int i = (start - 1);
        for (int j = start; j <= end - 1; j++) {
            if (a[j] < pivot) {
                i++;
                int t = a[i]; a[i] = a[j]; a[j] = t;
            }
        }
        int t = a[i + 1]; a[i + 1] = a[end]; a[end] = t;
        return (i + 1);
    }
    void quick(int a[], int start, int end) {
        if (start < end) {
            int p = partition(a, start, end);
            quick(a, start, p - 1);
            quick(a, p + 1, end);
        }
    }
}

public class SelectionSortExample {
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            int smallerNumber = arr[index];
            arr[index] = arr[i];
            arr[i] = smallerNumber;
        }
    }
    public static void main(String a[]) {
        int[] arr1 = { 9, 14, 3, 2, 43, 11, 58, 22 };
        selectionSort(arr1);
        System.out.println("After Selection Sort");
        for (int i : arr1) {
            System.out.print(i + " ");
        }
    }
}

public class HeapSort {
    public void sort(int arr[]) {
        int n = arr.length;
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);
        for (int i = n - 1; i >= 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapify(arr, i, 0);
        }
    }
    void heapify(int arr[], int n, int i) {
        int largest = i;
        int l = 2 * i + 1;
        int r = 2 * i + 2;
        if (l < n && arr[l] > arr[largest]) largest = l;
        if (r < n && arr[r] > arr[largest]) largest = r;
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }
}

import java.util.*;
public class StackDemo {
    public static void main(String args[]) {
        Stack st = new Stack<>();
        st.push(42);
        st.push(66);
        st.push(99);
        System.out.println("Stack: " + st);
        System.out.println("Popped: " + st.pop());
        System.out.println("Stack after pop: " + st);
    }
}

import java.util.*;
class QueueExample {
    public static void main(String args[]) {
        PriorityQueue queue = new PriorityQueue<>();
        queue.add("Amit");
        queue.add("Vijay");
        queue.add("Karan");
        System.out.println("Head of the queue: " + queue.peek());
        System.out.println("Removing: " + queue.poll());
        System.out.println("Queue after removal: " + queue);
    }
}