String In JAVA language

Answer 1

In Java, literal character strings such as "foo" are implemented as instances of the String class. These strings are constant and can not be modified directly. Mutable character strings, or string variables, are implemented as instances of StringBuffer class. It is also possible to work directly with arrays of chars, but String and related classes offer lots of useful methods.

Answer 2

Handling "strings" of characters is a fundamental aspect of most programming languages. In Java, each character in a string is a 16-bit Unicode character. Because Unicode characters are 16 bits, a rich, international set of characters is easily represented in Unicode.

In Java, strings are objects. Just like other objects, you can create an instance of a String with the new keyword, as follows:

String s = new String();

This line of code creates a new object of class String, and assigns it to the reference variable s. So far, String objects seem just like other objects. Now, let's give the String a value:

s = "abc";

As you might expect, the String class has about a zillion constructors, so you can use a more efficient shortcut:

String s = new String("abc");

And just because you'll use strings all the time, you can even say this:

String s = "abc";

The following methods are some of the more commonly used methods in the String class. They are:

public char charAt(int index)

This method returns the character located at the String's specified index. String indexes are zero-based-for example,

String x = "Rocky";

System.out.println( x.charAt(2) ); // output is 'o'

public String concat(String s)

This method returns a String with the value of the String passed in to the method appended to the end of the String used to invoke the method-for example,

String x = "ferrari ";

System.out.println( x.concat(" car") ); // output is "ferrari car"

The overloaded + and += operators perform functions similar to the concat() method-for example,

String x = "ferrari";

System.out.println( x + " car"); // output is "ferrari car"

String x = "ferrari";

x+= " car";

System.out.println( x ); // output is "ferrari car"

In the preceding "ferrari car" example, notice that the value of x really did change! Remember that the += operator is an assignment operator, so line 2 is really creating a new String, "ferrari car", and assigning it to the x variable. After line 2 executes, the original String x was referring to, "ferrari", is abandoned.

public boolean equalsignoreCase(String s)

This method returns a boolean value (true or false) depending on whether the value of the String in the argument is the same as the value of the String used to invoke the method. This method will return true even when characters in the String objects being compared have differing cases-for example,

String x = "ferrari";

System.out.println( x.equalsIgnoreCase("FERRARI")); // is "true"

System.out.println( x.equalsIgnoreCase("BMW")); // is "false"

public int length()

This method returns the length of the String used to invoke the method-for example,

String x = "Rocky";

System.out.println( x.length() ); // returns "5"

Answer 3

Handling "strings" of characters is a fundamental aspect of most programming languages. In Java, each character in a string is a 16-bit Unicode character. Because Unicode characters are 16 bits, a rich, international set of characters is easily represented in Unicode.

In Java, strings are objects. Just like other objects, you can create an instance of a String with the new keyword, as follows:

String s = new String();

This line of code creates a new object of class String, and assigns it to the reference variable s. So far, String objects seem just like other objects. Now, let's give the String a value:

s = "abc";

As you might expect, the String class has about a zillion constructors, so you can use a more efficient shortcut:

String s = new String("abc");

And just because you'll use strings all the time, you can even say this:

String s = "abc";

There are some subtle differences between these options that we'll discuss later, but what they have in common is that they all create a new String object, with a value of "abc", and assign it to a reference variable s. Now let's say that you want a second reference to the String object referred to by s:

String s2 = s; //refer s2 to the same String as s

String objects seem to be behaving just like other objects, so how is it that they are Immutable? Once you have assigned a String a value, that value can never change-it's immutable, frozen solid, won't change. The good news is that while the String object is immutable, its reference variable is not, so to continue with our previous example:

s = s.concat(" efg");

// the concat() method 'appends' a literal to the end

Didn't I just say that Strings are immutable? Yes, I perfectly did. But, here the stuff within the double quotes that is passed as argument to the concat method gets appended to the end of the String s. How did this happen?

The VM took the value of String s (which was "abc"), and added or rather appended " efg" onto the end, giving us the value "abc efg". Since Strings are immutable, the VM couldn't stuff this new value into the old String referenced by s, so it created a new String object, gave it the value "abc efg", and made s refer to it. At this point in our example, we have two String objects: the first one we created, with the value "abc", and the second one with the value "abc efg". Technically there are now three String objects, because the literal argument to concat, " efg", is itself a new String object. But we have references only to "abc" (referenced by s2) and "abc efg" (referenced by s).

Note, however, that the original "abc" String didn't change; only the reference variable s was changed, so that it would refer to a different String.

To wrap up, the original variable 's' in which we had "abc" as value would be abandoned and a new value "abc efg" would get assigned to it as soon as the s.concat(" efg") line of code is executed.

Answer 4

String objects in Java are used to hold a set of characters as a value. For example if you want a Java variable to hold the names of your friends then you would have to use Strings.

Sample String object declaration:

String name = "Tommy";

This variable "name" would contain the value "Tommy" when referenced anywhere in the code.

Strings can be concatenated using the "+" symbol

for example

String name = "Tommy";

String initial = "Junior";

System.out.println(name + initial);

The above line would print Tommy Junior in the console.

Strings have a lot of inbuilt methods like subString(), equals() etc.

Answer 5

Java, the popular object-oriented programming language, is widely used in making web applications, games, medical devices and many more. To store the sequence of characters, we use the string in Java. String, here is an object. The object is a blueprint of a class in Java.

Answer 6

In Java, String is an object that constitutes a series of characters that can be treated as a single entity. Strings store input from the programmer and allow developers to perform text-based manipulations. We use Strings in Java by enclosing their characters in double quotes.

String declaration and initialization in Java

The String datatype is used to declare a string in Java. The name of the variable follows it.

Example:

String str;

A value is assigned to the string variable using the “=” sign to initialize a string.

Example:

str = “Hello, Ninja”;

Strings in Java can also be created using the string constructor.

Example:

String str = new String(“Hello, Ninja”);

Java also provides certain built-in string functions used to play with string manipulation.

length (): This function is used to get the length of the string.

charAt(index): charAt(index) returns the character at the index as given in the brackets.

substring(start, end): The substring function returns a part of the string from a specified start index to a specified end index.

indexOf(string): The indexOf() function is used by developers to get the first occurrence of a specified string.

concat(): this function is used to concatenate the specified string at the end of the original string. The plus operator can also be used to join two strings.

toUpperCase(): This function is used to get a new string with all the characters the same as the original string but each in uppercase.

toLowerCase(): This function is used to get a new string with all the characters the same as the original string but each in lowercase.

replace(old_char, new_char): This method replaces all the occurrences of the specified old character in the string with a new one.

Examples of the above functions are:-

String str = "Hello, Ninja";

int length = str.length(); // length = 12

char fifth_char = str.charAt(4); // firstChar = 'o'

String substr =str.substring(7, 12); // subString = "Ninja"

int indexOfSpace =str.indexOf(" "); // indexOfComma = 6

String upperC = str.toUpperCase(); // upperC = “HELLO, NINJA”

String replacedStr = str.replace("Ninja", "Strings"); // replacedString = "Hello, Strings"

String newStr = replacedStr.concat(“InJava”); // newSr = “Hello, StringsInJava”

The string Ninja’s toolkit.

It is recommended to use StringBuffer for the concatenation of larger strings instead of the + operator. The reason behind this being the plus operator creates a new string every time, whereas StringBuffer modifies the original string.

While comparing two strings, using the equals() function instead of the == logical operator is always advisable. The == operator checks if two objects are the same. instance in memory, whereas equals() checks if the two objects have the same value.

The most efficient technique to check whether a string is empty is the isEmpty() method instead of performing a check on length==0.

Thus strings are a fundamental part of java programming. Hence, it becomes crucial for a programmer to master the hacks of string manipulation to create efficient, maintainable, and bug-free code that handles text-based data easily.