Java 8 # String Program Understanding

 

🔑 Core String Coding Challenges

Reverse a String without using StringBuilder or StringBuffer.

·       import java.util.*;
import java.util.stream.*;
public class ReverseStringExample
{

    public static void main(String[] args)
    {
        String str = "BrijendraJaiswal";
        String reversed = "";

        char[] chars = str.toCharArray();

        for(int i=chars.length-1;i >= 0;i--)
        {
            reversed += chars[i];
        }
        System.out.println(reversed);
    }


}

Count the number of vowels, consonants, digits, and special characters in a String.

import java.util.Map;

import java.util.OptionalLong;

import java.util.function.Function;

import java.util.stream.Collectors;



public class StringCharacterCountStream {

    public static void main(String[] args) {

        String str = "HelloWord@1234";

        String vowelList = "aeiouAEIOU";

        Map<String,Long> result =str.chars().mapToObj(c -> (char)c)

                .map(ch ->

        {

            if(Character.isLetter(ch)){

                return vowelList.indexOf(ch) != -1 ? "Vowel" : "Consonant";

            } else if(Character.isDigit(ch))

            {

                return "Digit";

            } else {

                return "Special";

            }

        })

                .collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));

        System.out.println("VOWEL:"+result.getOrDefault("Vowel", 0L));

        System.out.println("CONSONENT:"+result.getOrDefault("CONSONENT", 0L));

        System.out.println("CONSONENT:"+result.getOrDefault("Digit", 0L));

        System.out.println("CONSONENT:"+result.getOrDefault("Special", 0L));

    }

}

 

Find the first non-repeated character in a String.

·       import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.function.Function;

import java.util.stream.Collectors;



public class FirstNonRepeatedChar {

    public static void main(String[] args) {

        String str = "swiss";



        String result = String.valueOf(str.chars()

                .mapToObj(c -> (char)c)

                .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new,Collectors.counting()

                ))

                .entrySet()

                .stream()

                .filter(entry -> entry.getValue() ==1)

                .map(Map.Entry::getKey)

                .findFirst()

                .orElse(null));



        System.out.println(result);

    }

}

 

Check if a String is a palindrome.

import java.util.stream.IntStream;

public class PalindromeCheck {
    public static void main(String[] args) {
        String str = "madam";
        String normalize = str.replace("/", "").replace(".", "").toLowerCase();

        boolean isPallendron =IntStream.range(0, normalize.length()/2)
                .allMatch(i -> normalize.charAt(i) == normalize.charAt(normalize.length()-i-1));

        System.out.println("String is Pallendron:"+isPallendron);


        }
}

Remove duplicate characters from a String.

import java.util.stream.IntStream;

public class PalindromeCheck {
    public static void main(String[] args) {
        String str = "madam";
        String normalize = str.replace("/", "").replace(".", "").toLowerCase();

        boolean isPallendron =IntStream.range(0, normalize.length()/2)
                .allMatch(i -> normalize.charAt(i) == normalize.charAt(normalize.length()-i-1));

        System.out.println("String is Pallendron:"+isPallendron);


        }
}

Find the frequency of each character in a String.

import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class CharacterFrequency {
    public static void main(String[] args) {
        String str = "Programming";

        Map<Character, Long> result= str.chars()
                .mapToObj(c -> (char)c)
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        System.out.println(result);
    }
}

Find the longest and shortest word in a given String.

import java.util.Arrays;

import java.util.Comparator;

import java.util.Optional;

 

public class LongestShortestWord {

    public static void main(String[] args)

    {

        String input = "Java 8 makes coding interviews interesting";

 

        // Split into words

        String[] words = input.split("\\s+");

 

        // Find shortest word

        Optional<String> shortest = Arrays.stream(words)

                .min(Comparator.comparingInt(String::length));

 

        // Find longest word

        Optional<String> longest = Arrays.stream(words)

                .max(Comparator.comparingInt(String::length));

 

        System.out.println("Shortest word: " + shortest.orElse(""));

        System.out.println("Longest word: " + longest.orElse(""));

    }

}

Count occurrences of a given substring in a String.

import java.util.stream.IntStream;

public class SubstringCountStream {
    public static void main(String a[])
    {
        String str ="Java is Java again Java again ";
        String subStr = "Java";
        System.out.println("Occurance of SubString :"+occuranceOfSubString(str,subStr));

    }
    public static long occuranceOfSubString(String str, String subStr)
    {
        return IntStream.range(0,str.length() - subStr.length() -1)
                .filter(i -> str.substring(i, i + subStr.length()).equals(subStr)).count();
    }
}

 

 

Check if two Strings are anagrams.

·       import java.util.stream.Collectors;

public class AnagramChecking {
    public static void main(String a[])
    {
        String str1 = "silent";
        String str2 = "listen";
        boolean result = isAnagram(str1,str2);
        System.out.println("String is anagram ----"+ result );
    }
    public static boolean isAnagram(String str1, String str2)
    {
        if (str1.length() != str2.length())
        {
            return false;
        }
        String str3 = str1.chars().sorted().mapToObj(c -> (char)c).map(String::valueOf).collect(Collectors.joining());
        String str4 = str2.chars().sorted().mapToObj(c -> (char)c).map(String::valueOf).collect(Collectors.joining());
        return str3.equals(str4);

    }
}

 

Use Streams to count occurrences of each character in a String.

import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class CharacterCount {
    public static void main(String a[])
    {
        String str = "Brijendra Jaiswal";


        Map<Character, Long> frequencymap = str.chars().mapToObj(c -> (char)c)
                .collect(Collectors.groupingBy(c -> c, Collectors.counting()));

        // Print Result
        frequencymap.forEach((ch, count) ->
                System.out.println("--"+ ch +"--"+count));
    }
}

 

 

Use Streams to find the first non-repeated character in a String.

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SwissFindNonRepeatedChar {
    public static void main(String[] args) {
        //String str ="swiss";
        String str = "BrijendraJaiswal";



       Character result = str.chars()
                .mapToObj(c -> (char)c)
                .collect(Collectors.groupingBy
                        ( c -> c,
                                LinkedHashMap::new,
                                Collectors.counting()))
                .entrySet().stream()
                .filter( ch -> ch.getValue() ==1)
                .map(Map.Entry::getKey)
                //.findFirst()
               .findAny()
               .orElse(null);

       System.out.println(result);
    }
}

 

Use Collectors.joining() to concatenate a list of Strings into a single comma-separated String.

import java.util.*;
import java.util.stream.*;
public class JoiningExample {
    public static void main(String[] args) {
        {
            List<String> names = Arrays.asList("Rajaram","Ravindra","Brijendra","Renu","Chetan");
            String result = names.stream().collect(Collectors.joining("$"));
            System.out.println("******Result *******"+result);
        }
    }
}

 

 

Use StringJoiner to build a delimited String.

import java.util.StringJoiner;

public class JoinerClass {
    public static void main(String a[])
    {
        StringJoiner joiner = new StringJoiner(", ", "[", "]");

        joiner.add("Brijendra");
        joiner.add("Mintu");
        System.out.println(joiner.toString());

    }


}

 

Split a String into words and sort them alphabetically using Streams.

import java.util.stream.IntStream;

public class alphabeticallyShorting
{
    public static void main(String a[])
    {
        String str = "AAnil";
        str.chars().mapToObj(c -> (char)c).sorted().forEach(System.out::println);
    }
}

 

Convert a List<String> into a single String using Streams.

import java.util.Arrays;
import java.util.List;
import java.util.stream.*;

public class ListOfStringIntoSingleString {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Brijendra", "Mintu");
        String result = names.stream().collect(Collectors.joining("-"));
        System.out.println(result);
    }
}

 

Remove duplicates from a String using Streams.

import java.util.stream.Collectors;
import java.util.stream.*;
public class RemoveDuplicate {
    public static void main(String[] args) {
        String str = "banerbaner";
        String result = str.chars()
                            .distinct()
                            .mapToObj(c -> String.valueOf((char)c))
                            .collect(Collectors.joining());
        System.out.println(result);
    }
}

 

 

Find the longest word in a String using Streams.

import java.util.Arrays;
import java.util.Comparator;
import java.util.Optional;

public class longestWord {
    public static void main(String[] args) {
        {
            String sentence = "Brijendra Jaiswal is hard working candidate he never giveup";
            Optional<String>  longWord = Arrays.stream(sentence.split("\\s"))
                    .max(Comparator.comparingInt(String::length));
            longWord.ifPresent(word -> System.out.println(word));
        }
    }
}

 

 

 

 

 

Check if a String contains only digits using Streams.

public class DigitsCheck {
    public static void main(String a[])
    {
        String str1 = "12345";
        String str2 = "12a45";

        boolean isDigit1= str1.chars().allMatch(Character::isDigit);
        boolean isDigit2=str2.chars().allMatch(Character::isDigit);

        System.out.println("------- str1 is "+isDigit1);
        System.out.println("------- str2 is "+isDigit2);
    }
}

Convert a String into a Map<Character, Long> representing frequency counts using Streams.

import java.util.Map;
import java.util.stream.Collectors;

public class frequencyCount {
    public static void main(String a[])
    {
        String str = "banana";

        Map<Character, Long> frequency = str.chars()
                .mapToObj(c -> (char)c)
                .collect(Collectors.groupingBy(c -> c,Collectors.counting()));

        System.out.println(frequency);
    }
}

 

⚡ Advanced Coding Scenarios

Write a program to reverse each word in a sentence while keeping word order intact.

import java.util.Arrays;
import java.util.stream.Collectors;

public class ReverseWords {
    public static void main(String a[])
    {
        String sentence = "I will get success";

        String result = Arrays.stream(sentence.split("\\s"))
                .map(word -> new StringBuilder(word).reverse().toString())
                .collect(Collectors.joining(" "));

        System.out.println("**********"+result);
    }
}

Write a program to capitalize the first letter of each word in a String.

import java.util.Arrays;
import java.util.stream.Collectors;

public class capitalizeFirstLetter {
    public static void main(String[] args) {
        {
            String sentence = "brijendra jaiswal";


            // First Letter is Capital Letter
            String result = Arrays.stream(sentence.split("\\s"))
                    .map (word -> word.substring(0,1).toUpperCase() + word.substring(1).toLowerCase())
                    .collect(Collectors.joining(" "));

            // Reverse the sentence

            String result1 = Arrays.stream(sentence.split("\\s"))
                    .map(word -> new StringBuilder(word).reverse().toString())
                            .collect(Collectors.joining(" "));

            System.out.println("---Reverse String ----"+result1);

                    /*  String result = Arrays.stream(sentence.split("\\s+"))
                    .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1))
                    .collect(Collectors.joining(" "));*/



        }
    }
    }

 

Write a program to check if two Strings are rotations of each other.

public class RotationCheck {
    public static void main(String a[])
    {
        String s1 = "abcd";
        String s2 = "cdab";

        boolean checkRotation = false;
        System.out.println("s1 "+"And "+"s2 is Rotational ?" + checkRotation);
    }

    public static boolean checkRotation(String s1, String s2)
    {
        if(s1 == null || s2 == null || s1.length() != s2.length())
        {
                return false;
        }
        return (s1+s2).contains(s2);
    }
}

Write a program to find all permutations of a String.

import java.util.*;
import java.util.stream.Collectors;
public class GetPermutations {
    public static void main(String[] args) {
        String str ="ABC";
        List<String> permutations = getPermutations("ABC");
        System.out.println("Permutations of " + input + ":");
        permutations.forEach(System.out::println);
    }
    public static List<String> getPermutations(String str) {
        if (str.isEmpty()) {
            return Collections.singletonList("");
        }

        return IntStream.range(0, str.length())
                .mapToObj(i -> {
                    char ch = str.charAt(i);
                    String remaining = str.substring(0, i) + str.substring(i + 1);
                    return getPermutations(remaining).stream()
                            .map(s -> ch + s);
                })
                .flatMap(s -> s)
                .collect(Collectors.toList());
    }

}

 

Write a program to remove all occurrences of a given character from a String.

 

 

1. Write a program to check if a String contains only unique characters.
2. Write a program to find the most repeated word in a sentence using Streams.
3. Write a program to sort characters in a String by frequency using Streams.

---

✅ Interview Tip for You (senior-level):
Don’t just solve these imperatively — show off Java 8 idioms like map(), filter(), flatMap(), Collectors.groupingBy(), and Collectors.joining(). For example, solving “find the first non-repeated character” with a Stream + LinkedHashMap will impress interviewers far more than a simple loop.

---