-----------------------------------------------------------------------------------------------------------
Table of Contents:
*Introduction
*Constructors
-Code Examples of Constructors
*String Information
*Methods
-Code Examples of Methods
*toString()
*More Complex (Useful) Examples
-----------------------------------------------------------------------------------------------------------



Introduction:
Every Java programmer who has written any code has come in contact with the String variable:
public static void main(String args[])
or
public static void main(String[] args)

These both are stating that this method accepts an array of Strings as input.

If you’ve programmed in any language, you come in contact with Strings in some form.


These two methods will print in the same way. Knowing this is important when using some of the String methods that are available.

Constructors:
*Examples of most methods will be included after the set of descriptions.
**All depreciated methods have been left out, as of www.java.sun.com documentation version 6.

String()
-Creates an empty String, which is essentially a single char as the null terminating character ‘\0’

String(byte[] bytes)
-Creates a String from the array of bytes supplied. Any size of byte array can be used. The default character set will be used.

String(byte[] bytes)
-Creates a String from the array of bytes supplied. Any size of byte array can be used. The supplied character set is used, based on its name, rather than object.

String(byte[] bytes, Charset charset)
-Creates a String from the array of bytes supplied. Any size of byte array can be used. The supplied character set will be used.

String(byte[] bytes, int offset, int length)
-Creates a String of length length, starting at value offset in the byte array. The default character set is used.

String(byte[] bytes, int offset, int length, Charset charset)
-Creates a String of the length length, starting at value offset in the byte array. The supplied character set is used.

String(byte[] bytes, int offset, int length, String charsetName)
-Creates a String of the length length, starting at value offset in the byte array. The supplied character set is used, based on its name, rather than object.

String(char[] value)
-Creates a String from the supplied character array.

String(char[] value , int offset, int count)
- Creates a String of length length, starting at value offset in the char array

String(int[] codePoints, int offset, int count)
-Allocates memory for a String which contains Unicode characters of the type specified by codePoints.

String(String original)
-Creates a new String object which contains the same characters as the original String.

String(StringBuffer buffer)
-Creates a new String which contains the same characters which were contained in the supplied buffer.

String(StringBuilder builder)
-Creates a new String which contains the same characters which were contained in the supplied builder.


Examples:

The string was created using the empty constructor, this is proven by then adding some characters to the string.


You might expect the output to be:
A
A B C
But you would be mistaken. Bytes treat values differently, the actual output is:
65
A B C
The constructor changes the 65 ASCII value into part of a String.


I have skipped over the other option for using Charset on purpose. This method has been proven to be more efficient and produce results faster than actually supplying a Charset Object. The bug has been logged, but is yet to be resolved.


About as useful in everyday coding as the byte2 method, but this comes into play more on international language support. Simply an example of offsets and lengths. Be careful not to extend the length of the array.


Similar to the code at the very beginning, except we create the String object before passing it to the System.out.println command.


Another example of using offsets and lengths to get a substring of the original text.


By replacing the original string, we can see that the 2 Strings are completely unique, and stored in separate addresses. This is not actually completely true, but since String manipulation in this way is hard to impossible, they might as well be unique.


I have chosen to print the buffer here as well, as it is important to know that copying the data from a StringBuffer to a String, does not clear or flush the buffer.


String Information:
It is important to remember that in Java, a String is an object. Unlike the basic types: int, char, and all the others. This is important when expanding the use of Strings, as they can be passed and created in true Object Oriented Style, as well as directly stored in Vectors. Some complex examples will show how Strings are useful even when the end result is not necessarily a String.
Another point to keep in mind is that Strings for the most part are not efficient. When creating them every time the word new is used another String is created. The old String is discarded, not replaced. This is one of many advantages that C/C++ has over the manipulation of data with pointers.

Something to consider:

The delimiter in middle of the sentence changes the output.


Methods:
I know this is what many new Java coders were waiting to see, how to manipulate and process Strings.
I have omitted a few of the more obscure methods, a complete list is available from the java sun website documentation

char charAt(int index)
-Returns a char of the character at the given index.

int codePointAt(int index)
-Returns the code point value of the character at the given index.

int codePointBefore(int index)
- Returns the code point value of the character before the given index.

int codePointCount(int beginIndex, int endIndex)
-Returns the number of code points in the range between beginIndex and endIndex.

int compareTo(String string)
-Compares the original and string lexicographically, 0 is returned if the Strings match.

int compareToIgnoreCase(String string)
-Compares the original and string lexicographically ignoring the case of letters, 0 is returned if the Strings match.

String concat(String str)
-appends String str to the calling String (this).

boolean contains(CharSequence s)
-Returns true if the String contains the specified sequence.

static String copyValueOf(char[] data)
-Returns a String representing the supplied character array.

static String copyValueOf(char[] data, int offset, int length)
-Returns a String representing the character array at the supplied offset and length.

boolean endsWith(String suffix)
-Returns true if the end of the ‘this’ String matches the suffix supplied.

boolean equals(Object anObject)
-Compares ‘this’ String to the Object supplied.

boolean equalsIgnoreCase(String string)
-Returns true is ‘this’ String is the same as the String supplied.

byte[] getBytes()
-Returns a byte array of ‘this’ String.

void getChars(int start, int end, char[] dest, int destStart)
-Copies the characters in the range start to end, from ‘this’ String into the character array dest, starting at position destStart in the destination array.

int hashCode()
-Returns a hash code for ‘this’ String.

int indexOf(int ch)
-Returns the index value of the first occurrence of the character ch.

int indexOf(int ch, int offset)
-Returns the index value of the first occurrence of the character ch, which appears after the supplied offset.

int indexOf(String str)
-Returns the first occurrence of the supplied substring.

int indexOf(String str, int offset)
-Returns the first occurrence of the supplied substring, which appears after the supplied offset.

boolean isEmpty()
-Returns true if ‘this’ String’s length is 0.

int lastIndexOf(int ch)
-Returns the index value of the last occurrence of the character ch.

int lastIndexOf(String str)
-Returns the index value of the last occurrence of the substring str.

int length()
-Returns the length of the String. A count of all characters, including spaces.

boolean matches(String regex)
-Returns true if ‘this’ String matches the requirements of the regular expression regex.

String replace(char oldChar, char newChar)
-Returns a String with all occurrences of oldChar replaced by newChar.

String[] split(String regex)
-Splits the string into smaller Strings around the specified regular expression regex.

String substring(int startIndex, int endIndex)
-Returns a String that is a substring of the of the original, from startIndex to endIndex.

char[] toCharArray()
-Returns a char array of ‘this’ String.

String toLowerCase()
-Returns a lowercase version of ‘this’ string replacing all uppercase letters.

String toString()
-Returns a String of ‘this’ String.
*Not so important when used on Strings, but on other types and Objects it becomes very useful.

String toUpperCase()
-Returns an uppercase version of ‘this’ String replacing all lowercase letters.

String trim()
-Returns ‘this’ String with all leading and trailing white space omitted.

String valueOf(boolean b )
-Returns the String representation of the boolean argument b.

String valueOf(char c)
-Returns the String representation of the character argument c.

String valueOf(char[] c)
-Returns the String representation of the character array argument c.

String valueOf(double d)
-Returns the String representation of the double argument d.

String valueOf(float f)
-Returns the String representation of the float argument f.

String valueOf(int i)
-Returns the String representation of the integer argument i.

String valueOf(Object o)
-Returns the String representation of the Object argument o.


Examples:


The character c, now holds the character in string at index 0, which is ‘W’.


We get -8 in the last example because of the way the strings are compared. The first comparison is the length of each String. Since string3 is shorter than string4, a negative value is returned.


The String ‘this’ which is s in all cases, has the String passed to concat appended to the end.


Notice that case matters.


Displays the ASCII code of each letter.


The output of a known char array is added for comparison, thus being able to see that the result is exactly what is expected.


Straight forward, algorithm attempts to make a ‘unique’ hash value for the String. I use unique loosely, as it is possible to have collisions, but it is a very good algorithm.


Simple really, returns the first index occurrence. Remember that arrays start at 0.


Very similar, illustrates the negative return value if there are no more occurrences after the supplied index.


Gets the length of the string.


Note that the character ‘_’ is not kept, as it is the defining split character.
I have intentionally avoided talking about Regular Expressions and done a simple case here. As Strings and not Regex is the topic of this tutorial.


The same as endsWith(), easy to implement and use.


Be careful with this method, the first index is included, while the second index is not.


An easier option to getChars().


Note that symbols and numbers (_ 1 ,) are not affected.


Leading and Trailing spaces are removed.

toString()
This method is a special case. It is inherited from the class Object. Thus all objects can use this method.
An Object has a String representation, either supplied or determine based on the memory address by the JVM. We can supply a toString method for each of our classes (objects) to handle how the object reacts.

Example:

Your output will be something like this:
Node@16930e2
Node@108786b

Not very useful… but this is where the toString method comes in. We can print the Object in this case Node, directly if we simply supply a way to display the Object:

By adding this small method, our output becomes:
(0,0)
(14,7)

Much better!

Since the toString method always uses the this Object, and accepts no parameters, each object prints out it’s own information. The toString method appears to be a special case in some ways, but it really isn’t. You can do as many calculations beforehand in the method, as long as the return type is a String.
You can also call the toString method If you wish:
System.out.println(n1.toString());
This will give the same result as before. Java automatically looks for the toString() method when an object is used as a String. If none exists, then the default is supplied, but this is rarely good enough.
*Similar to constructors. The default constructor exists, even if you do not supply one.

Another example:

Notice how the toString method does a for loop to evaluate the String representation of the array. The conversion can be done many ways, but this also illustrates, the use of the valueOf method. Any primitive can have a String representation in this way. It is true we can place primitives directly into a String:
out += array[ i] + ",";
But it is important to understand the options/alternatives and their uses.


Complex Code Examples:
*I make no claim that these are the most efficient choices, these examples are meant to show the largest number of String operations possible, to help you learn how to improve upon the code presented here.

I will not analyze the code in extreme detail as they are simple concepts from above, joined to perform useful tasks. I will describe the process and result.


This method systematically swaps the starting and ending characters in a character array, to reverse a String. By accessing the String as an array of chars, the array becomes much easier to handle, and easily traversed with a for loop.


The above method inverts the case of letters in a String. Looping through the String as a char array.
Eg: a becomes A, and A becomes a
There are many, many String methods here. I will break down one of the replacements:
(((String.valueOf(chars[ i])).toUpperCase()).toCharArray())[0];
The best way to look at it is to move to the middle set of brackets:
(chars[ i]) – This is obviously a single char of the array.
Now expand one level:
(String.valueOf(chars[ i])) – This becomes the String representation of the char, required from the method toUpperCase()
Expand another level:
((String.valueOf(chars[ i])).toUpperCase()) – now we have an uppercase String
Last set of brackets:
(((String.valueOf(chars[ i])).toUpperCase()).toCharArray()) – a character array of the uppercase (converted) String.

Now since we know that the array contains a single character, and we are placing this character into a single char, and not an array, we need to specify a single character, as we did to start this entire process:
(((String.valueOf(chars[ i])).toUpperCase()).toCharArray())[0];

Once more, with replacement of type:
*I have made the item which will be substituted for in the next line italics, and the item which is the current replacement bold.

(((String.valueOf(chars[ i])).toUpperCase()).toCharArray())[0];
(((String.valueOf(char)).toUpperCase()).toCharArray())[0];
((String.toUpperCase()).toCharArray())[0];
(String.toCharArray())[0];
(char[])[0];
char;




I hope that you have learned something about Strings in Java, or reinforced things you already knew.
Good Luck and have fun with Strings.

-William_Wilson

Download Includes: Plain Text and MS Office 2007 Word Versions, plus source files for all examples.
 Java_String.zip ( 35.17k ) Number of downloads: 238

Excellent tutorial William that is all I have to say.

Very good tutorial, and also a very good subject, I am sure it would answer a nice amount of question regularly surfacing on DIC.
However (as usual) I have found something that might need a bit more explanation:




According to this, a String made with the given constructor is supposed to return 1 for length, but it is obviously not the case. I am not totally sure about this, but I think in Java - unlike C/C++ where this is true - the '\0' control char is not really used (not even defined as the end of String char?). Strings are immutable objects, and they store their length, so actually the end character is not needed. I've run this snippet:

And it's output shows that the '\0' char is not the end of the String - can't copy, but the '\0' turns up as a square, and the c char is visible as well. I haven't looked up the official doc on this, but if anyone knows anything more, please share - or I'll have to look up the spec

If you didn't point it out 1lacca I might get a big head


yes the '\0' character will print if it is converted from char to String, the conversion gets the ASCII value and converts it to a non-character eg the square character. When implanted directly in a String it will terminate the String.

But how do you do that in Java?

In a recent project I used the null character (ASCII 0) as a "padding" character for network transport level messages. I can tell you, from experience, that it does not terminate the String. You could try either of the following:



And you'll find that both will insert a null character, but not terminate the String. You can verify this by printing the String and/or inspecting it with a debugger.

Also, The Java Language Specification says:

Immutability
Also, something else about Strings and immutability. I've heard people say that they are inefficient compared to C++ strings. This may be true to some small extent (defrayed some by the JVMs constant String pool), but the design decision was made for very good reason. According to James Gosling (inventor of Java):


So, while this may annoy C++ to Java converts at first, they'd be happy to know that their code won't be vulnerable to those kinds of attacks.

Constant String Pool Behavior
Another tidbit concerning the constant String pool. As you mentioned, invoking the new keyword does create a new instance of a String. So while the following code will return true:



This code will return false:



However, did you know that runtime concatenation also creates a new String:



But, if you use constant Strings (final in Java) then it's obviously a compile-time concatenation.



Since s2 and s3 were marked as final then s2+s3 is the same as saying "T" + "ony". So this is a compile-time concatenation and no new String is created.

With all due respect to Mr Gosling, I've read several security experts writing that storing sensitive data in a Java String is a risk, because it is immutable. They've reasoned that it is better to put it into mutable objects (char arrays, etc.) instead, so you can overwrite it once you don't need them anymore and they don't stay in memory hanging around and maybe even swapped out before garbage collection making them visible to anyone who can access the swap file. I really don't know who to trust here, but probably both strategies have their respective uses.



Now that is what I inteded to look-up, just never got around to do so.
Thank you Programmist!



Yup, this is what I've shown in post #3

I've heard the other argument and it is valid. Thanks for pointing that out. I think, however, that it is exceptional given that someone would have to be snooping on the machine where the JVM is running. But, this is no excuse to let it go. That's why the Java API uses char arrays in certain areas, like: javax.swing.JPasswordField.getPassword(). I think in this situation "largest danger" was taken care of by making Strings immutable and then the exceptional cases are handled individually.


I thought it needed more examples.

True, one can never have too many examples.

Thanks, this is helping me out alot with my term project, as is this whole forum, you guys are great.

wow, you guys are amazing

Yes it must be a compiler issue, as running within my common compiler it cuts off at the '\0' character, but in the command prompt it carries on as if it was not there. From all I'd read it did not seem like that should be the case as you have clearly demonstrated, but it was hard to think the output i was seeing was wrong too.
Guess you can always learn something more.