Of all the things humans do, there is one we do more than anything else, and that is use language. Whether it’s speaking to our friends, writing letters to loved ones, sign language, or even body language, we are constantly communicating with one another.
This holds true in the Java programming language as well and Java Strings are one of the most used types of data.
In this post, you will learn about Java Strings and how they work. You will discover what they are, their behavior, and how Java treats them. You will also learn about String methods and what they mean for you and how they can be used on strings to perform powerful tasks. Additionally, you will see some code examples of Java Strings in a real use case scenario.
The jump links below can be used to navigate this post as needed.
Let’s get the party started.
What is a string in Java?
Strings in any programming language serve the same primary function: to facilitate communication between the user and the software. However, Java strings behave a little differently than most other languages. Nevertheless, familiarity with strings will be a vital aspect of your work as a Java programmer. This next image demonstrates the hierarchy of the string class.
So what separates Java Strings from that of other languages, and why is the difference between them so important? Well, in most languages, strings are considered primitive or “standard” data types, that is they are treated the same as numbers or booleans. In Java, however, strings are not considered primitive data types and instead are treated as objects.
This means is because every string created is a new instance of the String Class, this is due to the way Java Virtual Machines handle memory. Because Java is a compiles and interpreted language, it needs to be very careful how it handles memory usage. To do this, Java stores strings in memory and resuses them as needed in an effort to minimize interpretation time.
Now that you’ve learned what a string is, and how Java handles them, let’s look at some examples of how that affects the way you write your code. In the next section, you will see some examples of string creation and learn how to understand the syntax of Java Strings.
Create Java String
There are a couple of different ways you can create strings in Java, and each has its own caveats to consider. When working with Java strings the primary thing to remember is that a string is immutable and as such will be reused at any time by the compiler. Any program running within the Java Virtual Machine (JVM) will have access to the string for reuse.
Java String Constructor
The String Constructor is less commonly used but has its own benefits and drawbacks. With the String Constructor, the JVM does not check for the string to be in the pool first. Instead, it creates the string regardless.
String strConst = new String("I’m a String Contructor string");
With respect to performance Java constructors can be fast in the immediate moment. However, if it were used within a loop or some other repetitive task, it could quickly become cumbersome and slow down execution time. Strings created using the new keyword and instructor implicitly create new instances each time it is executed. Within a loop, this could result in many instances getting created, which can have some nasty effects on your software
String Literals
When using string literals, the JVM will always check to see if the string is in the memory pool first, and it will reuse that instance of it. If the string is not in the pool, it will then create a new instance of the string and add it to the pool.
String strLit = "I’m a String literal";
In most situations, this is the best and recommended method to create strings because this method allows more flexibility. It also saves on memory, but even more so when the software is large or heavily repetitive.
String Methods Java
Since strings are so commonly used, one might argue that there are more methods available to work with them than any other type of object in Java. With 28 different methods to use on strings, you have lots of options making strings a very robust object to use in your software.
- length(): The length() method can be used to find the length of a string.
- toUppercase(): This method converts all letters within a string to the uppercase format.
- toLowercase(): This method converts all letters within a string to the lowercase format.
- indexOf(): This method is used to identify the starting index location of a particular substring. [ stringToSearch.indexOf( "Target String" ) ]
On a long enough timeline, you will likely work with all of these methods and many more, further building your knowledge of working with strings.
In the next section, you will see some code examples of using strings in a hypothetical “To-Do List” program.
Java String Example
Learning how to identify when and where to use a string literal versus the string constructor can be a bit tricky. Often times you may feel like you should never use a String Constructor, but there are times when this may be beneficial.
Let’s look at an example of how you can use the string literal in this example of a “To-Do List” program.
In a program like this, you would need to handle a lot of strings, and for most of it, literals will work perfectly. For example, adding a task with the string literal will allow the text to be reused if needed for tasks added later. This means repetitive tasks will not use up as much memory due to reusing information stored in the pool.
This is a simple, yet accurate example of how you can utilize the benefit of string literals. This task is a repetitive nighttime task that the JVM will be able to save memory on by referencing the same string each time.
Furthermore, this would allow you to track your searches and ensure that any repeated search then uses a reference to the previous instance instead of creating a new one,
Creating Java Strings: What to do next
When working with strings there is an endless number of ways to use them in your software. As such, further familiarizing yourself with the methods and behaviors of strings is going to help you solidify your understanding of them. Below are some more methods you can study and experiment with in your code.
- startsWith(): Checks if a string begins with a given string
- endsWith(): Checks if a string ends with a given string
- compareTo(): Compares two strings
- compareToIgnoreCase(): Compares two strings while ignoring letter case
- contains(): Checks if a target string contains a given string
- substring(): Returns a substring of a given string
You’ve learned a lot about what strings are and discovered some very interesting caveats about them. Moving forward, your next steps would be to start studying the various other methods mentioned above. You can even dig into the workings of the Java String class to better understand how the class works.
