🧠 Java 8 Extended Examples Showcase

🔁 1. First Repeated Character

Finds the first character that appears more than once in a given string.


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

public class FirstRepeatedCharacter {
    public static void main(String[] args) {
        String input = "programming";
        Set<Character> seen = new HashSet<>();
        for (char c : input.toCharArray()) {
            if (!seen.add(c)) {
                System.out.println("First repeated character: " + c);
                break;
            }
        }
    }
}

📊 2. Frequency of Each Character

Uses Streams to count how often each character appears 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 input = "hello world";
        Map<String, Long> freq = input.chars()
            .mapToObj(c -> String.valueOf((char)c))
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        System.out.println(freq);
    }
}

🎯 3. Find Common Elements

Finds common values shared between two lists using Stream filtering.


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

public class CommonElements {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list2 = Arrays.asList(3, 4, 5, 6, 7);

        List<Integer> common = list1.stream()
            .filter(list2::contains)
            .collect(Collectors.toList());

        System.out.println("Common Elements: " + common);
    }
}

🔗 Join Strings with Delimiters

Uses Java Streams to join words with a comma and wraps them in square brackets — excellent for formatting output!


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

public class AddDlimetersWithInStrings {
    public static void main(String[] str){
        List<String> input = Arrays.asList("Rajesh", "Kumar", "R4R");
        String outputStr = input.stream()
                                .collect(Collectors.joining(",", "[", "]"));
        System.out.println(outputStr);
    }
}

Output
[Rajesh,Kumar,R4R]

🔤 Capitalize First Letter of Each Word

This snippet takes a sentence and transforms it so each word starts with an uppercase letter.


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

public class CapitalizeFirstLetters {
    public static void main(String[] args) {
        String str = "i am rajesh kumar from wipro";
        String output = Arrays.stream(str.split(" "))
                              .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1))
                              .collect(Collectors.joining(" "));
        System.out.println(output);
    }
}

Output
I Am Rajesh Kumar From Wipro

Java Code: Duplicate Characters in a String

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

public class DuplicateCharactersInAString {
    public static void main(String[] args) {
        String input = "java is programing language";
        Set<String> set = new HashSet<>();
        Set<String> duplicateCharacters = Arrays.stream(input.split(""))
            .filter(ch -> !set.add(ch))
            .collect(Collectors.toSet());
        System.out.println(duplicateCharacters);
    }
}

Output
[a, g, i, n, o, r, s, u]

Java Code: Extract Duplicate Integers

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class ExtactDuplicateElements {
    public static void main(String[] str) {
        List<Integer> integerList = Arrays.asList(12, 12, 3, 2, 1, 10, 30, 9, 10);
        Set<Integer> set = new HashSet<>();
        Set<Integer> duplicateElements = integerList.stream()
            .filter(e -> !set.add(e))
            .collect(Collectors.toSet());
        System.out.println(duplicateElements);
    }
}

Output
[10, 12]

Java Code: Fibonacci Series Using Stream

import java.util.stream.Stream;

public class FibonacciSeries {
    public static void main(String[] str) {
        Stream.iterate(new int[]{0, 1}, f -> new int[]{f[1], f[0] + f[1]})
            .limit(10)
            .map(f -> f[0])
            .forEach(i -> System.out.println(i + " "));
    }
}

Java Code: Filter Strings Starting with 'R'

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

public class FilterByStratSpecificCharcter {

    public static void main(String[] atr) {
        
        String[] str = new String[]{"Rajesh", "Kumar", "Verma", "Brijehs", "Suresh", "Rani", "Rahul"};

        List<String> output = Arrays.stream(str)
            .filter(x -> x.startsWith("R"))
            .collect(Collectors.toList());

        System.out.println(output);
    }
}

Java Code: Calculate Average Age by Gender

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

public class FindAverageAgeOfMaleAndFemale {
    public static void main(String[] arg) {
        List<Emp> list = getData();
        Map<String, Double> m = list.stream()
            .collect(Collectors.groupingBy(Emp::gender, Collectors.averagingDouble(Emp::age)));
        System.out.println(m);
    }

    record Emp(int id, String name, String gender, int age) {}

    static List<Emp> getData() {
        List<Emp> list = new ArrayList<>();
        list.add(new Emp(1, "Rajesh", "M", 24));
        list.add(new Emp(1, "Brijesh", "M", 23));
        list.add(new Emp(1, "Suresh", "M", 22));
        list.add(new Emp(1, "Suman", "F", 21));
        list.add(new Emp(1, "Sudha", "F", 25));
        list.add(new Emp(1, "Rani", "F", 26));
        return list;
    }
}

Java Code: Calculate Age from Birthdate

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class FindBirthday {
    public static void main(String[] args) {
        LocalDate birthDay = LocalDate.of(1982, 07, 21);
        LocalDate today = LocalDate.now();
        System.out.println(ChronoUnit.YEARS.between(birthDay, today));
    }
}

Java Code: Find Common Elements Between Two Lists

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

public class FindCommonElements {
    public static void main(String[] str) {
        List<Integer> input1 = Arrays.asList(12, 18, 19, 26);
        List<Integer> input2 = Arrays.asList(12, 19, 20, 23);
        List<Integer> commonElements = input1.stream()
            .filter(input2::contains)
            .collect(Collectors.toList());
        System.out.println(commonElements);
    }
}

Java Code: Find Highest Salary by Department

import java.util.*;
import java.util.stream.Collectors;

public class FindHighestSalary {
    public static void main(String[] arg) {
        List<Emp> empList = getData();
        Map<String, Emp> map = empList.stream()
            .collect(Collectors.groupingBy(Emp::department,
                Collectors.collectingAndThen(
                    Collectors.maxBy(Comparator.comparingDouble(Emp::salary)),
                    Optional::get
                )
            ));
        System.out.println(map);
    }

    record Emp(int id, String name, String department, double salary) {}

    static List<Emp> getData() {
        List<Emp> list = new ArrayList<>();
        list.add(new Emp(1, "Rajesh", "IT", 24.10));
        list.add(new Emp(1, "Brijesh", "EC", 23));
        list.add(new Emp(1, "Suresh", "IT", 22));
        list.add(new Emp(1, "Suman", "EC", 21));
        list.add(new Emp(1, "Sudha", "EC", 25));
        list.add(new Emp(1, "Rani", "IT", 26));
        return list;
    }
}

Java Code: First 10 Even Numbers Using IntStream

import java.util.stream.*;

public class First10EvenNumbers {
    public static void main(String[] str) {
        IntStream.range(1, 10)
            .map(i -> i * 2)
            .forEach(System.out::println);
    }
}

Java Code: First Repeated Character in a String

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

public class FirstRepeatedCharacterInAString {
    public static void main(String[] args) {
        String inputString = "Rajesh Kumar is from Kanpur";
        Map<String, Long> charCountMap = Arrays.stream(inputString.split(""))
            .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()));

        String firstRepeatedChar = charCountMap.entrySet().stream()
            .filter(entry -> entry.getValue() > 1)
            .map(Map.Entry::getKey)
            .findFirst()
            .get();

        System.out.println(firstRepeatedChar);
    }
}

Java Code: Frequency of Each Character in a String

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

public class FrequencyOfEachCharachterInString {
    public static void main(String[] str) {
        String input = "my name is rajesh kumar";

        Map<Character, Long> output = input.chars()
            .mapToObj(c -> (char) c)
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        System.out.println(output);

        Map<Character, List<Character>> outList = input.chars()
            .mapToObj(c -> (char) c)
            .filter(c -> c != ' ')
            .collect(Collectors.groupingBy(Function.identity()));
        System.out.println(outList);
    }
}

Java Code: Get Last Element of a List

import java.util.Arrays;
import java.util.List;

public class GetLastElementOfAnArray {
    public static void main(String[] args) {
        List<String> listOfStrings = Arrays.asList(
            "One", "Two", "Three", 
            "Four", "Five", "Six"
        );
        String lastelement = listOfStrings.stream()
            .skip(listOfStrings.size() - 1)
            .findFirst()
            .get();
        System.out.println(lastelement);
    }
}

Java Code: Get Top 3 Max and Min from a List

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

public class GetThreeMaxAndMin {
    public static void main(String[] str) {
        List<Integer> input = Arrays.asList(
            12, 2, 3, 4, 12, 5, 
            60, 23, 14, 15, 16, 
            17, 19, 18
        );

        System.out.print("Three max: ");
        List<Integer> threeMax = input.stream()
            .sorted(Comparator.reverseOrder())
            .limit(3)
            .collect(Collectors.toList());
        System.out.println(threeMax);

        System.out.println("Three min: " + input.stream()
            .sorted()
            .limit(3)
            .collect(Collectors.toList()));
    }
}

Java Code: Find Max and Min Values

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class MaxAnsMin {
    public static void main(String[] str) {
        List<Integer> input = Arrays.asList(
            1, 2, 3, 
            10, 20, 21, 
            70, 80, 90
        );
        System.out.println("Max: " + input.stream()
            .max(Comparator.naturalOrder()).get());
        System.out.println("Min: " + input.stream()
            .min(Comparator.naturalOrder()).get());
    }
}

Java Code: Merge Two Arrays Without Duplicates

import java.util.Arrays;
import java.util.stream.IntStream;

public class MergeTwoUnsortedArraysInOneWithoutDuplicate {
    public static void main(String[] str) {
        int[] a = new int[]{1, 3, 4, 5, 6, 7, 8, 10};
        int[] b = new int[]{3, 12, 13, 14, 15};
        int[] c = IntStream.concat(Arrays.stream(a), Arrays.stream(b))
            .distinct()
            .toArray();
        System.out.println(Arrays.toString(c));
    }
}

Java Code: Most Repeated Element in an Array

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class MostRepeatedElementInAnArray {
    public static void main(String[] str) {
        List<String> input = Arrays.asList(
            "Rajesh", "Kumar", "Verma", "Rajesh"
        );
        
        Map<String, Long> map = input.stream()
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        
        Map.Entry<String, Long> output = map.entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .get();
        
        System.out.println("Word: " + output.getKey() + 
                           " , Frequency: " + output.getValue());
    }
}

Java Code: First Non-Repeated Character

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

public class NoneRepeatedCharacter {
    public static void main(String[] str) {
        String input = "Rajesh Kumar";
        
        Map<String, Long> charCountMap = Arrays.stream(input.split(""))
            .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()));
        
        String firstNonRepeatedChar = charCountMap.entrySet().stream()
            .filter(entry -> entry.getValue() == 1)
            .map(entry -> entry.getKey())
            .findFirst()
            .get();
        
        System.out.println("First non-repeated character : " + firstNonRepeatedChar);
    }
}

Java Code: Employees Grouped by Department

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

public class NumberofEmployeesInEachDepartment {
    record Emp(int id, String name, String departments, double salary) {}
    
    public static void main(String[] args) {
        List<Emp> empList = getEmployeesData();
        
        System.out.println("\n Print employees Departments wise..");
        Map<String, List<Emp>> map = empList.stream()
            .collect(Collectors.groupingBy(Emp::departments));
        System.out.println(map);
        
        System.out.println("\n Count Employees by Departments wise..");
        Map<String, Long> mapCounting = empList.stream()
            .collect(Collectors.groupingBy(Emp::departments, Collectors.counting()));
        System.out.println(mapCounting);
    }

    private static List<Emp> getEmployeesData() {
        List<Emp> empList = new ArrayList<>();
        empList.add(new Emp(1, "Rajesh", "IT", 1200.10));
        empList.add(new Emp(2, "Brijesh", "EC", 1200.20));
        empList.add(new Emp(3, "Rakesh", "IT", 1200.30));
        empList.add(new Emp(4, "Bimal", "IT", 1200.40));
        empList.add(new Emp(5, "Amit", "AC", 1200.50));
        empList.add(new Emp(6, "Pawan", "IT", 1200.60));
        empList.add(new Emp(7, "Meena", "IT", 1200.70));
        empList.add(new Emp(8, "Juhi", "LW", 1201.20));
        empList.add(new Emp(9, "Reena", "MD", 1210.30));
        return empList;
    }
}

Java Code: Palindrome Checker

import java.util.stream.IntStream;

public class PalindromeProgram {
    public static void main(String[] str) {
        String palindrome = "ROTATOR";
        
        boolean isPalindrome = IntStream.range(0, palindrome.length() / 2)
            .noneMatch(i -> palindrome.charAt(i) != palindrome.charAt(palindrome.length() - i - 1));
        
        if (isPalindrome)
            System.out.println(palindrome + " is Palindrome.");
        else
            System.out.println(palindrome + " is not Palindrome.");
    }
}

Java Code: Numbers Divisible by 5

import java.util.Arrays;
import java.util.List;

public class PrintDividedBy5 {
    public static void main(String[] str) {
        List<Integer> input = Arrays.asList(1, 2, 3, 4, 60, 5, 7, 8, 40, 10, 24, 25);
        
        input.stream()
            .filter(f -> f % 5 == 0)
            .forEach(System.out::println);
    }
}

Java Code: Remove Duplicates Using Stream

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

import static java.lang.System.out;

public class RemoveDuplicateFromList {
    public static void main(String[] str) {

        List<Integer> input = Arrays.asList(1, 2, 3, 4, 5, 3, 2, 1, 2, 2, 2, 4);
        List<Integer> output = input.stream()
            .distinct()
            .collect(Collectors.toList());
        System.out.println(output);

        List<String> inputStr = Arrays.asList("Rajesh", "Kumar", "Kumar", "Rajesh");
        List<String> outputStr = inputStr.stream()
            .distinct()
            .collect(Collectors.toList());
        System.out.println(outputStr);
    }
}

Java Code: Reverse an Integer Array

import java.util.Arrays;
import java.util.stream.IntStream;

public class ReverseAnIntgerArray {
    public static void main(String[] str) {
        int[] inputArray = new int[]{2, 3, 1, 4, 8, 19};
        int[] outputArray = IntStream.rangeClosed(1, inputArray.length)
            .map(f -> inputArray[inputArray.length - f])
            .toArray();
        System.out.println(Arrays.toString(outputArray));
    }
}

Java Code: Reverse Each Word

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

public class ReverseEachWord {
    public static void main(String[] str) {
        String input = "My name is Rajesh Kumar";
        String reversedStr = Arrays.stream(input.split(" "))
            .map(sb -> new StringBuffer(sb).reverse())
            .collect(Collectors.joining(" "));
        System.out.println(reversedStr);
    }
}

Java Code: Second Largest Number in Array

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class SecondLargestNumberInAnIntegerArray {
    public static void main(String[] str) {
        List<Integer> input = Arrays.asList(
            4, 5, 6, 7, 8, 9, 
            10, 11, 12, 13, 14, 15, 
            16, 17, 18, 19, 20, 21
        );
        
        Integer secondLargestNumber = input.stream()
            .sorted(Comparator.reverseOrder())
            .skip(1)
            .findFirst()
            .get();
        
        System.out.println(secondLargestNumber);
    }
}

Java Code: Separate Odd and Even Numbers

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

public class SeperateOddAndEvenNumbers {

    public static void main(String str[]) {
        List<Integer> input = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Map<Boolean, List<Integer>> map = input.stream()
            .collect(Collectors.partitioningBy(s -> s % 2 == 0));
        System.out.println("Odd: " + map.get(false));
        System.out.println("Even: " + map.get(true));
    }
}

Java Code: Smallest String by Length

import java.util.Arrays;

public class SmallestString {

    public static void main(String[] args) {
        String[] input = new String[]{"Java", "C", "C++", "Pythone"};
        
        String output = Arrays.stream(input)
            .reduce((a, b) -> a.length() > b.length() ? b : a)
            .orElse("-1");
        
        System.out.println("Smallest String: " + output);
    }
}

Java Code: Sort Strings by Length

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

public class SortByLength {
    public static void main(String[] str) {
        List<String> input = Arrays.asList("Rajesh", "Kumar", "Java", "R4R");
        
        List<String> output = input.stream()
            .sorted(Comparator.comparing(String::length))
            .collect(Collectors.toList());
        
        System.out.println(output);
    }
}

Java Code: Reverse Sort of Decimal Numbers

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

public class SortDecimalsInReverseOrder {
    public static void main(String str[]) {
        List<Double> input = Arrays.asList(12.10, 11.10, 9.10, 8.10, 11.0);
        
        List<Double> reversed = input.stream()
            .sorted(Comparator.reverseOrder())
            .collect(Collectors.toList());
        
        System.out.println(reversed);
    }
}

Java Code: Sort Employees by Department and Salary

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class SortingTheEmployeesSalaryDepartmentWiseInAscendingOrder {
    public static void main(String[] str) {
        List<Emp> listEmp = new ArrayList<>();
        listEmp.add(new Emp(1, "Rajesh", 1100.00, "IT"));
        listEmp.add(new Emp(1, "Rahul", 12010.00, "IT"));
        listEmp.add(new Emp(1, "Ritu", 1202.00, "DEV"));
        listEmp.add(new Emp(1, "Ayushi", 1204.00, "IT"));
        listEmp.add(new Emp(1, "Abhijeet", 1260.00, "IT"));
        listEmp.add(new Emp(1, "Gunas", 1209.00, "DEV"));

        Map<String, Stream<Emp>> sortedEmpByDepartment = listEmp.stream().collect(
            Collectors.groupingBy(Emp::department,
                Collectors.collectingAndThen(Collectors.toList(),
                    list -> list.stream()
                        .sorted(Comparator.comparingDouble(Emp::salary).reversed())
                )
            )
        );

        sortedEmpByDepartment.forEach((dept, empStream) -> {
            System.out.println(dept);
            System.out.println(empStream.collect(Collectors.toList()));
        });
    }

    record Emp(int id, String name, double salary, String department) {}
}

Java Code: Sort Employees by Department (Descending Salary)

import java.util.*;
import java.util.stream.Collectors;

public class SortingTheEmployeesSalaryDepartmentWiseInDescendingOrder {

    record Emp(int id, String name, double salary, String dep) {}

    public static void main(String[] arg) {
        List<Emp> empList = new ArrayList<>();
        empList.add(new Emp(1, "Rajesh", 1200.10, "DEV"));
        empList.add(new Emp(2, "Rani", 1200.20, "DEV"));
        empList.add(new Emp(3, "Brijesh", 1200.30, "IT"));
        empList.add(new Emp(4, "Rakesh", 1200.10, "IT"));

        Map<String, List<Emp>> sortedEmpByDepartment = empList.stream()
            .collect(Collectors.groupingBy(Emp::dep,
                Collectors.collectingAndThen(Collectors.toList(),
                    list -> list.stream()
                        .sorted(Comparator.comparingDouble(Emp::salary).reversed())
                        .collect(Collectors.toList())
                )
            ));

        sortedEmpByDepartment.forEach((deptName, list) -> {
            System.out.println(deptName);
            list.forEach(System.out::println);
        });
    }
}

Java Code: Strings Starting with a Number

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

public class StringStartWithNumber {

    public static void main(String[] str) {
        List<String> listOfString = Arrays.asList("One", "2Two", "Four",
                                                   "Five", "6Six", "7Seven");
                                                   
        List<String> startWithDigit = listOfString.stream()
            .filter(s -> Character.isDigit(s.charAt(0)))
            .collect(Collectors.toList());
        
        System.out.println(startWithDigit);
    }
}

Java Code: Sum All Digits of an Integer

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class SumAllDigitsOfANumber {
    public static void main(String[] str) {
        int i = 1234;
        Integer sumOfDigits = Stream.of(String.valueOf(i).split(""))
            .collect(Collectors.summingInt(Integer::parseInt));
        System.out.println("Sum:-" + sumOfDigits);
    }
}

Java Code: Sum and Average of Array Elements

import java.util.Arrays;

public class SumAndAverageOfAllElements {
    public static void main(String[] str) {
        int[] input = new int[]{12, 13, 24, 45, 65, 
                        34, 67, 89, 60, 80, 70};
        
        System.out.println("Sum: " + Arrays.stream(input).sum());
        System.out.println("Average: " + Arrays.stream(input).average().getAsDouble());
    }
}

Java Code: Sum of First 10 Natural Numbers

import java.util.stream.IntStream;

public class SumOfFirst10NaturalNumbers {
    public static void main(String[] str) {
        int sum = IntStream.range(1, 11).sum();
        System.out.println(sum);
    }
}

Java Code: Two Strings Are Anagrams or Not

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TwoStringsAreAnagramsOrNot {

    public static void main(String[] str) {
        String s1 = "RaceCar";
        String s2 = "CarRace";
        
        s1 = Stream.of(s1.split(""))
                  .map(String::toLowerCase)
                  .sorted()
                  .collect(Collectors.joining());
                  
        s2 = Stream.of(s2.split(""))
                  .map(String::toLowerCase)
                  .sorted()
                  .collect(Collectors.joining());

        if (s1.equals(s2))
            System.out.println("Strings are anagrams..");
        else
            System.out.println("Strings are not anagrams..");
    }
}