String Literals vs. String Objects in Java
Table of Contents
- Introduction
- What are String Literals and String Objects?
- Comparison of String Literals and String Objects
- String Comparison Using
==andequals() - Example Code for String Literal and Object Comparison
- Conclusion
1. Introduction
In Java, strings are widely used to store and manipulate text. However, developers often encounter two types of string declarations: string literals and string objects.
Understanding the difference between these two can lead to more efficient memory usage and better performance in Java applications. This article will explore the distinction between string literals and string objects,
discuss how Java manages them in memory, and explain when and where to use each type.
2. What are String Literals and String Objects?
- String Literals: In Java, string literals are created using double quotes, like
String str1 = "Hello World!!";. These literals are stored in the String Pool, a special memory area within the heap that optimizes memory by storing one instance of each string literal. - String Objects: On the other hand, string objects are created using the
newkeyword, likeString str3 = new String("Hello World!!");. These strings are stored separately in the heap, even if their content is the same as that of a string literal.
3. Comparison of String Literals and String Objects
| Feature | String Literal | String Object |
|---|---|---|
| Memory Allocation | Stored in the String Pool | Stored in the heap memory |
| Creation | Created using double quotes, e.g., String str1 = "Hello"; |
Created using the new keyword, e.g., String str3 = new String("Hello"); |
| Memory Efficiency | More memory-efficient due to reuse from the String Pool | Less memory-efficient since new objects are created even if the value is the same |
| Equality Check | Can be checked using == since literals in the pool point to the same object |
Must be checked using equals() as they are distinct objects in the heap |
4. String Comparison Using == and equals()
Java allows two main methods for comparing strings: the == operator and the equals() method. Here’s how they differ:
==Operator: This checks if two string references point to the same memory location.equals()Method: This checks if the content of two strings is the same, regardless of whether they are stored in different locations.
5. Example Code for String Literal and Object Comparison
Here is a practical example of how to compare string literals and string objects in Java:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public class Main { public static void main(String[] args) { // String literals String str1 = "Hello World!!"; String str2 = "Hello World!!"; // String objects String str3 = new String("Hello World!!"); String str4 = new String("Hello World!!"); // Comparison using '==' System.out.println("str1 == str2: " + (str1 == str2)); // true System.out.println("str3 == str4: " + (str3 == str4)); // false // Comparison using equals() System.out.println("str3.equals(str4): " + str3.equals(str4)); // true } } |
Explanation:
- String Literals (str1, str2): Both
str1andstr2refer to the same memory location in the String Pool, so the comparison using==returnstrue. - String Objects (str3, str4): Even though
str3andstr4contain the same content, they refer to different memory locations in the heap. Therefore,str3 == str4returnsfalse. However, usingstr3.equals(str4)returnstruebecause the content of both strings is the same.
6. Conclusion
Java string literals and string objects serve different purposes when it comes to memory management and performance.
String literals are more memory-efficient, as they are stored in the String Pool and reused by the JVM. String objects, however, are useful when you need to create distinct instances of a string, even with the same content.
When comparing strings, it is important to use the equals() method to check for content equality, especially when working with string objects.