11) Check Vowel or Consonant in Java:

public class VowelConsonant {

public static void main(String[] args) {

char ch = ‘A’;

if (ch == ‘a’ || ch == ‘e’ || ch == ‘i’ || ch == ‘o’ || ch == ‘u’

|| ch == ‘A’ || ch == ‘E’ || ch == ‘I’ || ch == ‘O’ || ch == ‘U’) {

System.out.println(ch + ” is a vowel.”);

} else {

System.out.println(ch + ” is a consonant.”);

Output:

A is a vowel.
12) Calculate Compound Interest in Java:

public class CompoundInterest {

public static void main(String[] args) {

double principal = 15000, rate = 5.5, time = 3;

double compoundInterest = principal * (Math.pow((1 + rate / 100), time)) –

principal;

System.out.println(“Compound Interest: ” + compoundInterest);

}
Output:

Compound Interest: 2653.4375

13) Java Program to Calculate Simple Interest:

import java.util.Scanner;

public class SimpleInterest {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.print(“Enter principal amount: “);

double principal = input.nextDouble();

System.out.print(“Enter rate of interest: “);

double rate = input.nextDouble();

System.out.print(“Enter time period in years: “);

double time = input.nextDouble();

double simpleInterest = (principal * rate * time) / 100;

System.out.println(“Simple Interest: ” + simpleInterest);

input.close();

Output:

Enter principal amount: 5000

Enter rate of interest: 2.5

Enter time period in years: 3

Simple Interest: 375.0

14) Java Program to Find Quotient and Remainder:

import java.util.Scanner;

public class QuotientRemainder {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.print(“Enter dividend: “);

int dividend = input.nextInt();

System.out.print(“Enter divisor: “);

int divisor = input.nextInt();

int quotient = dividend / divisor;

int remainder = dividend % divisor;

System.out.println(“Quotient: ” + quotient);

System.out.println(“Remainder: ” + remainder);

input.close();

Output:

Enter dividend: 17

Enter divisor: 5

Quotient: 3

Remainder: 2
15) Java Program to Calculate Power of a Number:

import java.util.Scanner;
public class PowerOfNumber {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.print(“Enter base: “);

int base = input.nextInt();

System.out.print(“Enter exponent: “);

int exponent = input.nextInt();

long result = 1;

while (exponent != 0) {

result *= base;

–exponent;

System.out.println(“Result: ” + result);

input.close();

Output:

Enter base: 3

Enter exponent: 4

Result: 81
16) Java Program to Convert char to String and String to Char:

public class CharStringConversion {

public static void main(String[] args) {

// Convert char to String

char ch = ‘A’;

String str = Character.toString(ch);

System.out.println(“Char to String: ” + str);

// Convert String to char

String s = “Hello”;

char c = s.charAt(0);

System.out.println(“String to Char: ” + c);

}
17) Java Program to Find Duplicate Characters in a String:

import java.util.HashMap;

import java.util.Map;

public class DuplicateCharacters {

public static void main(String[] args) {

String str = “programming”;

Map<Character, Integer> charCountMap = new HashMap<>();

for (char ch : str.toCharArray()) {

if (charCountMap.containsKey(ch)) {

charCountMap.put(ch, charCountMap.get(ch) + 1);

} else {

charCountMap.put(ch, 1);

}
}

System.out.println(“Duplicate Characters:”);

for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {

if (entry.getValue() > 1) {

System.out.println(entry.getKey() + ” – ” + entry.getValue() + ” times”);

}
18) Java Program to Check Palindrome String using Stack, Queue, For, and
While loop:

import java.util.LinkedList;

import java.util.Queue;

import java.util.Stack;

public class PalindromeCheck {

public static void main(String[] args) {

String str = “racecar”;

Stack<Character> stack = new Stack<>();

Queue<Character> queue = new LinkedList<>();

for (char ch : str.toCharArray()) {

stack.push(ch);

queue.add(ch);

}
boolean isPalindrome = true;

while (!stack.isEmpty() && !queue.isEmpty()) {

if (!stack.pop().equals(queue.remove())) {

isPalindrome = false;

break;

if (isPalindrome) {

System.out.println(str + ” is a palindrome.”);

} else {

System.out.println(str + ” is not a palindrome.”);

}
19) Java Program to Sort Strings in Alphabetical Order:

import java.util.Arrays;

public class SortStrings {

public static void main(String[] args) {

String[] strings = {“orange”, “apple”, “banana”, “grape”};

Arrays.sort(strings);

System.out.println(“Sorted Strings:”);

for (String s : strings) {

System.out.println(s);
}

}
20) Java Program to Reverse Words in a String:

public class ReverseWords {

public static void main(String[] args) {

String str = “Hello World”;

String[] words = str.split(” “);

StringBuilder reversed = new StringBuilder();

for (int i = words.length – 1; i >= 0; i–) {

reversed.append(words[i]).append(” “);

System.out.println(“Reversed Words: ” + reversed.toString().trim());

}
21) Java Program to perform bubble sort on Strings:

import java.util.Arrays;

public class BubbleSortStrings {

public static void main(String[] args) {

String[] arr = {“banana”, “apple”, “orange”, “grapes”, “pineapple”};

bubbleSort(arr);

System.out.println(“Sorted Array: ” + Arrays.toString(arr));

}
public static void bubbleSort(String[] arr) {

int n = arr.length;

for (int i = 0; i < n – 1; i++) {

for (int j = 0; j < n – i – 1; j++) {

if (arr[j].compareTo(arr[j + 1]) > 0) {

// swap arr[j] and arr[j+1]

String temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

Output:

Sorted Array: [apple, banana, grapes, orange, pineapple]

22) Java program to find occurrence of a character in a String:

public class CharacterOccurrences {

public static void main(String[] args) {

String str = “hello world”;

char ch = ‘o’;

int count = 0;

for (int i = 0; i < str.length(); i++) {

if (str.charAt(i) == ch) {

count++;

System.out.println(“Occurrences of ‘” + ch + “‘ in the string: ” + count);

Output:

Occurrences of ‘o’ in the string: 2

23) Java program to count vowels and consonants in a String:

public class VowelsConsonantsCount {

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 == ‘e’ || ch == ‘i’ || ch == ‘o’ || ch == ‘u’) {

vowels++;

} else if (ch >= ‘a’ && ch <= ‘z’) {

consonants++;

}
System.out.println(“Vowels: ” + vowels);

System.out.println(“Consonants: ” + consonants);

Output:

Vowels: 3

Consonants: 7
24) Java Program to check two strings are anagram or not:

import java.util.Arrays;

public class AnagramCheck {

public static void main(String[] args) {

String str1 = “listen”;

String str2 = “silent”;

boolean isAnagram = checkAnagram(str1, str2);

if (isAnagram) {

System.out.println(str1 + ” and ” + str2 + ” are anagrams.”);

} else {

System.out.println(str1 + ” and ” + str2 + ” are not anagrams.”);

public static boolean checkAnagram(String str1, String str2) {

if (str1.length() != str2.length()) {

return false;
}

char[] chars1 = str1.toCharArray();

char[] chars2 = str2.toCharArray();

Arrays.sort(chars1);

Arrays.sort(chars2);

return Arrays.equals(chars1, chars2);

Output:

listen and silent are anagrams.

25) Java Program to divide a string in ‘n’ equal parts:

public class DivideString {

public static void main(String[] args) {

String str = “abcdefghi”;

int n = 3;

int len = str.length();

int partLength = len / n;

int extraChars = len % n;

int start = 0;

for (int i = 0; i < n; i++) {

int end = start + partLength + (i < extraChars ? 1 : 0);

String part = str.substring(start, end);

System.out.println(“Part ” + (i + 1) + “: ” + part);
start = end;

Output:

Part 1: abc

Part 2: def

Part 3: ghi
26) Java Program to find all subsets of a string:

import java.util.ArrayList;

import java.util.List;

public class SubsetsOfString {

public static void main(String[] args) {

String str = “abc”;

List<String> subsets = new ArrayList<>();

generateSubsets(str, 0, “”, subsets);

System.out.println(“All subsets of \”” + str + “\”: ” + subsets);

private static void generateSubsets(String str, int index, String current,

List<String> subsets) {

if (index == str.length()) {

subsets.add(current);

return;
}

generateSubsets(str, index + 1, current + str.charAt(index), subsets);

generateSubsets(str, index + 1, current, subsets);

Output:

All subsets of “abc”: [, c, b, bc, a, ac, ab, abc]

27) Java Program to find longest substring without repeating characters:

import java.util.HashSet;

import java.util.Set;

public class LongestSubstringWithoutRepeating {

public static void main(String[] args) {

String str = “abcabcbb”;

System.out.println(“Longest substring without repeating characters: ” +

longestSubstring(str));

public static int longestSubstring(String s) {

Set<Character> set = new HashSet<>();

int left = 0, right = 0, maxLen = 0;

while (right < s.length()) {

if (!set.contains(s.charAt(right))) {

set.add(s.charAt(right++));

maxLen = Math.max(maxLen, set.size());

} else {

set.remove(s.charAt(left++));

return maxLen;

Output:

Longest substring without repeating characters: 3

28) Java Program to find longest repeating sequence in a string:

public class LongestRepeatingSequence {

public static void main(String[] args) {

String str = “aabcaabdaab”;

System.out.println(“Longest repeating sequence: ” +

longestRepeatingSequence(str));

public static String longestRepeatingSequence(String str) {

int n = str.length();

int[][] dp = new int[n + 1][n + 1];

int longest = 0, endIndex = 0;

for (int i = 1; i <= n; i++) {

for (int j = i + 1; j <= n; j++) {

if (str.charAt(i – 1) == str.charAt(j – 1) && dp[i – 1][j – 1] < (j – i)) {

dp[i][j] = dp[i – 1][j – 1] + 1;

if (dp[i][j] > longest) {

longest = dp[i][j];

endIndex = i;

} else {

dp[i][j] = 0;

return str.substring(endIndex – longest, endIndex);

Output:

Longest repeating sequence: aab

29) Java Program to remove all the white spaces from a string:

public class RemoveWhiteSpaces {

public static void main(String[] args) {

String str = “This is a test string”;

String trimmedStr = removeWhiteSpaces(str);

System.out.println(“String after removing white spaces: \”” + trimmedStr +

“\””);

}
public static String removeWhiteSpaces(String str) {

return str.replaceAll(“\\s”, “”);

Output:

String after removing white spaces: “Thisisateststring”

30) Program to find number of elements in an array:

public class ArrayLength {

public static void main(String[] args) {

int[] array = {1, 2, 3, 4, 5};

int length = array.length;

System.out.println(“Number of elements in the array: ” + length);

Output:

Number of elements in the array: 5

31) Java Program to Calculate average of numbers using Array:

public class AverageOfArray {

public static void main(String[] args) {

int[] array = {5, 10, 15, 20, 25};

int sum = 0;

for (int num : array) {

sum += num;
}

double average = (double) sum / array.length;

System.out.println(“Average of numbers in the array: ” + average);

Output:

Average of numbers in the array: 15.0

32) Java Program to Add the elements of an Array:

public class ArraySum {

public static void main(String[] args) {

int[] array = {1, 2, 3, 4, 5};

int sum = 0;

for (int num : array) {

sum += num;

System.out.println(“Sum of elements in the array: ” + sum);

Output:

Sum of elements in the array: 15

33) Java Program to reverse an array:

import java.util.Arrays;

public class ReverseArray {

public static void main(String[] args) {

int[] array = {1, 2, 3, 4, 5};

reverseArray(array);

System.out.println(“Reversed array: ” + Arrays.toString(array));

public static void reverseArray(int[] array) {

int start = 0;

int end = array.length – 1;

while (start < end) {

int temp = array[start];

array[start] = array[end];

array[end] = temp;

start++;

end–;

Output:

Reversed array: [5, 4, 3, 2, 1]

34) Java Program to sort an array in ascending order:

import java.util.Arrays;

public class SortArray {

public static void main(String[] args) {

int[] array = {5, 3, 9, 1, 7};

Arrays.sort(array);

System.out.println(“Sorted array in ascending order: ” +

Arrays.toString(array));

Output:

Sorted array in ascending order: [1, 3, 5, 7, 9]

35) Java Program to convert char Array to String:

public class CharArrayToString {

public static void main(String[] args) {

char[] charArray = {‘h’, ‘e’, ‘l’, ‘l’, ‘o’};

String str = new String(charArray);

System.out.println(“Converted String: ” + str);

Output:

Converted String: hello