String s1 = new String("JavaProgramTo.com");
String s2 = "welcome, Java developer";
package com.javaprogramto.convert.chartostring;
/**
* example to convert char to string in java using Character.toString() method.
*
* @author javaprogramto.com
*
*/
public class CharToStringExample1 {
public static void main(String[] args) {
// example 1
char ch = 'c';
String strC = Character.toString(ch);
System.out.println("Example 1: ");
System.out.println("Char in String : " + strC);
System.out.println("returned string length : " + strC.length());
// example 2
char ch2 = 'z';
String strZ = Character.toString(ch2);
System.out.println("\nExample 2: ");
System.out.println("Char in String : " + strZ);
System.out.println("returned string length : " + strZ.length());
}
}
Example 1: Char in String : c returned string length : 1 Example 2: Char in String : z returned string length : 1
package com.javaprogramto.convert.chartostring;
/**
* example to convert char to string in java using String.valueOf() method.
*
* @author javaprogramto.com
*
*/
public class CharToStringExample2 {
public static void main(String[] args) {
// example 1
char ch3 = 'x';
String strC = String.valueOf(ch3);
System.out.println("String.valueOf Example 1: ");
System.out.println("Char in String : " + strC);
System.out.println("returned string length : " + strC.length());
// example 2
char ch4 = '7';
String strZ = String.valueOf(ch4);
System.out.println("\nString.valueOf Example 2: ");
System.out.println("Char in String : " + strZ);
System.out.println("returned string length : " + strZ.length());
}
}
String.valueOf Example 1: Char in String : x returned string length : 1 String.valueOf Example 2: Char in String : 7 returned string length : 1
package com.javaprogramto.convert.chartostring;
/**
* char to string using + operator
*
* @author javaprogramto.com
*
*/
public class CharToStringExample3 {
public static void main(String[] args) {
char ch3 = 'x';
String returnedString = "" + ch3;
System.out.println("Returned string 1 : " + returnedString);
char ch1 = 'a';
String returnedString2 = "" + ch1;
System.out.println("Returned string 2 : " + returnedString2);
char ch2 = 'b';
String returnedString3 = "" + ch2;
System.out.println("Returned string 3 : " + returnedString3);
}
}
Returned string 1 : x Returned string 2 : a Returned string 3 : b
package com.javaprogramto.programs.strings.tolong;
public class StringToLongExample {
public static void main(String[] args) {
String positiveString = "12345";
long longvalue1 = Long.parseLong(positiveString);
System.out.println("Positive Long value 1 : " + longvalue1);
String positiveString2 = "+12345";
long longvalue2 = Long.parseLong(positiveString2);
System.out.println("Positive Long value 2 : " + longvalue2);
String negativeValue1 = "-12345";
long longvalue3 = Long.parseLong(negativeValue1);
System.out.println("Negative Long value 3 : " + longvalue3);
}
}
Positive Long value 1 : 12345 Positive Long value 2 : 12345 Negative Long value 3 : -12345
package com.javaprogramto.programs.strings.tolong;
public class StringToLongExample {
public static void main(String[] args) {
String positiveString = "12345";
long longvalue1 = Long.parseLong(positiveString);
System.out.println("Positive Long value 1 : " + longvalue1);
String positiveString2 = "+12345";
long longvalue2 = Long.parseLong(positiveString2);
System.out.println("Positive Long value 2 : " + longvalue2);
String negativeValue1 = "-12345";
long longvalue3 = Long.parseLong(negativeValue1);
System.out.println("Negative Long value 3 : " + longvalue3);
}
}
package com.javaprogramto.programs.strings.tolong;
public class StringToLongExample3 {
public static void main(String[] args) {
String positiveString = "12345";
Long longvalue1 = new Long(positiveString);
System.out.println("Positive Long value 1 : " + longvalue1);
String positiveString2 = "+12345";
Long longvalue2 = new Long(positiveString2);
System.out.println("Positive Long value 2 : " + longvalue2);
String negativeValue1 = "-12345";
Long longvalue3 = new Long(negativeValue1);
System.out.println("Negative Long value 3 : " + longvalue3);
}
}
package com.javaprogramto.programs.strings.tolong;
public class StringToLongExample4 {
public static void main(String[] args) {
long one = Long.parseLong("abc133");
Long two = Long.valueOf("abc133");
Long three = new Long("abc133");
}
}
Exception in thread "main" java.lang.NumberFormatException: For input string: "abc133" at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:68) at java.base/java.lang.Long.parseLong(Long.java:707) at java.base/java.lang.Long.parseLong(Long.java:832) at com.javaprogramto.programs.strings.tolong.StringToLongExample4.main(StringToLongExample4.java:7)
package com.javaprogramto.programs.strings;
public class StrintSubSequnceIterativeExample {
public static void main(String[] args) {
String otherString = "ABCDE";
String subsequence = "ACE";
boolean isValidSubsequence = checkSubsequence(otherString, subsequence);
System.out.println(isValidSubsequence);
otherString = "ABCDE";
subsequence = "AEC";
isValidSubsequence = checkSubsequence(otherString, subsequence);
System.out.println(isValidSubsequence);
}
private static boolean checkSubsequence(String otherString, String subsequence) {
// if the subsequence length is greather than subsequence, then inputs are not
// valid and not subsequence.
if (otherString.length() < subsequence.length()) {
return false;
}
int subsequenceIndex = 0;
for (int otherStringIndex = 0; otherStringIndex < otherString.length(); otherStringIndex++) {
// whether there is a match or not with other string. we will increment other
// string index by 1 always.
if (otherString.charAt(otherStringIndex) == subsequence.charAt(subsequenceIndex)) {
// if both characters are matching then incrementing the index of subsequence
// string.
subsequenceIndex++;
}
}
// always subsequence length and sub sequence index should be same for a valid
// sub sequence.
return subsequence.length() == subsequenceIndex;
}
}
true false
package com.javaprogramto.programs.strings.subsequence;
public class StrintSubSequnceRecursiveExample {
public static void main(String[] args) {
String otherString = "ABCDE";
String subsequence = "ACE";
boolean isValidSubsequence = checkSubsequence(otherString, subsequence, otherString.length(),
subsequence.length());
System.out.println(isValidSubsequence);
otherString = "ABCDE";
subsequence = "AEC";
isValidSubsequence = checkSubsequence(otherString, subsequence, otherString.length(), subsequence.length());
System.out.println(isValidSubsequence);
}
private static boolean checkSubsequence(String otherString, String subsequence, int otherLength, int subLength) {
// if at any point if the sub sequence length becomes zero mean all character of
// sub sequence are matched
// or if other is reached 0 index and sub sequences also reached 0 index at the
// same time then it is a valid sub sequence. so because of this we are first
// checking the sub sequence length 0
if (subLength == 0) {
return true;
}
if (otherLength == 0) {
return false;
}
// comparing the last characters first and then going backward for the previous
// letters comparison.
if (otherString.charAt(otherLength - 1) == subsequence.charAt(subLength - 1)) {
// if matched then decrement the legth for the both strings.
return checkSubsequence(otherString, subsequence, otherLength - 1, subLength - 1);
} else {
// if no match then decrement only for the other string. because sub sequence
// current character is not matched yet
return checkSubsequence(otherString, subsequence, otherLength - 1, subLength);
}
}
}
In this tutorial, We'll learn how to check if the two given strings are anagrams or not in java programming language.
Anagram means two string should be same characters but order is not important. So, that means characters can be another order.
Note that character count also should be matched. Suppose if the string1 has 10 chars where as string 2 has 9 characters so these two are not anagams.
Example 1:
String 1: "abaac"
String 2: "caaba"
Output: true
Example 2:
String 1: "listen"
String 2: "silent"
Output: true
Example 3:
String 1: "aap"
String 2: "pap"
Output: false
First solution is sort the first two string characters and then compare them. If both strings are same then these two strings are anagrams. If the two strings are not same then strings are not anagrams.
Use Arrays.sort() method to sort the string character as char array.
Use String.equals() method to compare the two strings contents.
Look at the below code.
Time complexicity: O(nlogn)
package com.javaprogramto.programs.strings.anagrams;
import java.util.Arrays;
public class CheckStringsAnagramsExample {
public static void main(String[] args) {
String str1 = "abaac";
String str2 = "caaba";
boolean isAnagram = isStrinsAnagrams(str1, str2);
System.out.println(isAnagram);
str1 = "listen";
str2 = "silent";
isAnagram = isStrinsAnagrams(str1, str2);
System.out.println(isAnagram);
str1 = "aap";
str2 = "pap";
isAnagram = isStrinsAnagrams(str1, str2);
System.out.println(isAnagram);
}
private static boolean isStrinsAnagrams(String str1, String str2) {
// converting str1 to char array
char[] strCharArray1 = str1.toCharArray();
// converting str2 to char array
char[] strCharArray2 = str2.toCharArray();
// sorting two strings char arrays using Arrays.sort() method
Arrays.sort(strCharArray1);
Arrays.sort(strCharArray2);
// converting char arrays back to strings
str1 = new String(strCharArray1);
str2 = new String(strCharArray2);
// comparing two strings
if (str1.equals(str2))
return true;
return false;
}
}
Output:
true true false
The above solution takes nlogn logarthemetic execution time. This may not work for the larger input data.
We need to always think before using sorting logic on any problem.
To avoid sorting, we need to think different for better approach.
Here is problem is we need to check each and every character of string 1 is present in the string 2.
Actually, for this problem sorting is not an efficient answer.
We will take one integer array with size of 256. This value is the typical characters are stored in 8 bits so there will be only 256 possible characters.
By default, all values in the int array are initialized with 0.
First, Take the each character from the string and go to the corresponding location in the int array increaemtn by 1 and repeat the same process.
Next, take the each character from second string and go the corresponding location in the same int array, decrement the value 1.
If the one character is present in both strings then first count is increment by 1 and decreemnted by 1. So, count value in the int array becomes 0.
If the one character is present in the first array and the same character element is not present in the second string then the value in the count array will non zero value.
After traversing the two strings, we will check the counts int array values, if any index value is non zero then two strings are not anagrams.
If all values in the count array is zero then inputs are anagrams.
Look at the below code.
package com.javaprogramto.programs.strings.anagrams;
public class CheckStringsAnagramsExample2 {
public static void main(String[] args) {
String str1 = "abaac";
String str2 = "caaba";
boolean isAnagram = isStrinsAnagramsOptimized(str1, str2);
System.out.println(isAnagram);
str1 = "listen";
str2 = "silent";
isAnagram = isStrinsAnagramsOptimized(str1, str2);
System.out.println(isAnagram);
str1 = "aap";
str2 = "pap";
isAnagram = isStrinsAnagramsOptimized(str1, str2);
System.out.println(isAnagram);
}
private static boolean isStrinsAnagramsOptimized(String str1, String str2) {
// if two strings lengths are not same then return false
if (str1.length() != str2.length()) {
return false;
}
int arraySize = 256;
int[] countsArray = new int[arraySize];
// increment by 1 from str1, decrement by 1 from str2
for (int i = 0; i < str1.length(); i++) {
countsArray[str1.charAt(i)]++;
countsArray[str2.charAt(i)]--;
}
// checking any value is non zero in the counts arrray.
for (int i = 0; i < countsArray.length; i++) {
if (countsArray[i] != 0) {
return false;
}
}
return true;
}
}
Output:
true true false
This code also generates the same output with O(n).
Time complexity: O(n)
Space complexity: O(256)
In this tutorial, We've seen how to check if the two strings are Anagrams or not in java.
package com.javaprogramto.programs.strings.substring.count;
public class SubstringCountExample {
public static void main(String[] args) {
int count = countSubStringInString("222", "22");
System.out.println(count);
count = countSubStringInString("madam", "ma");
System.out.println(count);
}
public static int countSubStringInString(String string, String toFind) {
int position = 0;
int count = 0;
while ((position = string.indexOf(toFind, position)) != -1) {
position = position + 1;
count++;
}
return count;
}
}
2 1
package com.javaprogramto.programs.strings.substring.count;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SubstringCountExample2 {
public static void main(String[] args) {
int count = countSubStringInString("222", "22");
System.out.println(count);
count = countSubStringInString("madam", "ma");
System.out.println(count);
}
public static int countSubStringInString(String string, String toFind) {
Pattern pattern = Pattern.compile(Pattern.quote(toFind));
Matcher matcher = pattern.matcher(string);
int position = 0;
int count = 0;
while (matcher.find(position)) {
position = matcher.start() + 1;
count++;
}
return count;
}
}
package com.javaprogramto.programs.strings.substring.count;
public class SubstringCountExample3 {
public static void main(String[] args) {
int count = countSubStringInString("22222", "22");
System.out.println(count);
count = countSubStringInString("madam", "ma");
System.out.println(count);
}
public static int countSubStringInString(String string, String toFind) {
int M = toFind.length();
int N = string.length();
int res = 0;
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++) {
if (string.charAt(i + j) != toFind.charAt(j)) {
break;
}
}
if (j == M) {
res++;
j = 0;
}
}
return res;
}
}
In this tutorial, We'll learn how to find and check if the string contains the substring in java.
This problem is commonly asked in the interview rounds.
There are many solutions are present for this problem using java string api methods and third party api's also.
Let us write the quick program to understand the all methods.
String class is added with contains() method which takes another method. contains() method returns true, if the passed string is present inside the current string, otherwise returns false.
Look at the below code.
package com.javaprogramto.programs.strings.substrin;
public class StringContainsSubstringExample {
public static void main(String[] args) {
String input = "hello world - welcome";
String substring = "world";
boolean isSubstring = input.contains(substring);
System.out.println(isSubstring);
substring = "llo";
isSubstring = input.contains(substring);
System.out.println(isSubstring);
substring = "java";
isSubstring = input.contains(substring);
System.out.println(isSubstring);
}
}
Output:
true true false
First two substring are present in the input string. So contains() method returned true. The 3rd string "java" is not present in the input string. So, contains() method returned false.
And also note that contains() method is case sensitive.
If you pass substring as "Hello" which does not match the "hello" from the input string because h is lower in the input and upper in the sub string.
Refer the below code.
substring = "Hello"; isSubstring = input.contains(substring); System.out.println(isSubstring);
Output:
false
Next solution is using the String class indexOf() or lastIndexOf() methods.
if the match is found then these method returns the starting of the index of substring from input string, otherwise -1 if no match found.
Example:
package com.javaprogramto.programs.strings.substrin;
public class StringContainsSubstringExample2 {
public static void main(String[] args) {
String input = "hello world - welcome";
String substring = "world";
int index = input.indexOf(substring);
System.out.println(index);
substring = "llo";
index = input.lastIndexOf(substring);
System.out.println(index);
substring = "java";
index = input.indexOf(substring);
System.out.println(index);
substring = "Hello";
index = input.lastIndexOf(substring);
System.out.println(index);
}
}
Output:
6 2 -1 -1
indexOf() and lastIndexOf() methods also case sensitive.
Next solution to solve this problem is with help of regular expression. We need to use the Pattern.quote() method and this method takes the regex pattern.
This method takes care if the substring has the special characters then escaping them is taken care by quote method.
Look at the following code.
package com.javaprogramto.programs.strings.substrin;
import java.util.regex.Pattern;
public class StringContainsSubstringExample3 {
public static void main(String[] args) {
String input = "hello world - welcome";
String substring = "world";
boolean isPatternMatched = input.matches("(?i).*" + Pattern.quote(substring) + ".*");
System.out.println(isPatternMatched);
substring = "llo";
isPatternMatched = input.matches("(?i).*" + Pattern.quote(substring) + ".*");
System.out.println(isPatternMatched);
substring = "java";
isPatternMatched = input.matches("(?i).*" + Pattern.quote(substring) + ".*");
System.out.println(isPatternMatched);
}
}
Output:
true true false
Apache commons lang third party api also provided a utility method to handle this problem.
contains(): Checks the given substring is present in the main string.
containsIgnoreCase(): Same as above but ignores the case sensitive
indexOf(): Returns the index of substring if present, else returns -1.
package com.javaprogramto.programs.strings.substrin;
import org.apache.commons.lang3.StringUtils;
public class StringContainsSubstringExample4 {
public static void main(String[] args) {
// StringUtils.contains() example
String input = "hello world - welcome";
String substring = "world";
boolean isPatternMatched = StringUtils.contains(input, substring);
System.out.println(isPatternMatched);
// StringUtils.containsIgnoreCase() example
substring = "Hello";
isPatternMatched = StringUtils.containsIgnoreCase(input, substring);
System.out.println(isPatternMatched);
// StringUtils.isIndexFound() example
substring = "welco";
int isIndexFound = StringUtils.indexOf(input, substring);
System.out.println(isIndexFound);
}
}
Output:
true true 14
In this article, We've seen the various ways to check whether the string contains the substring in it or not in java.
Apache commons StringUtils class has many utility methods. These are the additional methods which is not shown in the above example indexOfAny(), indexOfAnyBut(), indexOfDifference(). All of these methods can be used to solve the problem statement.
package com.javaprogramto.programs.strings.sort.length;
import java.util.Arrays;
public class SortStringsByLengthExample {
public static void main(String[] args) {
String[] words = { "hello", "how", "are", "u", "doing" };
System.out.println("string array before sorting : "+Arrays.toString(words));
sortArrayByLength(words, Sort.ASC);
System.out.println("string array after sorting : "+Arrays.toString(words));
}
public static void sortArrayByLength(String[] strs, Sort direction) {
if (direction.equals(Sort.ASC)) {
Arrays.sort(strs, (String s1, String s2) -> Integer.compare(s1.length(), s2.length()));
} else {
Arrays.sort(strs, (String s1, String s2) -> (-1) * Integer.compare(s1.length(), s2.length()));
}
}
public enum Sort {
ASC, DESC
}
}
string array before sorting : [hello, how, are, u, doing] string array after sorting : [u, how, are, hello, doing]
package com.javaprogramto.programs.strings.sort.length;
import java.util.Arrays;
import java.util.Comparator;
public class SortStringsByLengthExample2 {
public static void main(String[] args) {
String[] words = { "hello", "how", "are", "u", "doing" };
System.out.println("string array before sorting : " + Arrays.toString(words));
sortArrayByLengthUsingComparator(words, Sort.DESC);
System.out.println("string array after sorting : " + Arrays.toString(words));
}
public static void sortArrayByLengthUsingComparator(String[] strs, Sort direction) {
if (direction.equals(Sort.ASC)) {
Arrays.sort(strs, Comparator.comparingInt(String::length));
} else {
Arrays.sort(strs, Comparator.comparingInt(String::length).reversed());
}
}
public enum Sort {
ASC, DESC
}
}
string array before sorting : [hello, how, are, u, doing] string array after sorting : [hello, doing, how, are, u]
package com.javaprogramto.programs.strings.sort.length;
import java.util.Arrays;
import java.util.Comparator;
public class SortStringsByLengthExample3 {
public static void main(String[] args) {
String[] words = { "hello", "how", "are", "u", "doing" };
System.out.println("string array before sorting : " + Arrays.toString(words));
String[] sortedArrayByLength = sortArrayByLengthUsingSorted(words, Sort.DESC);
System.out.println("original array after sorting : " + Arrays.toString(words));
System.out.println("new string array after sorting : " + Arrays.toString(sortedArrayByLength));
}
public static String[] sortArrayByLengthUsingSorted(String[] strs, Sort direction) {
if (direction.equals(Sort.ASC)) {
return Arrays.stream(strs)
.sorted(Comparator.comparingInt(String::length))
.toArray(String[]::new);
} else {
return Arrays.stream(strs)
.sorted(Comparator.comparingInt(String::length)
.reversed())
.toArray(String[]::new);
}
}
public enum Sort {
ASC, DESC
}
}
string array before sorting : [hello, how, are, u, doing] original array after sorting : [hello, how, are, u, doing] new string array after sorting : [hello, doing, how, are, u]
package com.javaprogramto.programs.strings.find.most;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.lang3.tuple.Pair;
public class FindMostRepeatedCharacterInStringExample {
public static void main(String[] args) {
String input = "hello world";
Pair<Character, Integer> maxCharCountPair = getMostRepeatedCharacterFromString(input);
System.out.println("Input string : " + input);
System.out.println(maxCharCountPair.getKey() + " is the most repeated character for "
+ maxCharCountPair.getValue() + " times.");
}
private static Pair<Character, Integer> getMostRepeatedCharacterFromString(String input) {
Map<Character, Integer> countMap = new HashMap<>();
char[] chars = input.toCharArray();
// storing the char and its count in the hashmap
for (char ch : chars) {
if (!Character.isWhitespace(ch)) {
Integer currentCount = countMap.get(ch);
if (currentCount == null) {
countMap.put(ch, 1);
} else {
countMap.put(ch, ++currentCount);
}
}
}
// getting the max count from counter map.
Integer maxCharacterCount = Collections.max(countMap.values());
char maxCharacter = Character.MIN_VALUE;
// getting the max occurred character.
for (Entry<Character, Integer> entry : countMap.entrySet()) {
if (entry.getValue() == maxCharacterCount) {
maxCharacter = entry.getKey();
}
}
return Pair.of(maxCharacter, maxCharacterCount);
}
}
Input string : hello world l is the most repeated character for 3 times.
package com.javaprogramto.programs.strings.find.most;
import org.apache.commons.lang3.tuple.Pair;
public class FindMostRepeatedCharacterInStringExample2 {
public static void main(String[] args) {
String input = "hello world";
Pair<Character, Integer> maxCharCountPair = getMostRepeatedCharacterFromString(input);
System.out.println("Input string : " + input);
System.out.println(maxCharCountPair.getKey() + " is the most repeated character for "
+ maxCharCountPair.getValue() + " times.");
}
private static Pair<Character, Integer> getMostRepeatedCharacterFromString(String input) {
int[] asciiIntArray = new int[256];
char[] chars = input.toCharArray();
int mostAppearanceCount = 0;
char mostAppearedChar = Character.MIN_VALUE;
// storing the char and its count in the hashmap
for (char ch : chars) {
if (!Character.isWhitespace(ch)) {
int asciiCode = (int) ch;
asciiIntArray[asciiCode]++;
if (asciiIntArray[asciiCode] > mostAppearanceCount) {
mostAppearanceCount = asciiIntArray[asciiCode];
mostAppearedChar = ch;
}
}
}
return Pair.of(mostAppearedChar, mostAppearanceCount);
}
}
package com.javaprogramto.programs.strings.find.most;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.lang3.tuple.Pair;
public class FindMostRepeatedCharacterInStringExample3 {
public static void main(String[] args) {
String input = "hello world";
Pair<Character, Long> maxCharCountPair = getMostRepeatedCharacterFromString(input);
System.out.println("Input string : " + input);
System.out.println(maxCharCountPair.getKey() + " is the most repeated character for "
+ maxCharCountPair.getValue() + " times.");
}
private static Pair<Character, Long> getMostRepeatedCharacterFromString(String input) {
return input.chars()
.filter(c -> Character.isWhitespace(c) == false) // ignoring space
.mapToObj(c -> (char) c)
.collect(Collectors.groupingBy(c -> c, Collectors.counting()))
.entrySet()
.stream()
.max(Map.Entry.comparingByValue())
.map(p -> Pair.of(p.getKey(), p.getValue()))
.orElse(Pair.of(Character.MIN_VALUE, -1L));
}
}
package com.javaprogramto.programs.strings.remove.character;
public class StringRemoveCharacterExample {
public static void main(String[] args) {
String input = "hello 0world 00";
String output = input.replaceAll("0", "");
System.out.println("Input string 1 : "+input);
System.out.println("Output string after removing the + symbol : "+output);
}
}
Input string 1 : hello 0world 00 Output string after removing the + symbol : hello world
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '+' near index 0 + ^ at java.base/java.util.regex.Pattern.error(Pattern.java:2029) at java.base/java.util.regex.Pattern.sequence(Pattern.java:2204) at java.base/java.util.regex.Pattern.expr(Pattern.java:2070) at java.base/java.util.regex.Pattern.compile(Pattern.java:1784) at java.base/java.util.regex.Pattern.<init>(Pattern.java:1431) at java.base/java.util.regex.Pattern.compile(Pattern.java:1070) at java.base/java.lang.String.replaceAll(String.java:2141) at com.javaprogramto.programs.strings.remove.character.StringRemoveCharacterExample.main(StringRemoveCharacterExample.java:9)
package com.javaprogramto.programs.strings.remove.character;
import java.util.regex.Pattern;
public class StringRemoveCharacterExample2 {
public static void main(String[] args) {
String input = "hello +world ++";
String output = input.replaceAll(Pattern.quote("+"), "");
System.out.println("Input string 1 : "+input);
System.out.println("Output string after removing the + symbol : "+output);
}
}
Input string 1 : hello +world ++ Output string after removing the + symbol : hello world
package com.javaprogramto.programs.strings.remove.character;
public class StringRemoveCharacterExample3 {
public static void main(String[] args) {
String input = "hello +world ++";
char removalCh = '+';
char[] chars = input.toCharArray();
StringBuilder builder = new StringBuilder();
for (char ch : chars) {
if (ch != removalCh) {
builder.append(ch);
}
}
System.out.println("Input string 1 : " + input);
System.out.println("Output string after removing the + symbol : " + builder.toString());
}
}
Input string 1 : hello +world ++ Output string after removing the + symbol : hello world
package com.javaprogramto.programs.strings.remove.character;
import java.util.stream.Collectors;
public class StringRemoveCharacterExample4 {
public static void main(String[] args) {
String input = "hello +world ++";
char removalCh = '+';
String output = input.chars()
.filter(ch -> ch != removalCh)
.mapToObj(ch -> String.valueOf(ch))
.collect(Collectors.joining());
System.out.println("Input string 1 : " + input);
System.out.println("Output string after removing the + symbol : " + output);
}
}
package com.javaprogramto.programs.strings.remove.character;
import org.apache.commons.lang3.StringUtils;
public class StringRemoveCharacterExample5 {
public static void main(String[] args) {
String input = "hello +world ++";
char removalCh = '+';
String output = StringUtils.remove(input, removalCh);
System.out.println("Input string 1 : " + input);
System.out.println("Output string after removing the + symbol : " + output);
}
}
package com.javaprogramto.programs.strings.remove.duplicates;
public class StringRemoveDuplicatesExample1 {
public static void main(String[] args) {
String orignalString = "world world";
StringBuilder builder = new StringBuilder();
for (int i = 0; i < orignalString.length(); i++) {
if (builder.indexOf(String.valueOf(orignalString.charAt(i))) == -1) {
builder.append(orignalString.charAt(i));
}
}
System.out.println("Original String : " + orignalString);
System.out.println("After removing the duplicates : " + builder.toString());
}
}
Original String : world world After removing the duplicates : world
package com.javaprogramto.programs.strings.remove.duplicates;
import java.util.HashSet;
import java.util.Set;
public class StringRemoveDuplicatesExample2 {
public static void main(String[] args) {
String orignalString = "world world";
StringBuilder builder = new StringBuilder();
Set<Character> set = new HashSet<>();
char[] chars = orignalString.toCharArray();
for (char ch : chars) {
if (set.add(ch)) {
builder.append(ch);
}
}
System.out.println("Original String : " + orignalString);
System.out.println("After removing the duplicates : " + builder.toString());
}
}
package com.javaprogramto.programs.strings.remove.duplicates;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
public class StringRemoveDuplicatesExample3 {
public static void main(String[] args) {
String orignalString = "world world";
String output = Arrays.asList(orignalString.split(""))
.stream()
.distinct()
.collect(Collectors.joining());
System.out.println("Original String : " + orignalString);
System.out.println("After removing the duplicates : " + output);
}
}
package com.javaprogramto.programs.strings.palindrome;
public class StringCheckPalindrome1 {
public static void main(String[] args) {
String input1 = "hello";
boolean isPalindrome = isPalindrome(input1);
System.out.println("Is " + input1 + " palindrome? " + isPalindrome);
String input2 = "abcba";
isPalindrome = isPalindrome(input2);
System.out.println("Is " + input2 + " palindrome? " + isPalindrome);
}
private static boolean isPalindrome(String input) {
int right = 0;
int left = input.length() - 1;
while (right <= left) {
if (input.charAt(right) != input.charAt(left)) {
return false;
}
right++;
left--;
}
return true;
}
}
Is hello palindrome? false Is abcba palindrome? true
package com.javaprogramto.programs.strings.palindrome;
public class StringCheckPalindrome2 {
public static void main(String[] args) {
String input1 = "hello";
boolean isPalindrome = isPalindromeWithForLoop(input1);
System.out.println("Is " + input1 + " palindrome? " + isPalindrome);
String input2 = "abcba";
isPalindrome = isPalindromeWithForLoop(input2);
System.out.println("Is " + input2 + " palindrome? " + isPalindrome);
}
private static boolean isPalindromeWithForLoop(String input) {
int length = input.length();
for (int i = 0; i < length; i++) {
if (input.charAt(i) != input.charAt(length - i - 1)) {
return false;
}
}
return true;
}
}
private static boolean isPalindromeWithStringBuilder(String input) {
return input.equals(new StringBuilder(input).reverse().toString());
}
package com.javaprogramto.programs.strings.palindrome;
import java.util.stream.IntStream;
public class StringCheckPalindrome4 {
public static void main(String[] args) {
String input1 = "hello";
boolean isPalindrome = isPalindromeInJava8(input1);
System.out.println("Is " + input1 + " palindrome? " + isPalindrome);
String input2 = "abcba";
isPalindrome = isPalindromeInJava8(input2);
System.out.println("Is " + input2 + " palindrome? " + isPalindrome);
}
private static boolean isPalindromeInJava8(String input) {
return IntStream.range(0, input.length() / 2)
.noneMatch(index -> input.charAt(index) != input.charAt(input.length() - index - 1));
}
}
package com.javaprogramto.programs.strings.permutations;
public class StringPermutationsExample1 {
public static void main(String[] args) {
stringPermuteAndPrint("", "ABC");
}
private static void stringPermuteAndPrint(String prefix, String str) {
int n = str.length();
if (n == 0) {
System.out.print(prefix + " ");
} else {
for (int i = 0; i < n; i++) {
stringPermuteAndPrint(prefix + str.charAt(i), str.substring(i + 1, n) + str.substring(0, i));
}
}
}
}
ABC ACB BCA BAC CAB CBA
package com.javaprogramto.programs.strings.permutations;
import java.util.stream.IntStream;
public class StringPermutationsExample2 {
public static void main(String[] args) {
stringPermuteAndPrint("", "ABC");
}
// java 8 stream example
private static void stringPermuteAndPrint(String prefix, String str) {
int n = str.length();
if (n == 0) {
System.out.print(prefix + " ");
} else {
IntStream.range(0, n).parallel().forEach(
i -> stringPermuteAndPrint(prefix + str.charAt(i), str.substring(i + 1, n) + str.substring(0, i)));
}
}
}
package com.javaprogramto.programs.strings.joining;
public class JoiningStringDelimiterExample1 {
public static void main(String[] args) {
// input 1
String output1 = joinStringsWithDelimiter("-", "hello", "world", "welcome", "to", "java", "programs");
System.out.println("Ouptut 1 : " + output1);
// input 1
String output2 = joinStringsWithDelimiter("**", "this", "is", "second", "input");
System.out.println("Ouptut 2 : " + output2);
}
/**
* Gets the joined string for the input strings with a given delimiter
*
* @param delimiter
* @param strings
* @return
*/
private static String joinStringsWithDelimiter(String delimiter, String... strings) {
StringBuilder stringBuilder = new StringBuilder();
int index = 0;
for (index = 0; index < strings.length - 1; index++) {
stringBuilder.append(strings[index]).append(delimiter);
}
stringBuilder.append(strings[index]);
return stringBuilder.toString();
}
}
Ouptut 1 : hello-world-welcome-to-java-programs Ouptut 2 : this**is**second**input
package com.javaprogramto.programs.strings.joining;
import java.util.StringJoiner;
public class JoiningStringDelimiterExample2 {
public static void main(String[] args) {
// input 1
String output1 = stringJoinerWithDelimiter("-", "hello", "world", "welcome", "to", "java", "programs");
System.out.println("Ouptut 1 : " + output1);
// input 1
String output2 = stringJoinerWithDelimiter("**", "this", "is", "second", "input");
System.out.println("Ouptut 2 : " + output2);
}
private static String stringJoinerWithDelimiter(String delimiter, String... strings) {
StringJoiner stringJoinder = new StringJoiner(delimiter);
for (String str : strings) {
stringJoinder.add(str);
}
return stringJoinder.toString();
}
}
StringJoiner stringJoinder = new StringJoiner(delimiter, "!!", "!!");
Ouptut 1 : !!hello-world-welcome-to-java-programs!! Ouptut 2 : !!this**is**second**input!!
package com.javaprogramto.programs.strings.joining;
public class JoiningStringDelimiterExample3 {
public static void main(String[] args) {
// input 1
String output1 = stringJoinWithDelimiter("-", "hello", "world", "welcome", "to", "java", "programs");
System.out.println("Ouptut 1 : " + output1);
// input 1
String output2 = stringJoinWithDelimiter("**", "this", "is", "second", "input");
System.out.println("Ouptut 2 : " + output2);
}
private static String stringJoinWithDelimiter(String delimiter, String... strings) {
return String.join(delimiter, strings);
}
}
import java.util.Arrays;
import java.util.stream.Collectors;
public class JoiningStringDelimiterExample4 {
public static void main(String[] args) {
// input 1
String output1 = stringCollectorsJoiningWithDelimiter("-", "hello", "world", "welcome", "to", "java",
"programs");
System.out.println("Ouptut 1 : " + output1);
// input 1
String output2 = stringCollectorsJoiningWithDelimiter("**", "this", "is", "second", "input");
System.out.println("Ouptut 2 : " + output2);
}
private static String stringCollectorsJoiningWithDelimiter(String delimiter, String... strings) {
String output = Arrays.stream(strings).collect(Collectors.joining(delimiter));
return output;
}
}
import org.apache.commons.lang3.StringUtils;
public class JoiningStringDelimiterExample5 {
public static void main(String[] args) {
// same code as abvoe example
}
private static String stringCollectorsJoiningWithDelimiter(String delimiter, String... strings) {
String output = StringUtils.join(strings, delimiter);
return output;
}
}
String out = "";
for (int i = 0; i < 100000; i++) {
out += "new value";
}