Java Basics Programs - Learning with Nitheesh

Write a program to find the second largest element in an array.

Input

[12, 35, 1, 10, 34, 1]

Output

Second Largest: 34

public class SecondLargest {
    public static void main(String[] args) {
        int[] arr = {12, 35, 1, 10, 34, 1};
        int first = Integer.MIN_VALUE, second = Integer.MIN_VALUE;

        for (int num : arr) {
            if (num > first) {
                second = first;
                first = num;
            } else if (num > second && num != first) {
                second = num;
            }
        }

        System.out.println("Second Largest: " + second);
    }
}

Explanation:

Initialize first and second to the minimum integer value.
Traverse the array and update first and second accordingly.
Skip updating second if the current number equals the first.
Print the second largest number.

Write a program to check if the array is sorted in ascending order.

Input

[1, 2, 3, 4, 5]

Output

Yes, the array is sorted.

public class CheckSortedArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        boolean isSorted = true;

        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                isSorted = false;
                break;
            }
        }

        if (isSorted)
            System.out.println("Yes, the array is sorted.");
        else
            System.out.println("No, the array is not sorted.");
    }
}

Explanation:

Loop through the array and compare each element with the next.
If any element is greater than the next one, the array is not sorted.
Use a boolean flag to track if the array remains sorted.
Print the appropriate message based on the result.

Find the missing number in an array of size n containing numbers from 1 to n+1.

Input

[1, 2, 4, 5, 6]

Output

Missing Number: 3

public class FindMissingNumber {
    public static void main(String[] args) {
        int[] arr = {1, 2, 4, 5, 6};
        int n = arr.length + 1;
        int total = n * (n + 1) / 2;

        int sum = 0;
        for (int num : arr) {
            sum += num;
        }

        int missing = total - sum;
        System.out.println("Missing Number: " + missing);
    }
}

Explanation:

Calculate expected sum of numbers from 1 to n+1 using formula: n(n+1)/2.
Calculate actual sum of array elements.
Subtract actual sum from expected sum to find the missing number.

Write a program to remove duplicate elements from an array.

Input

[1, 2, 2, 3, 4, 4, 5]

Output

[1, 2, 3, 4, 5]

import java.util.*;

public class RemoveDuplicates {
    public static void main(String[] args) {
        int[] arr = {1, 2, 2, 3, 4, 4, 5};
        Set<Integer> set = new LinkedHashSet<>();

        for (int num : arr) {
            set.add(num);
        }

        System.out.println(set);
    }
}

Explanation:

Create a LinkedHashSet to preserve insertion order and eliminate duplicates.
Iterate through the array and add each element to the set.
Print the set which now contains only unique elements.

Write a program to reverse the elements of an array in-place.

Input

[1, 2, 3, 4, 5]

Output

[5, 4, 3, 2, 1]

import java.util.Arrays;

public class ReverseArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int start = 0, end = arr.length - 1;

        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }

        System.out.println(Arrays.toString(arr));
    }
}

Explanation:

Initialize two pointers, start at 0 and end at last index.
Swap elements at start and end until they meet.
This reverses the array in-place without using extra space.

Merge two sorted arrays into one sorted array.

Input

[1, 3, 5], [2, 4, 6]

Output

[1, 2, 3, 4, 5, 6]

import java.util.Arrays;

public class MergeSortedArrays {
    public static void main(String[] args) {
        int[] a = {1, 3, 5};
        int[] b = {2, 4, 6};
        int[] merged = new int[a.length + b.length];

        int i = 0, j = 0, k = 0;
        while (i < a.length && j < b.length) {
            if (a[i] <= b[j]) {
                merged[k++] = a[i++];
            } else {
                merged[k++] = b[j++];
            }
        }

        while (i < a.length) {
            merged[k++] = a[i++];
        }

        while (j < b.length) {
            merged[k++] = b[j++];
        }

        System.out.println(Arrays.toString(merged));
    }
}

Explanation:

Initialize three pointers for array A, B, and the merged array.
Compare elements and insert the smaller one into the merged array.
Copy any remaining elements from both arrays.
Print the merged array.

Count the number of even and odd elements in an array.

Input

[1, 2, 3, 4, 5]

Output

Even: 2, Odd: 3

public class CountEvenOdd {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int evenCount = 0, oddCount = 0;

        for (int num : arr) {
            if (num % 2 == 0) {
                evenCount++;
            } else {
                oddCount++;
            }
        }

        System.out.println("Even: " + evenCount + ", Odd: " + oddCount);
    }
}

Explanation:

Initialize counters for even and odd numbers.
Iterate through the array and use modulus operator to check parity.
Increment respective counters and print the result.

Find all pairs in the array whose sum equals a given number.

Input

Array: [1, 5, 7, -1], Sum = 6

Output

Pairs: (1, 5), (7, -1)

import java.util.HashMap;

public class PairSum {
    public static void main(String[] args) {
        int[] arr = {1, 5, 7, -1};
        int sum = 6;
        findPairs(arr, sum);
    }

    static void findPairs(int[] arr, int sum) {
        HashMap map = new HashMap<>();

        for (int num : arr) {
            int complement = sum - num;
            if (map.containsKey(complement)) {
                int count = map.get(complement);
                for (int i = 0; i < count; i++) {
                    System.out.println("Pair: (" + complement + ", " + num + ")");
                }
            }
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
    }
}

Explanation:

Use a hash map to track the count of each number.
For each element, calculate its complement (sum - element).
If the complement is found in the map, print the pair.
Update the count of the current element in the map.

Find the element that appears more than n/2 times.

Input

[3, 3, 4, 2, 3, 3, 5, 3]

Output

Majority Element: 3

public class MajorityElement {
    public static void main(String[] args) {
        int[] arr = {3, 3, 4, 2, 3, 3, 5, 3};
        int majority = findMajorityElement(arr);
        if (majority != -1) {
            System.out.println("Majority Element: " + majority);
        } else {
            System.out.println("No Majority Element");
        }
    }

    static int findMajorityElement(int[] arr) {
        int count = 0, candidate = -1;

        for (int num : arr) {
            if (count == 0) {
                candidate = num;
            }
            count += (num == candidate) ? 1 : -1;
        }

        // Verify the candidate
        count = 0;
        for (int num : arr) {
            if (num == candidate) {
                count++;
            }
        }

        return count > arr.length / 2 ? candidate : -1;
    }
}

Explanation:

Use Boyer-Moore majority vote algorithm to find a candidate.
Reset count and verify if the candidate occurs more than n/2 times.
If it does, return it as the majority element.

Rotate the array to the right by k steps.

Input

Array: [1, 2, 3, 4, 5, 6, 7], k = 3

Output

[5, 6, 7, 1, 2, 3, 4]

public class RotateArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        int k = 3;
        rotate(arr, k);

        System.out.print("Rotated Array: [");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i != arr.length - 1) System.out.print(", ");
        }
        System.out.println("]");
    }

    static void rotate(int[] arr, int k) {
        int n = arr.length;
        k = k % n; // handle if k > n

        reverse(arr, 0, n - 1);
        reverse(arr, 0, k - 1);
        reverse(arr, k, n - 1);
    }

    static void reverse(int[] arr, int start, int end) {
        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }
}

Explanation:

Use the reversal algorithm for array rotation.
Reverse the entire array.
Reverse the first k elements.
Reverse the remaining elements.

Count frequency of each element in an array.

Input

[10, 20, 20, 10, 10, 20, 5, 20]

Output

10: 3, 20: 4, 5: 1

import java.util.HashMap;
import java.util.Map;

public class CountFrequencies {
    public static void main(String[] args) {
        int[] arr = {10, 20, 20, 10, 10, 20, 5, 20};
        Map frequencyMap = new HashMap<>();

        for (int num : arr) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }

        System.out.print("Frequencies: ");
        for (Map.Entry entry : frequencyMap.entrySet()) {
            System.out.print(entry.getKey() + ": " + entry.getValue() + ", ");
        }
    }
}

Explanation:

Use a HashMap to store element frequencies.
Iterate through the array and update the counts.
Print each element and its frequency.

Find the k-th smallest element in an unsorted array.

Input

Array: [7, 10, 4, 3, 20, 15], k = 3

Output

Kth Smallest: 7

import java.util.Arrays;

public class KthSmallestElement {
    public static void main(String[] args) {
        int[] arr = {7, 10, 4, 3, 20, 15};
        int k = 3;

        Arrays.sort(arr);
        System.out.println("Kth Smallest: " + arr[k - 1]);
    }
}

Explanation:

Sort the array in ascending order using Arrays.sort().
Access the element at index k-1 as the kth smallest element.

Find all leaders in the array (element greater than all to its right).

Input

[16, 17, 4, 3, 5, 2]

Output

Leaders: 17, 5, 2

import java.util.ArrayList;
import java.util.Collections;

public class FindLeaders {
    public static void main(String[] args) {
        int[] arr = {16, 17, 4, 3, 5, 2};
        ArrayList leaders = new ArrayList<>();
        
        int maxFromRight = arr[arr.length - 1];
        leaders.add(maxFromRight);
        
        for (int i = arr.length - 2; i >= 0; i--) {
            if (arr[i] > maxFromRight) {
                maxFromRight = arr[i];
                leaders.add(maxFromRight);
            }
        }
        
        Collections.reverse(leaders);
        System.out.print("Leaders: ");
        for (int leader : leaders) {
            System.out.print(leader + ", ");
        }
    }
}

Explanation:

Start from the rightmost element, consider it as the current maximum.
Traverse the array from right to left.
If an element is greater than the current maximum, update the maximum and add it to the leaders list.
Reverse the list to display leaders in original order.

Find the first repeating element in an array.

Input

[1, 2, 3, 4, 5, 2, 1]

Output

First Repeating: 2

import java.util.HashSet;

public class FirstRepeatingElement {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 2, 1};
        HashSet seen = new HashSet<>();
        int firstRepeating = -1;
        
        for (int num : arr) {
            if (seen.contains(num)) {
                firstRepeating = num;
                break;
            }
            seen.add(num);
        }
        
        if (firstRepeating != -1) {
            System.out.println("First Repeating: " + firstRepeating);
        } else {
            System.out.println("No repeating elements found.");
        }
    }
}

Explanation:

Traverse the array and track seen elements using a HashSet.
If an element is already in the set, it's the first repeating element.
Print the element and stop further checks.

Find a continuous subarray that adds to a given sum.

Input

Array: [1, 4, 20, 3, 10, 5], Sum = 33

Output

Subarray: [20, 3, 10]

public class SubarrayWithGivenSum {
    public static void main(String[] args) {
        int[] arr = {1, 4, 20, 3, 10, 5};
        int sum = 33;
        
        int currentSum = arr[0], start = 0;
        boolean found = false;

        for (int i = 1; i <= arr.length; i++) {
            // Shrink the window as long as currentSum is greater than sum and start < i-1
            while (currentSum > sum && start < i - 1) {
                currentSum -= arr[start];
                start++;
            }
            // Check if currentSum equals sum
            if (currentSum == sum) {
                System.out.print("Subarray: [");
                for (int j = start; j < i; j++) {
                    System.out.print(arr[j]);
                    if (j < i - 1) System.out.print(", ");
                }
                System.out.println("]");
                found = true;
                break;
            }
            // Add next element if not reached end
            if (i < arr.length) {
                currentSum += arr[i];
            }
        }

        if (!found) {
            System.out.println("No subarray found with given sum.");
        }
    }
}

Explanation:

Use a sliding window approach with two pointers.
Expand window by adding elements to current sum.
Shrink window from the left if current sum exceeds target.
When current sum matches target, print the subarray.

Move all 0s to the end of array without changing the order of other elements.

Input

[0, 1, 0, 3, 12]

Output

[1, 3, 12, 0, 0]

public class MoveZerosToEnd {
    public static void main(String[] args) {
        int[] arr = {0, 1, 0, 3, 12};
        int count = 0; // Count of non-zero elements

        // Move all non-zero elements to the front
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != 0) {
                arr[count++] = arr[i];
            }
        }

        // Fill remaining positions with zero
        while (count < arr.length) {
            arr[count++] = 0;
        }

        // Print the modified array
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) System.out.print(", ");
        }
        System.out.println("]");
    }
}

Explanation:

Traverse array and move all non-zero elements to the front.
Fill the rest of the array with zeros.
This keeps the relative order of non-zero elements unchanged.

Find the union and intersection of two arrays.

Input

[1, 2, 4], [2, 4, 6]

Output

Union: [1, 2, 4, 6]
Intersection: [2, 4]

import java.util.*;

public class UnionIntersection {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 4};
        int[] arr2 = {2, 4, 6};

        Set unionSet = new LinkedHashSet<>();
        Set intersectionSet = new LinkedHashSet<>();

        // Add elements from first array to union set
        for (int num : arr1) {
            unionSet.add(num);
        }

        // For second array, add to union, and if present in first, add to intersection
        for (int num : arr2) {
            if (!unionSet.add(num)) { // add() returns false if already present
                intersectionSet.add(num);
            }
        }

        System.out.println("Union: " + unionSet);
        System.out.println("Intersection: " + intersectionSet);
    }
}

Explanation:

Use sets to avoid duplicates.
Add all elements of first array to union set.
Add elements of second array to union; if already present, add to intersection.
Print union and intersection sets.

Find the contiguous subarray within an array with the largest product.

Input

[2, 3, -2, 4]

Output

Max Product: 6

public class MaxProductSubarray {
    public static void main(String[] args) {
        int[] arr = {2, 3, -2, 4};
        
        int maxProduct = maxProductSubarray(arr);
        System.out.println("Max Product: " + maxProduct);
    }

    public static int maxProductSubarray(int[] nums) {
        int maxSoFar = nums[0];
        int minSoFar = nums[0];
        int result = nums[0];

        for (int i = 1; i < nums.length; i++) {
            int tempMax = maxSoFar;
            maxSoFar = Math.max(Math.max(nums[i], maxSoFar * nums[i]), minSoFar * nums[i]);
            minSoFar = Math.min(Math.min(nums[i], tempMax * nums[i]), minSoFar * nums[i]);
            result = Math.max(result, maxSoFar);
        }

        return result;
    }
}

Explanation:

Track maximum and minimum products up to current index (handle negative numbers).
At each step, update max and min considering the current element.
Keep updating the result with the maximum product found.

Replace every element with the greatest element on its right.

Input

[16, 17, 4, 3, 5, 2]

Output

[17, 5, 5, 5, 2, -1]

public class ReplaceWithGreatestOnRight {
    public static void main(String[] args) {
        int[] arr = {16, 17, 4, 3, 5, 2};
        replaceElements(arr);
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i != arr.length - 1) System.out.print(", ");
        }
        System.out.println("]");
    }

    public static void replaceElements(int[] arr) {
        int maxRight = -1;
        for (int i = arr.length - 1; i >= 0; i--) {
            int temp = arr[i];
            arr[i] = maxRight;
            if (temp > maxRight) {
                maxRight = temp;
            }
        }
    }
}

Explanation:

Traverse array from right to left.
Keep track of the maximum element to the right.
Replace current element with the max right value and update max if needed.

Write a program to find the maximum sum of a contiguous subarray.

Input

[-2, 1, -3, 4, -1, 2, 1, -5, 4]

Output

Max Sum: 6 (Subarray: [4, -1, 2, 1])

public class KadanesAlgorithm {
    public static void main(String[] args) {
        int[] arr = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        int maxSum = Integer.MIN_VALUE;
        int currentSum = 0;
        int start = 0, end = 0, tempStart = 0;

        for (int i = 0; i < arr.length; i++) {
            currentSum += arr[i];
            if (currentSum > maxSum) {
                maxSum = currentSum;
                start = tempStart;
                end = i;
            }
            if (currentSum < 0) {
                currentSum = 0;
                tempStart = i + 1;
            }
        }

        System.out.println("Max Sum: " + maxSum + " (Subarray: " + java.util.Arrays.toString(java.util.Arrays.copyOfRange(arr, start, end + 1)) + ")");
    }
}

Explanation:

Use a variable to keep track of current subarray sum.
Reset current sum to 0 if it becomes negative.
Update max sum and subarray indexes when a new max is found.

Java Array Intermediate Programs

Second Largest Element

Check Array Sorted

Find Missing Number

Remove Duplicates

Reverse Array In-Place

Merge Two Sorted Arrays

Count Even and Odd Numbers

Find Pairs with Given Sum

Find Majority Element

Rotate Array by K Positions

Count Frequencies of Elements

Find Kth Smallest Element

Find Leaders in the Array

Find First Repeating Element

Find Subarray with Given Sum

Move All Zeros to End

Find Union and Intersection

Maximum Product Subarray

Replace Every Element With Greatest on Right

Kadane’s Algorithm (Max Subarray Sum)