Java Basics Programs - Learning with Nitheesh

Write a program to check if two strings are anagrams of each other.

Input

"listen", "silent"

Output

Yes, they are anagrams.

import java.util.Arrays;

public class AnagramCheck {
    public static void main(String[] args) {
        String str1 = "listen";
        String str2 = "silent";

        if (areAnagrams(str1, str2)) {
            System.out.println("Yes, they are anagrams.");
        } else {
            System.out.println("No, they are not anagrams.");
        }
    }

    public static boolean areAnagrams(String s1, String s2) {
        // Remove spaces and convert to lowercase
        s1 = s1.replaceAll("\\s", "").toLowerCase();
        s2 = s2.replaceAll("\\s", "").toLowerCase();

        if (s1.length() != s2.length()) {
            return false;
        }

        char[] arr1 = s1.toCharArray();
        char[] arr2 = s2.toCharArray();

        Arrays.sort(arr1);
        Arrays.sort(arr2);

        return Arrays.equals(arr1, arr2);
    }
}

Explanation:

Convert both strings to lowercase and remove spaces.
If lengths differ, they cannot be anagrams.
Convert strings to char arrays, sort them, and compare.
If sorted arrays are equal, strings are anagrams.

Write a program to remove all duplicate characters from a string.

Input

"programming"

Output

"progamin"

import java.util.LinkedHashSet;

public class RemoveDuplicateChars {
    public static void main(String[] args) {
        String input = "programming";
        String result = removeDuplicates(input);
        System.out.println(result);
    }

    public static String removeDuplicates(String str) {
        LinkedHashSet set = new LinkedHashSet<>();
        for (char c : str.toCharArray()) {
            set.add(c);
        }
        StringBuilder sb = new StringBuilder();
        for (char c : set) {
            sb.append(c);
        }
        return sb.toString();
    }
}

Explanation:

Use a LinkedHashSet to maintain insertion order and uniqueness.
Traverse the string and add each character to the set.
Build a new string from the set elements.
Return the string without duplicate characters.

Write a program to find the longest word in a sentence.

Input

"The quick brown fox jumped over the lazy dog"

Output

Longest Word: "jumped"

public class LongestWordInSentence {
    public static void main(String[] args) {
        String sentence = "The quick brown fox jumped over the lazy dog";
        String longestWord = findLongestWord(sentence);
        System.out.println("Longest Word: \"" + longestWord + "\"");
    }

    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;
    }
}

Explanation:

Split the sentence into words by whitespace.
Initialize an empty string to track the longest word.
Iterate through each word, updating the longest if current word length is greater.
Return the longest word found.

Write a program to count the frequency of each character in a string.

Input

"balloon"

Output

b:1 a:1 l:2 o:2 n:1

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

public class CharacterFrequencyCount {
    public static void main(String[] args) {
        String input = "balloon";
        Map freqMap = new HashMap<>();

        for (char ch : input.toCharArray()) {
            freqMap.put(ch, freqMap.getOrDefault(ch, 0) + 1);
        }

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

Explanation:

Use a HashMap to store character frequencies.
Iterate over each character, incrementing its count in the map.
Print the character and its frequency from the map.

Write a program to check if one string is a rotation of another.

Input

"waterbottle", "erbottlewat"

Output

Yes, it is a rotation

public class StringRotationCheck {
    public static boolean isRotation(String s1, String s2) {
        if (s1.length() != s2.length()) return false;
        String temp = s1 + s1;
        return temp.contains(s2);
    }

    public static void main(String[] args) {
        String s1 = "waterbottle";
        String s2 = "erbottlewat";

        if (isRotation(s1, s2)) {
            System.out.println("Yes, it is a rotation");
        } else {
            System.out.println("No, it is not a rotation");
        }
    }
}

Explanation:

If strings are of different lengths, they cannot be rotations.
Concatenate the first string to itself.
If the second string is a substring of this concatenated string, it is a rotation.

Write a program to reverse the order of words in a sentence.

Input

"hello world program"

Output

"program world hello"

public class ReverseWords {
    public static String reverseWords(String sentence) {
        String[] words = sentence.split(" ");
        StringBuilder reversed = new StringBuilder();

        for (int i = words.length - 1; i >= 0; i--) {
            reversed.append(words[i]);
            if (i != 0) reversed.append(" ");
        }
        return reversed.toString();
    }

    public static void main(String[] args) {
        String input = "hello world program";
        System.out.println(reverseWords(input));
    }
}

Explanation:

Split the sentence into words using space as a delimiter.
Traverse the words array backward and append words to the result.
Return the reversed word string.

Compress the string by counting consecutive characters.

Input

"aabcccccaaa"

Output

"a2b1c5a3"

public class StringCompression {
    public static String compress(String str) {
        StringBuilder compressed = new StringBuilder();
        int count = 1;

        for (int i = 1; i <= str.length(); i++) {
            if (i < str.length() && str.charAt(i) == str.charAt(i - 1)) {
                count++;
            } else {
                compressed.append(str.charAt(i - 1));
                compressed.append(count);
                count = 1;
            }
        }
        return compressed.toString();
    }

    public static void main(String[] args) {
        String input = "aabcccccaaa";
        System.out.println(compress(input));
    }
}

Explanation:

Traverse the string while counting consecutive repeating characters.
Append the character and its count to the result when a new character is encountered.
Return the compressed string.

Write a function to implement strstr() (find substring).

Input

"hello", "ll"

Output

Found at index 2

public class StrStrImplementation {
    public static int strstr(String haystack, String needle) {
        int hLen = haystack.length();
        int nLen = needle.length();

        if (nLen == 0) return 0; // Empty needle

        for (int i = 0; i <= hLen - nLen; i++) {
            int j = 0;
            while (j < nLen && haystack.charAt(i + j) == needle.charAt(j)) {
                j++;
            }
            if (j == nLen) {
                return i; // Found at index i
            }
        }
        return -1; // Not found
    }

    public static void main(String[] args) {
        String haystack = "hello";
        String needle = "ll";

        int index = strstr(haystack, needle);
        if (index != -1) {
            System.out.println("Found at index " + index);
        } else {
            System.out.println("Not found");
        }
    }
}

Explanation:

Iterate through the main string up to length difference.
For each position, check if substring matches the needle.
If match found, return the starting index.
If no match, return -1.

Write a program to convert a numeric string into an integer.

Input

"12345"

Output

Integer: 12345

public class StringToInteger {
    public static int stringToInt(String str) {
        int result = 0;
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c < '0' || c > '9') {
                throw new IllegalArgumentException("Invalid numeric string");
            }
            result = result * 10 + (c - '0');
        }
        return result;
    }

    public static void main(String[] args) {
        String numericString = "12345";
        int number = stringToInt(numericString);
        System.out.println("Integer: " + number);
    }
}

Explanation:

Initialize result as 0.
Traverse each character of the string.
Check if character is digit; if not, throw error.
Update result by multiplying current result by 10 and adding numeric value of character.
Return final result.

Write a program to find the first non-repeating character in a string.

Input

"aabbcddee"

Output

First Unique: c

import java.util.LinkedHashMap;
import java.util.Map;

public class FirstNonRepeatingChar {
    public static char firstNonRepeatingChar(String str) {
        Map charCount = new LinkedHashMap<>();
        for (char c : str.toCharArray()) {
            charCount.put(c, charCount.getOrDefault(c, 0) + 1);
        }
        for (Map.Entry entry : charCount.entrySet()) {
            if (entry.getValue() == 1) {
                return entry.getKey();
            }
        }
        return '\0'; // No unique char found
    }

    public static void main(String[] args) {
        String input = "aabbcddee";
        char result = firstNonRepeatingChar(input);
        if (result != '\0') {
            System.out.println("First Unique: " + result);
        } else {
            System.out.println("No unique character found.");
        }
    }
}

Explanation:

Use a LinkedHashMap to maintain character count and insertion order.
Traverse the string to count occurrences of each character.
Traverse map entries to find the first character with count 1.
Return the first unique character found, or indicate none exists.

Check if a string has all unique characters.

Input

"abcdefg"

Output

Yes, all characters are unique.

import java.util.HashSet;
import java.util.Set;

public class AllUniqueCharacters {
    public static boolean areAllUnique(String str) {
        Set chars = new HashSet<>();
        for (char c : str.toCharArray()) {
            if (chars.contains(c)) {
                return false;
            }
            chars.add(c);
        }
        return true;
    }

    public static void main(String[] args) {
        String input = "abcdefg";
        if (areAllUnique(input)) {
            System.out.println("Yes, all characters are unique.");
        } else {
            System.out.println("No, there are duplicate characters.");
        }
    }
}

Explanation:

Use a HashSet to track characters encountered.
Traverse the string; if a character is already in the set, duplicates exist.
If traversal finishes without duplicates, all characters are unique.

Convert the first letter of each word to uppercase.

Input

"welcome to coding world"

Output

"Welcome To Coding World"

public class TitleCaseConverter {
    public static String toTitleCase(String str) {
        String[] words = str.split("\\s+");
        StringBuilder sb = new StringBuilder();
        for (String word : words) {
            if (word.length() > 0) {
                sb.append(Character.toUpperCase(word.charAt(0)));
                sb.append(word.substring(1).toLowerCase());
                sb.append(" ");
            }
        }
        return sb.toString().trim();
    }

    public static void main(String[] args) {
        String input = "welcome to coding world";
        String result = toTitleCase(input);
        System.out.println(result);
    }
}

Explanation:

Split the input string into words by spaces.
Capitalize the first character of each word, convert rest to lowercase.
Concatenate all words with spaces and trim the trailing space.

Write a program to generate all substrings of a string.

Input

"abc"

Output

"a", "ab", "abc", "b", "bc", "c"

public class AllSubstrings {
    public static void main(String[] args) {
        String str = "abc";
        for (int i = 0; i < str.length(); i++) {
            for (int j = i + 1; j <= str.length(); j++) {
                System.out.println(str.substring(i, j));
            }
        }
    }
}

Explanation:

Use two nested loops: the outer loop picks the start index.
The inner loop picks the end index for the substring.
Print the substring from start to end index for all combinations.

Write a program to count vowels and consonants in a string.

Input

"hello world"

Output

Vowels: 3, Consonants: 7

public class VowelConsonantCount {
    public static void main(String[] args) {
        String str = "hello world";
        int vowels = 0, consonants = 0;
        str = str.toLowerCase();

        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            if (ch >= 'a' && ch <= 'z') {
                if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
                    vowels++;
                } else {
                    consonants++;
                }
            }
        }

        System.out.println("Vowels: " + vowels + ", Consonants: " + consonants);
    }
}

Explanation:

Convert the string to lowercase for uniformity.
Iterate over each character, check if it’s an alphabet.
Count vowels if the character matches a vowel, else consonants.
Ignore spaces and other non-alphabetic characters.

Write a program to check if a string contains only digits.

Input

"123456"

Output

Yes, it contains only digits.

public class DigitsOnlyCheck {
    public static void main(String[] args) {
        String str = "123456";
        boolean isDigitsOnly = true;

        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                isDigitsOnly = false;
                break;
            }
        }

        if (isDigitsOnly) {
            System.out.println("Yes, it contains only digits.");
        } else {
            System.out.println("No, it contains other characters.");
        }
    }
}

Explanation:

Iterate over each character in the string.
Check if every character is a digit using Character.isDigit().
If any character is not a digit, mark as false and break the loop.
Print appropriate message based on the flag.

Find the length of the longest substring with all unique characters.

Input

"abcabcbb"

Output

Length: 3

import java.util.HashSet;

public class LongestUniqueSubstring {
    public static void main(String[] args) {
        String s = "abcabcbb";
        System.out.println("Length: " + lengthOfLongestSubstring(s));
    }

    public static int lengthOfLongestSubstring(String s) {
        int maxLen = 0, start = 0;
        HashSet<Character> set = new HashSet<>();

        for (int end = 0; end < s.length(); end++) {
            while (set.contains(s.charAt(end))) {
                set.remove(s.charAt(start));
                start++;
            }
            set.add(s.charAt(end));
            maxLen = Math.max(maxLen, end - start + 1);
        }
        return maxLen;
    }
}

Explanation:

Use two pointers (start and end) to maintain a sliding window.
Use a HashSet to track unique characters in the current window.
If the current character is already in the set, shrink the window from the left until it is removed.
Update max length after expanding the window.

Write a program to remove all non-alphabetic characters from a string.

Input

"Hello@123#World!"

Output

"HelloWorld"

public class RemoveNonAlphabetic {
    public static void main(String[] args) {
        String input = "Hello@123#World!";
        String result = input.replaceAll("[^a-zA-Z]", "");
        System.out.println(result);
    }
}

Explanation:

Use regex [^a-zA-Z] to match all non-alphabetic characters.
Replace all matched characters with an empty string.
Print the cleaned string containing only alphabets.

Check if a string is a pangram (contains all alphabets).

Input

"The quick brown fox jumps over the lazy dog"

Output

Yes, it's a pangram.

public class PangramCheck {
    public static void main(String[] args) {
        String sentence = "The quick brown fox jumps over the lazy dog";
        sentence = sentence.toLowerCase();
        boolean[] alphabet = new boolean[26];
        int index;
        int count = 0;

        for (int i = 0; i < sentence.length(); i++) {
            char ch = sentence.charAt(i);
            if (ch >= 'a' && ch <= 'z') {
                index = ch - 'a';
                if (!alphabet[index]) {
                    alphabet[index] = true;
                    count++;
                }
            }
        }

        if (count == 26) {
            System.out.println("Yes, it's a pangram.");
        } else {
            System.out.println("No, it's not a pangram.");
        }
    }
}

Explanation:

Convert the string to lowercase to handle case-insensitivity.
Use a boolean array of size 26 to track each alphabet occurrence.
Iterate through the string, mark characters found in the boolean array.
If all 26 alphabets are found, the string is a pangram.

Replace all spaces in a string with "%20".

Input

"My name is Khan"

Output

"My%20name%20is%20Khan"

public class ReplaceSpaces {
    public static void main(String[] args) {
        String input = "My name is Khan";
        String output = input.replace(" ", "%20");
        System.out.println(output);
    }
}

Explanation:

Use the built-in replace() method to replace all spaces with "%20".
Print the modified string.

Find the minimum characters to insert at the beginning to make a string palindrome.

Input

"abcd"

Output

Minimum Insertions: 3 (Result: "dcbabcd")

public class MinInsertionsPalindrome {
    // Function to check if a string is palindrome
    static boolean isPalindrome(String s) {
        int start = 0, end = s.length() - 1;
        while (start < end) {
            if (s.charAt(start) != s.charAt(end)) return false;
            start++;
            end--;
        }
        return true;
    }

    // Function to find minimum insertions at beginning
    static int minInsertionsToMakePalindrome(String s) {
        int count = 0;
        String temp = s;
        // Keep adding characters from end until palindrome formed
        while (!isPalindrome(temp)) {
            count++;
            temp = s.charAt(s.length() - count) + temp;
        }
        return count;
    }

    public static void main(String[] args) {
        String input = "abcd";
        int minInsertions = minInsertionsToMakePalindrome(input);

        // Construct the result string
        StringBuilder sb = new StringBuilder(input);
        for (int i = minInsertions - 1; i >= 0; i--) {
            sb.insert(0, input.charAt(input.length() - 1 - i));
        }

        System.out.println("Minimum Insertions: " + minInsertions + " (Result: \"" + sb.toString() + "\")");
    }
}

Explanation:

Check if the string is a palindrome.
If not, keep adding characters from the end of the string to the front until it becomes palindrome.
The count of added characters is the minimum insertions needed.
Print the minimum insertions and the resulting palindrome.

Java String Intermediate Programs

Anagram Check

Remove Duplicate Characters

Longest Word in Sentence

Character Frequency Count

String Rotation Check

Reverse Words in a Sentence

String Compression

strstr() Implementation

String to Integer Conversion

First Non-Repeating Character

All Unique Characters

Convert to Title Case

All Substrings of a String

Vowel and Consonant Count

Digits Only Check

Longest Substring Without Repeating Characters

Remove Non-Alphabetic Characters

Pangram Check

Replace Spaces with %20

Make String Palindrome (Minimum Insertions)