Obify Consulting

public static boolean isAlpha(final CharSequence cs) {
        if (isEmpty(cs)) {
            return false;
        }
        final int sz = cs.length();
        for (int i = 0; i < sz; i++) {
            if (!Character.isLetter(cs.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public static boolean isEmpty(final CharSequence cs) {
        return cs == null || cs.length() == 0;
    }

private static boolean isNumeric(final CharSequence cs) {
        if (isEmpty(cs)) {
        return false;
        }
final int sz = cs.length();
        for (int i = 0; i < sz; i++) {
        if (!Character.isDigit(cs.charAt(i))) {
        return false;
        }
    }
        return true;
 }

public class ReverseEachWord {
    public static void main(String[] args) {

        reverseEachWord("obify consultancy");

        reverseEachWord("I am string not reversed");

        reverseEachWord("Reverse Me");

    }

    private static String reverseEachWord(String originalStr) {

        // split the sentence by words using split method
        String[] words = originalStr.split(" ");

        String reverseStr = "";

        // Iterate over String array
        for (String word: words) {
            // reverse each word by calling reverseWithStringConcat method
            reverseStr = reverseStr + reverseWithStringConcat(word) + " ";
        }

        display(originalStr, reverseStr);
        return reverseStr;
    }

    private static final void display(String original, String reverse) {
        System.out.println(original);
        System.out.println(reverse);
    }
    private static final String reverseWithStringConcat(String string) {
        String reverseWord = "";
        for (int i = (string.length() - 1); i >= 0; i--) {
            reverseWord = reverseWord + string.charAt(i);
        }
        return reverseWord;
    }
}

output:

obify consultancy
yfibo ycnatlusnoc
I am string not reversed
I ma gnirts ton desrever
Reverse Me
esreveR eM

public class ReverseString {

    public static void main(String[] args) {
        reverseWithStringConcat("obify");
    }
    public static final String reverseWithStringConcat(String string) {
        String output = new String();
        for (int i = (string.length() - 1); i >= 0; i--) {
            output += (string.charAt(i));
        }

        display(string, output);
        return output;
    }
    private static final void display(String original, String reverse) {
        System.out.println(original);
        System.out.println(reverse);
    }
}

output:
obify
yfibo

public class RemoveDuplicateWordsFromString {
    public static void main(String[] args) {
        String string = "i like java java coding java and you do you interested in java coding coding.";

        System.out.println("Original String: ");
        System.out.println(string);
        /*
         * Since the words are separated by space, we will split the string by
         * one or more space
         */

        final String[] strWords = string.split("\\s+");

        // convert String array to LinkedHashSet to remove duplicates
        final Set < String > setOfWords = new LinkedHashSet < String > (Arrays.asList(strWords));

        // join the words again by space
        final StringBuilder builder = new StringBuilder();
        int index = 0;

        for (String s: setOfWords) {

            if (index > 0)
                builder.append(" ");

            builder.append(s);
            index++;
        }

        string = builder.toString();

        System.out.println("String after removing duplicate words: ");
        System.out.println(string);

    }
}

output:

Original String:
i like java java coding java and you do you interested in java coding coding.
String after removing duplicate words:
i like java coding and you do interested in coding

public class MergeTwoStringarrays {

    private static String[] mergeStringArrays(String array1[], String array2[]) {

        if (array1 == null || array1.length == 0)
            return array2;
        if (array2 == null || array2.length == 0)
            return array1;
        List < String > firstList = Arrays.asList(array1);
        List < String > secondList = Arrays.asList(array2);

        List < String > result = new ArrayList < String > (firstList);
        List < String > tmp = new ArrayList < String > (firstList);

        tmp.retainAll(secondList);
        result.removeAll(tmp);
        result.addAll(secondList);
        return ((String[]) result.toArray(new String[result.size()]));
    }

    public static void main(String[] args) {
        String[] strArray = mergeStringArrays(new String[] {
                "abc",
                "xyz",
                "pqr"
            },
            new String[] {
                "abc",
                "ABC",
                "PQR"
            });
        for (String string: strArray) {
            System.out.println(string);
        }
    }
}

output:

xyz
pqr
abc
ABC
PQR

public class StringPermutationsProgram {
 
     public List<String> permutations(String inputStr) {
        if (inputStr == null)
           return null;
  
        final List<String> result = new ArrayList<>();
        if (inputStr.length() < 2) {

            result.add(inputStr);
            return result;
        }

        final List<String> permutations = permutations(inputStr.substring(1));
        for (final String permutation : permutations) {
        for (int i = 0; i <= permutation.length(); i++) {
        String newPermutation = permutation.substring(0, i) 
              + inputStr.charAt(0) + permutation.substring(i);
        result.add(newPermutation);
     }
   }
  return result;
}

 public static void main(String[] args) {
     StringPermutationsProgram permuter = new StringPermutationsProgram();
     List<String> perms = permuter.permutations("xyz");
     System.out.println(Arrays.toString(perms.toArray()));
  
     List<String> perms1 = permuter.permutations("abca");
     System.out.println(Arrays.toString(perms1.toArray()));
   }
}

output:

[xyz, yxz, yzx, xzy, zxy, zyx]
[abca, baca, bcaa, bcaa, acba, caba, cbaa, cbaa, acab, caab, caab, caba, abac, baac, baac, baca, aabc,
aabc, abac, abca, aacb, aacb, acab, acba]