How to perform String Compression in Java?

Photo of author

Know about string compression in java. String compression is a technique used to reduce the size of a string by replacing the characters which are repeating with a count of the number of occurrences. This technique is commonly used in data compression algorithms to reduce the memory or disk space required to store a string.string compression

Below learn about string compression in java.

See Also: How To Display Time In HTML Using JavaScript?

Contents

String compression in java

There are numerous ways to perform string contraction in Java. Then we will be agitating three of the ways that are used to perform string contraction. 

The first way to perform contraction is by using StringBuilder

Using the StringBuilder class, this is the first approach to perform string contraction in Java. The StringBuilder class provides a set of styles to manipulate strings efficiently. This. As it generates a variable series of characters, the StringBuilder class offers a variation to the string class. The functions of the StringBuilder and StringBuffer classes are the same, as both produce variable sequences of characters as an option to the String Class. Still, syncing is where the StringBuilder class and StringBuffer class diverge. The StringBuilder class doesn’t ensure synchronization.string builder

As a result, this class is intended to be used in areas where a single thread preliminarily used the StringBuffer as a drop-in relief( as is generally the case). This class is brisk and works snappily on the executions, so using this rather than StringBuffer is doable.

The initial idea behind this approach is to reiterate through the input string, count the number of successive characters, and tack the count to a StringBuilder object.

The basic idea behind this approach is to iterate through the input string, count the number of consecutive characters, and append the count to a StringBuilder object.

The code is as follows

public static String compressString(String str) {

StringBuilder sb = new StringBuilder();

int count = 1;

char prevChar = str.charAt(0);

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

char currentChar = str.charAt(i);

if (currentChar == prevChar) {

count++;

} else {

sb.append(prevChar);

sb.append(count);

count = 1;

prevChar = currentChar;

}

}

sb.append(prevChar);

sb.append(count);

return sb.toString();

}

We first construct a StringBuilder object in this code to store the compressed string. The first character of the input string is then used as the starting value for the count and prevChar variables. The next step is repeatedly matching each character in the input string to the character before it. We increase the tally if they are identical. If they are distinct, we update the prevChar variable, append the previous character and its count to the StringBuilder object, and then reset the count to 1. Lastly, we return the compressed string after adding the last character and its count to the StringBuilder object.

The second approach is Regular Expressions in Java

 The alternate method is Regular Expressions in Java

Using regular expressions is the alternate system of textbook contraction in Java. String manipulation is made easy with the help of regular expressions.regular expression

A string of letters called a regular expression creates a hunting pattern. This hunt pattern can be used to specify your hunt criteria when looking for information within a document.

A regular expression can be a simple pattern or just a single letter. All kinds of textbook hunting and textbook relief tasks can be carried out using regular expressions. Although Java does not have an erect- in the Regular Expression class, we can use regular expressions by importing Java.util.regex library.

Regex in Java provides us with 3 classes and 1 interface listed below as follows

Matcher Class

Pattern Class

MatchResult Interface

PatternSyntaxException Class

The code is as follows:

public static String compressString(String str) {

StringBuilder sb = new StringBuilder();

Pattern pattern = Pattern.compile(“(.)\\1*”);

Matcher matcher = pattern.matcher(str);

while (matcher.find()) {

String group = matcher.group();

sb.append(group.charAt(0));

sb.append(group.length());

}

return sb.toString();

}

The third approach we’ve is using a chart

Using a Chart is one way to negotiate string contraction in Java.chart In Java, a Chart interface maps variables to values, and the census of each character in the input string can be stored using a Chart.

The code is as follows

public static String compressString(String str) {

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

StringBuilder sb = new StringBuilder();

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

map.put(c, map.getOrDefault(c, 0) + 1);

}

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

sb.append(entry.getKey());

sb.append(entry.getValue());

}

return sb.toString();

}

See Also: Python For Scientific Computing: Everything You Need To Know

Conclusion

To store the count of each character in the input string, we first construct a Chart object in this law. The Chart object’s character count streamlines by repeating through the input string using the put() function.

Using the entrySet() function, we reiterate through the Map object, subjoining each key and value to the StringBuilder object.

We also give the compressed text. Thus this was about string compression in java.

See Also: Python Round() Function: Complete Tutorial

Leave a Comment