Ace Your Java Coding Interview: 15 Questions & Clear Answers

public static String reverse(String in) {
    if (in == null)
        throw new IllegalArgumentException("Null input");
    StringBuilder out = new StringBuilder();
    char[] chars = in.toCharArray();
    for (int i = chars.length - 1; i >= 0; i--)
        out.append(chars[i]);
    return out.toString();
}

b = b + a; // b is now the sum
a = b - a; // a is now original b
b = b - a; // b is now original a

public static boolean stringContainsVowels(String input) {
    return input.toLowerCase().matches(".*[aeiou].*");
}

public static boolean isPrime(int n) {
    if (n <= 1) return false;
    if (n == 2) return true;
    for (int i = 2; i <= Math.sqrt(n); i++) {
        if (n % i == 0) return false;
    }
    return true;
}

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

public static boolean onlyOddNumbers(List<Integer> list) {
    return list.parallelStream().allMatch(x -> x % 2 != 0);
}

boolean checkPalindromeString(String input) {
    int length = input.length();
    for (int i = 0; i < length/2; i++) {
        if (input.charAt(i) != input.charAt(length - i - 1)) {
            return false;
        }
    }
    return true;
}

String removeWhiteSpaces(String input) {
    StringBuilder output = new StringBuilder();
    char[] charArray = input.toCharArray();
    for (char c : charArray) {
        if (!Character.isWhitespace(c))
            output.append(c);
    }
    return output.toString();
}

String s = " abc def\t";
s = s.strip();
System.out.println(s);

int[] array = {1, 2, 3, -1, -2, 4};
Arrays.sort(array);
System.out.println(Arrays.toString(array));

public class ThreadDeadlock {
    public static void main(String[] args) throws InterruptedException {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = new Object();

        Thread t1 = new Thread(new SyncThread(obj1, obj2), "t1");
        Thread t2 = new Thread(new SyncThread(obj2, obj3), "t2");
        Thread t3 = new Thread(new SyncThread(obj3, obj1), "t3");

        t1.start();
        Thread.sleep(5000);
        t2.start();
        Thread.sleep(5000);
        t3.start();
    }
}

public static long factorial(long n) {
    if (n == 1)
        return 1;
    else
        return (n * factorial(n - 1));
}

LinkedList<Integer> ll = new LinkedList<>();
ll.add(1);
ll.add(2);
ll.add(3);

LinkedList<Integer> ll1 = new LinkedList<>();
ll.descendingIterator().forEachRemaining(ll1::add);

System.out.println(ll1);

public static int binarySearch(int arr[], int low, int high, int key) {
    while (low <= high) {
        int mid = (low + high) / 2;
        if (arr[mid] < key) {
            low = mid + 1;
        } else if (arr[mid] == key) {
            return mid;
        } else {
            high = mid - 1;
        }
    }
    return -1;
}

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = { 70, 50, 30, 10, 20, 40, 60 };

        int[] merged = mergeSort(arr);

        for (int val : merged) {
            System.out.print(val+"," );
        }
    }

    public static int[] mergeSort(int[] arr) {
        if (arr.length <= 1) {
            return arr;
        }

        int midpoint = arr.length / 2;
        int[] left = new int[midpoint];
        int[] right;

        if (arr.length % 2 == 0) {
            right = new int[midpoint];
        } else {
            right = new int[midpoint + 1];
        }

        for (int i = 0; i < midpoint; i++) {
            left[i] = arr[i];
        }

        for (int j = 0; j < right.length; j++) {
            right[j] = arr[midpoint+j];
        }

        int[] result = new int[arr.length];

        left = mergeSort(left);
        right = mergeSort(right);

        result = merge(left, right);

        return result;
    }

    public static int[] merge(int[] left, int[] right) {

        int[] result = new int[left.length + right.length];

        int leftPointer, rightPointer, resultPointer;
        leftPointer = rightPointer = resultPointer = 0;

        while (leftPointer < left.length || rightPointer < right.length) {
            if (leftPointer < left.length && rightPointer < right.length) {
                if (left[leftPointer] < right[rightPointer]) {
                    result[resultPointer++] = left[leftPointer++];
                } else {
                    result[resultPointer++] = right[rightPointer++];
                }
            } else if (leftPointer < left.length) {
                result[resultPointer++] = left[leftPointer++];
            } else if (rightPointer < right.length) {
                result[resultPointer++] = right[rightPointer++];
            }
        }

        return result;
    }
}