feat:Java Interview Coding Examples.

Author: pothurajtharun

src/array/manipulations/BubbleSortExample.java

@@ -0,0 +1,23 @@
+package array.manipulations;
+
+public class BubbleSortExample {
+  public static void main(String[] args) {
+    int[] arr = {5, 3, 8, 1, 2};
+
+    for (int i = 0; i < arr.length - 1; i++) {
+      for (int j = 0; j < arr.length - i - 1; j++) {
+        if (arr[j] > arr[j + 1]) {
+          // Swap
+          int temp = arr[j];
+          arr[j] = arr[j + 1];
+          arr[j + 1] = temp;
+        }
+      }
+    }
+
+    System.out.println("Sorted array: ");
+    for (int num : arr) {
+      System.out.print(num + " ");
+    }
+  }
+}

src/array/manipulations/FindDuplicate.java

@@ -0,0 +1,19 @@
+package array.manipulations;
+
+import java.util.*;
+
+public class FindDuplicate {
+  public static void main(String[] args) {
+    int[] arr = {1, 3, 4, 2, 2};
+
+    Set<Integer> seen = new HashSet<>();
+    for (int num : arr) {
+      if (!seen.add(num)) {
+        System.out.println("Duplicate number: " + num);
+        return;
+      }
+    }
+
+    System.out.println("No duplicates found.");
+  }
+}

src/array/manipulations/FindPairs.java

@@ -0,0 +1,21 @@
+package array.manipulations;
+
+import java.util.*;
+
+public class FindPairs {
+  public static void main(String[] args) {
+    int[] arr = {2, 4, 3, 5, 7, 8, 9};
+    int target = 10;
+
+    Set<Integer> seen = new HashSet<>();
+
+    for (int num : arr) {
+      int complement = target - num;
+      if (seen.contains(complement)) {
+        System.out.println("Pair: (" + complement + ", " + num + ")");
+      }
+      seen.add(num);
+    }
+  }
+}
+

src/array/manipulations/MinMaxInArray.java

@@ -0,0 +1,19 @@
+package array.manipulations;
+
+public class MinMaxInArray {
+  public static void main(String[] args) {
+    int[] arr = {45, 3, 99, 12, 0, -5, 72};
+
+    int min = arr[0];
+    int max = arr[0];
+
+    for (int num : arr) {
+      if (num < min) min = num;
+      if (num > max) max = num;
+    }
+
+    System.out.println("Min: " + min);
+    System.out.println("Max: " + max);
+  }
+}
+

src/array/manipulations/MissingNumber.java

@@ -0,0 +1,19 @@
+package array.manipulations;
+
+public class MissingNumber {
+  public static void main(String[] args) {
+    int[] arr = {1, 2, 4, 5, 6}; // Missing 3
+
+    int n = arr.length + 1;
+    int expectedSum = n * (n + 1) / 2;
+
+    int actualSum = 0;
+    for (int num : arr) {
+      actualSum += num;
+    }
+
+    int missing = expectedSum - actualSum;
+    System.out.println("Missing number: " + missing);
+  }
+}
+

src/array/manipulations/MoveZeros.java

@@ -0,0 +1,24 @@
+package array.manipulations;
+
+public class MoveZeros {
+  public static void main(String[] args) {
+    int[] arr = {0, 1, 0, 3, 12};
+
+    int index = 0;
+    for (int num : arr) {
+      if (num != 0) {
+        arr[index++] = num;
+      }
+    }
+
+    while (index < arr.length) {
+      arr[index++] = 0;
+    }
+
+    System.out.print("After moving zeros: ");
+    for (int num : arr) {
+      System.out.print(num + " ");
+    }
+  }
+}
+

src/array/manipulations/RemoveDuplicates.java

@@ -0,0 +1,17 @@
+package array.manipulations;
+
+import java.util.*;
+
+public class RemoveDuplicates {
+  public static void main(String[] args) {
+    int[] arr = {1, 3, 2, 3, 4, 1, 5};
+
+    Set<Integer> set = new LinkedHashSet<>();
+    for (int value : arr) {
+      set.add(value);
+    }
+
+    System.out.println("Array after removing duplicates: " + set);
+  }
+}
+

src/array/manipulations/ReverseArray.java

@@ -0,0 +1,24 @@
+package array.manipulations;
+
+public class ReverseArray {
+  public static void main(String[] args) {
+    int[] arr = {1, 2, 3, 4, 5};
+
+    int left = 0, right = arr.length - 1;
+
+    while (left < right) {
+      int temp = arr[left];
+      arr[left] = arr[right];
+      arr[right] = temp;
+
+      left++;
+      right--;
+    }
+
+    System.out.println("Reversed array: ");
+    for (int num : arr) {
+      System.out.print(num + " ");
+    }
+  }
+}
+

src/stream/manipulations/ArrayToListStream.java

@@ -0,0 +1,17 @@
+package stream.manipulations;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ArrayToListStream {
+  public static void main(String[] args) {
+    String[] names = {"Alice", "Bob", "Charlie"};
+
+    List<String> nameList = Arrays.stream(names)
+        .collect(Collectors.toList());
+
+    System.out.println("List: " + nameList);
+  }
+}
+

src/stream/manipulations/FilterEvenNumbers.java

@@ -0,0 +1,16 @@
+package stream.manipulations;
+
+import java.util.Arrays;
+
+public class FilterEvenNumbers {
+  public static void main(String[] args) {
+    int[] arr = {1, 2, 3, 4, 5, 6};
+
+    int[] evens = Arrays.stream(arr)
+        .filter(num -> num % 2 == 0)
+        .toArray();
+
+    System.out.println("Even numbers: " + Arrays.toString(evens));
+  }
+}
+

src/stream/manipulations/FrequencyCountStream.java

@@ -0,0 +1,17 @@
+package stream.manipulations;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class FrequencyCountStream {
+  public static void main(String[] args) {
+    String[] input = {"apple", "banana", "apple", "orange", "banana", "apple"};
+
+    Map<String, Long> frequencyMap = Arrays.stream(input)
+        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+
+    System.out.println("Frequencies: " + frequencyMap);
+  }
+}
+

src/stream/manipulations/MinMaxStream.java

@@ -0,0 +1,17 @@
+package stream.manipulations;
+
+import java.util.OptionalInt;
+import java.util.stream.IntStream;
+
+public class MinMaxStream {
+  public static void main(String[] args) {
+    int[] arr = {5, 10, 3, 7, 1};
+
+    OptionalInt min = IntStream.of(arr).min();
+    OptionalInt max = IntStream.of(arr).max();
+
+    min.ifPresent(m -> System.out.println("Min: " + m));
+    max.ifPresent(m -> System.out.println("Max: " + m));
+  }
+}
+

src/stream/manipulations/RemoveDuplicatesStream.java

@@ -0,0 +1,17 @@
+package stream.manipulations;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
+public class RemoveDuplicatesStream {
+  public static void main(String[] args) {
+    int[] arr = {1, 2, 3, 2, 4, 1, 5};
+
+    int[] result = IntStream.of(arr)
+        .distinct()
+        .toArray();
+
+    System.out.println("Unique elements: " + Arrays.toString(result));
+  }
+}
+

src/stream/manipulations/SortStream.java

@@ -0,0 +1,16 @@
+package stream.manipulations;
+
+import java.util.Arrays;
+
+public class SortStream {
+  public static void main(String[] args) {
+    int[] arr = {9, 3, 7, 1, 4};
+
+    int[] sorted = Arrays.stream(arr)
+        .sorted()
+        .toArray();
+
+    System.out.println("Sorted array: " + Arrays.toString(sorted));
+  }
+}
+

src/stream/manipulations/SumWithStreams.java

@@ -0,0 +1,14 @@
+package stream.manipulations;
+
+import java.util.stream.IntStream;
+
+public class SumWithStreams {
+  public static void main(String[] args) {
+    int[] arr = {1, 2, 3, 4, 5};
+
+    int sum = IntStream.of(arr).sum();
+
+    System.out.println("Sum = " + sum);
+  }
+}
+

src/string/manipulations/AnagramCheck.java

@@ -0,0 +1,20 @@
+package string.manipulations;
+
+import java.util.*;
+
+//Example: "listen" & "silent" → true
+
+public class AnagramCheck {
+    public static boolean areAnagrams(String s1, String s2) {
+        if (s1.length() != s2.length()) return false;
+        char[] c1 = s1.toCharArray();
+        char[] c2 = s2.toCharArray();
+        Arrays.sort(c1);
+        Arrays.sort(c2);
+        return Arrays.equals(c1, c2);
+    }
+
+    public static void main(String[] args) {
+        System.out.println("Are anagrams: " + areAnagrams("listen", "silent"));
+    }
+}

src/string/manipulations/FirstNonRepeated.java

@@ -0,0 +1,22 @@
+package string.manipulations;
+
+import java.util.*;
+
+// Example: "aabbccdfe" → 'd'
+
+public class FirstNonRepeated {
+    public static char firstNonRepeatedChar(String str) {
+        Map<Character, Integer> map = new LinkedHashMap<>();
+        for (char c : str.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
+            if (entry.getValue() == 1) return entry.getKey();
+        }
+        return '_';
+    }
+
+    public static void main(String[] args) {
+        System.out.println("First non-repeated character: " + firstNonRepeatedChar("aabbccdfe"));
+    }
+}

src/string/manipulations/LongestPalindrome.java

@@ -0,0 +1,29 @@
+package string.manipulations;
+
+public class LongestPalindrome {
+    public static String longestPalindrome(String s) {
+        int start = 0, end = 0;
+        for (int i = 0; i < s.length(); i++) {
+            int len1 = expand(s, i, i);
+            int len2 = expand(s, i, i + 1);
+            int len = Math.max(len1, len2);
+            if (len > end - start) {
+                start = i - (len - 1) / 2;
+                end = i + len / 2;
+            }
+        }
+        return s.substring(start, end + 1);
+    }
+
+    private static int expand(String s, int left, int right) {
+        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
+            left--;
+            right++;
+        }
+        return right - left - 1;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("Longest palindrome in 'babad': " + longestPalindrome("babad"));
+    }
+}

src/string/manipulations/LongestWordFinder.java

@@ -0,0 +1,20 @@
+package string.manipulations;
+
+public class LongestWordFinder {
+  public static String findLongestWord(String sentence) {
+    String[] words = sentence.split("\\s+");
+    String longest = "";
+    for (String word : words) {
+      if (word.length() > longest.length()) {
+        longest = word;
+      }
+    }
+    return longest;
+  }
+
+  public static void main(String[] args) {
+    String input = "Java is an object-oriented programming language";
+    System.out.println("Longest word: " + findLongestWord(input));
+  }
+}
+