STRING IN JAVA

 Strings in Java 

• WHAT IS STRING
• WAYS OF CREATING A STRING
• INTERFACES AND CLASSES IN STRINGS IN JAVA 
• JAVA STRING CLASS METHODS 
• STRING TOKENIZER
• IMMUTABLE STRING IN JAVA 
• MEMORY ALLOTMENT IN STRING 

In this example, object creation is restricted to a single instance. It will first create a new string object because the "Welcome" object isn't already in the JVM's collection of string constants. Then, instead of creating a new object, it finds the collection whose string value is "Welcome" and returns a reference to the instance that already exists. This article covers the capabilities of strings in the Java language.

What are strings in Java?

Java's "string" object type may store character values; each character should be represented by 16 bits, according to the Unicode Technical Report (UTF). Similar to any other string in Java.

String s =” India”;

The Java String class contains countless methods for interacting with strings, such as compare, concat, equals, split, length, replace, compareTo, intern, and substring. This project is for Java. lang.

The String class implements the methods Serializable, Comparable, and CharSequence.

Example of using a string

Example

Java strings are immutable, meaning they cannot be changed. Every time a string is changed, a new instance is created. You may use strings that can be changed with the StringBuilder and String Buffer classes.

We shall discuss immutable strings later. We'll start by going over the fundamentals of strings and how to create a string object in Java.

Ways of creating a string

There are two ways of creating a string

1)      by string literal

2)      by new keyword

By string literal

For the sake of Java's memory efficiency (because the set string constant stops duplicate objects from being created).

Ex: string demo string = “India”;

By using keyword

for example: String s=new String("Welcome");

Here, the Java Virtual Machine (JVM) creates a new String object in traditional (non-pooled) heap memory and appends the literal "Welcome" to the String constant. The variables designate items that are on the heap (and those that are not).

For example:

Interfaces and classes in Strings in Java

The Char Buffer class is an example of an interface that is implemented by other classes. You may utilize character buffers instead of Char-Sequences with this class. To see this in action, go no further than the java. util.regex package, which contains regular expressions.

A string is presented here. Once created, string objects in Java cannot be edited; this is known as immutability.

Char-Sequence Interface

The Char-Sequence interface is used to represent strings in Java.

The following classes meet the requirements of the Char-Sequence interface. You may take use of their many helpful characteristics, such as substring, last occurrence, first occurrence, chaining, vertical, horizontal, and many more.

• String
• StringBuffer
• StringBuilder

 

1)      String

The string class is said to as immutable as it is a constant that cannot be changed once it is formed. Every update necessitates the creation of a new object, and even its own operations—like to upper and to lower—return new objects that are identical to the original. It is by default thread-safe.

Syntax:

    String str= "LMS";

           or

String str= new String("LMS")

 

2)      String buffer

StringBuffer is an analog class for Strings that provides a large portion of Strings' functionality. Instead of using a string, which has a fixed length and cannot be altered, you may use the ThreadSafe class StringBuffer if you need to use a shared string buffer object while working in a multithreaded environment. Due to its overhead, which comes from being thread-safe, its primary use is in multi-threaded systems.

Syntax

                  StringBuffer demoString = new StringBuffer("LMS");

       3) String builder

Java's StringBuilder class represents a changing string. The StringBuilder class is a suitable substitute for Java's String class, which creates an immutable string. Although it is thread-specific rather than thread-safe, overload is avoided. For the above-mentioned reasons, it is mostly used in programs that do not support threads.

Syntax:

StringBuilder demoString = new StringBuilder();
 

demoString.append("LMS"); 

Java string class methods

The java.lang.String class provides many useful methods for performing operations on an array of character values..

 

String tokenizer

The String-Tokenizer object internally maintains track of the string's current position. Some techniques move the pointer past the characters after they have been processed. The token may be acquired by extracting a substring from the string that was used to create the String-Tokenizer object. To create strings with optional prefixes and suffixes at the beginning and end, separated by a delimiter, one handy Java class is StringJoiner. Instead of writing a ton of code to do the same task as appending a delimiter to each string using the StringBuilder class, String-Joiner provides an easy-to-use solution.

Syntax: public StringJoiner (CharSequence delimiter)

Here, the JVM checks the string against the standard store. If there's not already a string in the pool, a new string instance is created and added. If there isn't already a string instance in the pool, one is created and added. If the string already exists, the constructor won't be called. Instead, it goes back to using the same instance as before. The cache that contains all of these strings is sometimes referred to as the "String Pool" or "String Constant pool." Up until JDK 6, the String collection in previous versions of Java was in PermGen (permanent generation) mode. It was instead moved to the main heap due to a change in JDK 7.

Immutable string in Java

In Java, string objects cannot be changed. Immaculate, to put it simply, means unchanged. A new string object must be generated since an existing string object cannot have its contents or status changed.

Let us understand with a program:

Here, Sachin is still Sachin in this instance, but "Sachin Tendulkar" is added to an already-existing object. For this reason, the string is called immutable.

As can be seen in the attached image, even though two objects are formed, "Sachin" rather than "Sachin Tendulkar" is used in the reference variable. On the other hand, when we explicitly add the object "Sachin Tendulkar" to the reference variable, it gets referred.

Memory allotment on string

When a string object is created literally, it is added to a collection of string constants. As a result, the JVM could optimize how string literals are initialized.

Syntax: string demostring = “LMS”

Another technique to define strings is to use the new operator to dynamically allocate them. When dynamic allocation is done, a string is given a new heap position. This string is not obtained via the string constant set.

Syntax: string demo string = new string(“LMS”)

For example:

Why did the String pool move from Perm-Gen to the normal heap area?

PermGen has a 64 MB default size, which limits its storage capacity. The issue was brought on by the creation and storage of an excessive number of string objects in PermGen space. As a result, the String pool was moved to a larger stack area. Using the concept of a string literal, Java memory management is made more effective.

Whether or whether the exact same object already exists in the string pool, the Java Virtual Machine will create a new string object on the usual stack region when you use the "new" keyword.

Example: String demoString = new String("Bhubaneswar");

Few more examples