Java String Methods with Examples

Author:
The String class in Java is used to represent sequences of characters. Strings are immutable, meaning that once a String object is created, it cannot be changed. This tutorial will cover all methods of the String class with examples and outputs, highlighting key points, use cases, best practices, and performance considerations.

Table of Contents

  1. Introduction
  2. Key Points
  3. String Methods
    • length()
    • charAt()
    • substring()
    • contains()
    • equals()
    • equalsIgnoreCase()
    • compareTo()
    • indexOf()
    • lastIndexOf()
    • startsWith()
    • endsWith()
    • toLowerCase()
    • toUpperCase()
    • trim()
    • replace()
    • replaceAll()
    • split()
    • join()
    • format()
    • valueOf()
  4. Use Cases
  5. Best Practices
  6. Performance Considerations
  7. Conclusion

1. Introduction

The String class in Java is a part of the java.lang package and provides a way to represent and manipulate sequences of characters. Strings are widely used in Java programming, and understanding the methods available in the String class is essential for effective string manipulation.

2. Key Points

  • Strings are immutable in Java.
  • The String class provides a variety of methods for string manipulation.
  • Strings can be concatenated using the + operator.
  • Java provides the StringBuilder and StringBuffer classes for mutable strings.

3. String Methods

3.1. length()

The length() method returns the length of the string.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int length = str.length();
        System.out.println("Length: " + length);
    }
}

Output:

Length: 13

3.2. charAt()

The charAt() method returns the character at the specified index.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        char ch = str.charAt(7);
        System.out.println("Character at index 7: " + ch);
    }
}

Output:

Character at index 7: W

3.3. substring()

The substring() method returns a new string that is a substring of the original string.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String substr = str.substring(7);
        System.out.println("Substring from index 7: " + substr);
    }
}

Output:

Substring from index 7: World!

3.4. contains()

The contains() method returns true if the string contains the specified sequence of char values.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        boolean contains = str.contains("World");
        System.out.println("Contains 'World': " + contains);
    }
}

Output:

Contains 'World': true

3.5. equals()

The equals() method compares the specified string to the current string for equality.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        boolean isEqual = str1.equals(str2);
        System.out.println("Strings are equal: " + isEqual);
    }
}

Output:

Strings are equal: true

3.6. equalsIgnoreCase()

The equalsIgnoreCase() method compares the specified string to the current string for equality, ignoring case considerations.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        boolean isEqual = str1.equalsIgnoreCase(str2);
        System.out.println("Strings are equal (ignore case): " + isEqual);
    }
}

Output:

Strings are equal (ignore case): true

3.7. compareTo()

The compareTo() method compares two strings lexicographically.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";
        int result = str1.compareTo(str2);
        System.out.println("Comparison result: " + result);
    }
}

Output:

Comparison result: -15

3.8. indexOf()

The indexOf() method returns the index within the string of the first occurrence of the specified character or substring.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int index = str.indexOf('o');
        System.out.println("Index of 'o': " + index);
    }
}

Output:

Index of 'o': 4

3.9. lastIndexOf()

The lastIndexOf() method returns the index within the string of the last occurrence of the specified character or substring.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int index = str.lastIndexOf('o');
        System.out.println("Last index of 'o': " + index);
    }
}

Output:

Last index of 'o': 8

3.10. startsWith()

The startsWith() method returns true if the string starts with the specified prefix.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        boolean startsWith = str.startsWith("Hello");
        System.out.println("Starts with 'Hello': " + startsWith);
    }
}

Output:

Starts with 'Hello': true

3.11. endsWith()

The endsWith() method returns true if the string ends with the specified suffix.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        boolean endsWith = str.endsWith("World!");
        System.out.println("Ends with 'World!': " + endsWith);
    }
}

Output:

Ends with 'World!': true

3.12. toLowerCase()

The toLowerCase() method converts all characters in the string to lowercase.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String lowerCaseStr = str.toLowerCase();
        System.out.println("Lowercase: " + lowerCaseStr);
    }
}

Output:

Lowercase: hello, world!

3.13. toUpperCase()

The toUpperCase() method converts all characters in the string to uppercase.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String upperCaseStr = str.toUpperCase();
        System.out.println("Uppercase: " + upperCaseStr);
    }
}

Output:

Uppercase: HELLO, WORLD!

3.14. trim()

The trim() method removes leading and trailing whitespace from the string.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "   Hello, World!   ";
        String trimmedStr = str.trim();
        System.out.println("Trimmed: '" + trimmedStr + "'");
    }
}

Output:

Trimmed: 'Hello, World!'

3.15. replace()

The replace() method replaces each occurrence of the specified character or substring with the specified replacement.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String replacedStr = str.replace('o', 'a');
        System.out.println("Replaced: " + replacedStr);
    }
}

Output:

Replaced: Hella, Warld!

3.16. replaceAll()

The replaceAll() method replaces each substring of the string that matches the given regular expression with the given replacement.

Example:

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String replacedStr = str.replaceAll("o", "a");
        System.out.println("Replaced: " + replacedStr);
    }
}

Output:

Replaced: Hella, Warld!

3.17. split()

The split() method splits the string around matches of the given regular expression.

Example:

import java.util.Arrays;

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String[] parts = str.split(", ");
        System.out.println(Arrays.toString(parts));
    }
}

Output:

[Hello, World!]

3.18. join()

The join() method returns a new string that concatenates the given elements, separated by the specified delimiter.

Example:

public class StringExample {
    public static void main(String[] args) {
        String joinedStr = String.join(", ", "Apple", "Mango", "Banana");
        System.out.println("Joined: " + joinedStr);
    }
}

Output:

Joined: Apple, Mango, Banana

3.19. format()

The format() method returns a formatted string using the specified format string and arguments.

Example:

public class StringExample {
    public static void main(String[] args) {
        String formattedStr = String.format("Hello, %s!", "World");
        System.out.println("Formatted: " + formattedStr);
    }
}

Output:

Formatted: Hello, World!

3.20. valueOf()

The valueOf() method returns the string representation of the specified argument.

Example:

public class StringExample {
    public static void main(String[] args) {
        int number = 123;
        String str = String.valueOf(number);
        System.out.println("String value: " + str);
    }
}

Output:

String value: 123

4. Use Cases

  • Text processing: Manipulating and processing text data.
  • Data formatting: Formatting strings for display or output.
  • Input validation: Checking and validating string input.
  • File handling: Reading and writing text files.

5. Best Practices

  • Use StringBuilder for concatenation: For multiple concatenations, use StringBuilder to avoid creating multiple immutable string objects.
  • Avoid using == for string comparison: Use equals() or equalsIgnoreCase() for comparing strings.
  • Use regex judiciously: Regular expressions can be powerful but may affect performance if overused.

6. Performance Considerations

  • Immutable nature: Strings are immutable, so operations that modify strings create new string objects.
  • String pooling: Java uses string pooling to optimize memory usage for string literals.

7. Conclusion

The String class in Java provides a wide range of methods for string manipulation. By understanding its methods, use cases, and best practices, you can effectively utilize the String class in your Java applications. This tutorial covers the essential methods with examples, ensuring a comprehensive understanding of how to work with strings in Java.

Comments

Post a Comment

Leave Comment