Java All String Class Methods with Examples

Author:

Introduction

In this guide, we will explore all Java String class methods with examples, covering the methods available up to Java 21. We will continue to update this guide with new String class methods introduced in future Java releases.

Strings are immutable in Java, meaning once a String object is created, its value cannot be changed. Instead, every modification results in the creation of a new String object. The java.lang.String class is used to create and manipulate strings, offering a wide array of methods to handle text.

Table of Contents

  1. String Overview
  2. String Constructors
  3. String Methods
    • charAt()
    • codePointAt()
    • codePointBefore()
    • codePointCount()
    • compareTo()
    • compareToIgnoreCase()
    • concat()
    • contains()
    • contentEquals()
    • endsWith()
    • equals() and equalsIgnoreCase()
    • getBytes()
    • getChars()
    • hashCode()
    • indexOf()
    • intern()
    • lastIndexOf()
    • length()
    • regionMatches()
    • replace()
    • replaceAll()
    • replaceFirst()
    • split()
    • startsWith()
    • subSequence()
    • substring()
    • toCharArray()
    • toLowerCase()
    • toUpperCase()
    • trim()
    • valueOf()
    • strip()
    • stripLeading()
    • stripTrailing()
    • isBlank()
    • lines()
    • repeat()
    • indent()
    • transform()
    • describeConstable()
    • resolveConstantDesc()
    • formatted()
    • stripIndent()
    • translateEscapes()
  4. Conclusion

String Overview

Creating Strings

There are two ways to create a String object: by string literal or by using the new keyword.

Using String Literal

String s = "javaguides";

Using new Keyword

public class StringExample {
    public static void main(String[] args) {
        String str = new String("Java Guides");
        int length = str.length();
        System.out.println("Length of the string '" + str + "' is: " + length);
    }
}

Output:

Length of the string 'Java Guides' is: 11

Using Character Array

char[] chars = {'a', 'b', 'c'};
String s = new String(chars);

String Constructors

The String class supports several constructors. Here are a few important ones with examples:

Default Constructor

String s = new String();

From Character Array

char[] chars = {'a', 'b', 'c'};
String s = new String(chars);

Subrange of Character Array

char[] chars = {'a', 'b', 'c', 'd', 'e', 'f'};
String s = new String(chars, 2, 3);

From Another String

String s1 = new String("Hello");
String s2 = new String(s1);
System.out.println(s1); // Output: Hello
System.out.println(s2); // Output: Hello

String Methods

charAt()

Returns the char value at the specified index.

public class CharAtExample {
    public static void main(String[] args) {
        String str = "Welcome to string handling guide";
        char ch1 = str.charAt(0);
        System.out.println("Character at 0 index is: " + ch1);
    }
}

Output:

Character at 0 index is: W

codePointAt()

Returns the character (Unicode code point) at the specified index.

public class CodePointAtExample {
    public static void main(String[] args) {
        String str = "javaguides";
        int unicode = str.codePointAt(0);
        System.out.println("Unicode code point at index 0 is: " + unicode);
    }
}

Output:

Unicode code point at index 0 is: 106

codePointBefore()

Returns the character (Unicode code point) before the specified index.

public class CodePointBeforeExample {
    public static void main(String[] args) {
        String str = "javaguides";
        int unicode = str.codePointBefore(1);
        System.out.println("Unicode code point before index 1 is: " + unicode);
    }
}

Output:

Unicode code point before index 1 is: 106

codePointCount()

Returns the number of Unicode code points in the specified text range.

public class CodePointCountExample {
    public static void main(String[] args) {
        String str = "javaguides";
        int unicodeCount = str.codePointCount(0, str.length());
        System.out.println("Number of Unicode code points: " + unicodeCount);
    }
}

Output:

Number of Unicode code points: 10

compareTo()

Compares two strings lexicographically.

public class CompareToExample {
    public static void main(String[] args) {
        String s1 = "Hello World";
        String s2 = "Java";
        System.out.println(s1.compareTo(s2)); // Output: 2 (because "H" is 2 characters after "J")
    }
}

Output:

2

compareToIgnoreCase()

Compares two strings lexicographically, ignoring case differences.

public class CompareToIgnoreCaseExample {
    public static void main(String[] args) {
        String s1 = "Hello World";
        String s2 = "hello world";
        System.out.println(s1.compareToIgnoreCase(s2)); // Output: 0
    }
}

Output:

0

concat()

Concatenates the specified string to the end of this string.

public class ConcatExample {
    public static void main(String[] args) {
        String str = "javaguides";
        str = str.concat(".net");
        System.out.println(str); // Output: javaguides.net
    }
}

Output:

javaguides.net

contains()

Returns true if and only if this string contains the specified sequence of char values.

public class ContainsExample {
    public static void main(String[] args) {
        String str = "javaguides";
        boolean contains = str.contains("guides");
        System.out.println("Contains 'guides': " + contains); // Output: true
    }
}

Output:

Contains 'guides': true

contentEquals()

Compares this string to the specified CharSequence.

public class ContentEqualsExample {
    public static void main(String[] args) {
        String str = "javaguides";
        boolean isContentEquals = str.contentEquals("javaguides");
        System.out.println("Content equals: " + isContentEquals); // Output: true
    }
}

Output:

Content equals: true

endsWith()

Tests if this string ends with the specified suffix.

public class EndsWithExample {
    public static void main(String[] args) {
        String str = "javaguides";
        boolean endsWith = str.endsWith("guides");
        System.out.println("Ends with 'guides': " + endsWith); // Output: true
    }
}

Output:

Ends with 'guides': true

equals() and equalsIgnoreCase()

Compares two strings for equality.

public class EqualsExample {
    public static void main(String[] args) {
        String str1 = "javaguides";
        String str2 = "JAVAguides";
        System.out.println("Equals: " + str1.equals(str2)); // Output: false
        System.out.println("Equals ignore case: " + str1.equalsIgnoreCase(str2)); // Output: true
    }
}

Output:

Equals: false
Equals ignore case: true

getBytes()

Encodes this String into a sequence of bytes.

public class GetBytesExample {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str = "javaguides";
        byte[] bytes = str.getBytes("UTF-8");
        for (byte b : bytes) {
            System.out.print(b + " ");
        }
    }
}

Output:

106 97 118 97 103 117 105 100 101 115

getChars()

Copies characters from this string into the destination character array.

public class GetCharsExample {
    public static void main(String[] args) {
        String str = "This is a demo of the getChars method.";
        char[] buf = new char[10];
        str.getChars(10, 20, buf, 0);
        System.out.println(buf);
    }
}

Output:

demo of th

hashCode()

Returns a hash code for this string.

public class HashCodeExample {
    public static void main(String[] args) {
        String str = "javaguides";
        int hashCode = str.hashCode();
        System.out.println("Hash code: " + hashCode);
    }
}

Output:

Hash code: -138203751

indexOf()

Returns the index within this string of the first occurrence of the specified character or substring.

public

 class IndexOfExample {
    public static void main(String[] args) {
        String str = "javaguides";
        System.out.println("Index of 'guides': " + str.indexOf("guides"));
    }
}

Output:

Index of 'guides': 4

intern()

Returns a canonical representation for the string object.

public class InternExample {
    public static void main(String[] args) {
        String str = "javaguides";
        String newStr = new String("javaguides");
        System.out.println(newStr.intern() == str); // Output: true
    }
}

Output:

true

lastIndexOf()

Returns the index within this string of the last occurrence of the specified character or substring.

public class LastIndexOfExample {
    public static void main(String[] args) {
        String str = "javaguides";
        System.out.println("Last index of 'g': " + str.lastIndexOf('g'));
    }
}

Output:

Last index of 'g': 4

length()

Returns the length of this string.

public class LengthExample {
    public static void main(String[] args) {
        String str = "Java Guides";
        int length = str.length();
        System.out.println("Length: " + length);
    }
}

Output:

Length: 11

regionMatches()

Tests if two string regions are equal.

public class RegionMatchesExample {
    public static void main(String[] args) {
        String str = "javaguides";
        boolean result = str.regionMatches(0, "java", 0, 4);
        System.out.println("Region matches: " + result); // Output: true
    }
}

Output:

Region matches: true

replace()

Replaces each occurrence of the specified character or substring.

public class ReplaceExample {
    public static void main(String[] args) {
        String str = "javaguides";
        String newStr = str.replace('a', 'b');
        System.out.println("Replaced: " + newStr); // Output: jbvbguides
    }
}

Output:

Replaced: jbvbguides

replaceAll()

Replaces each substring of this string that matches the given regular expression.

public class ReplaceAllExample {
    public static void main(String[] args) {
        String str = "javaguides";
        String newStr = str.replaceAll("[a-z]", "java");
        System.out.println("Replaced all: " + newStr); // Output: javajavajavajavajavajavajavajavajavajava
    }
}

Output:

Replaced all: javajavajavajavajavajavajavajavajavajava

replaceFirst()

Replaces the first substring of this string that matches the given regular expression.

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String str = "javaguides";
        String newStr = str.replaceFirst("[a-z]", "java");
        System.out.println("Replaced first: " + newStr); // Output: javaavaguides
    }
}

Output:

Replaced first: javaavaguides

split()

Splits this string around matches of the given regular expression.

public class SplitExample {
    public static void main(String[] args) {
        String str = "java,guides.net";
        String[] parts = str.split(",");
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

Output:

java
guides.net

startsWith()

Tests if this string starts with the specified prefix.

public class StartsWithExample {
    public static void main(String[] args) {
        String str = "javaguides";
        boolean startsWith = str.startsWith("java");
        System.out.println("Starts with 'java': " + startsWith); // Output: true
    }
}

Output:

Starts with 'java': true

subSequence()

Returns a character sequence that is a subsequence of this sequence.

public class SubSequenceExample {
    public static void main(String[] args) {
        String str = "javaguides";
        CharSequence subSeq = str.subSequence(0, 4);
        System.out.println("Subsequence: " + subSeq); // Output: java
    }
}

Output:

Subsequence: java

substring()

Returns a new string that is a substring of this string.

public class SubStringExample {
    public static void main(String[] args) {
        String str = "javaguides";
        String subStr = str.substring(4);
        System.out.println("Substring from index 4: " + subStr); // Output: guides
    }
}

Output:

Substring from index 4: guides

toCharArray()

Converts this string to a new character array.

public class ToCharArrayExample {
    public static void main(String[] args) {
        String str = "javaguides";
        char[] charArray = str.toCharArray();
        for (char c : charArray) {
            System.out.print(c + " ");
        }
    }
}

Output:

j a v a g u i d e s

toLowerCase()

Converts all of the characters in this string to lowercase using the rules of the default locale.

public class ToLowerCaseExample {
    public static void main(String[] args) {
        String str = "JAVAGUIDES";
        String lowerCaseStr = str.toLowerCase();
        System.out.println("Lowercase: " + lowerCaseStr); // Output: javaguides
    }
}

Output:

Lowercase: javaguides

toUpperCase()

Converts all of the characters in this string to uppercase using the rules of the default locale.

public class ToUpperCaseExample {
    public static void main(String[] args) {
        String str = "javaguides";
        String upperCaseStr = str.toUpperCase();
        System.out.println("Uppercase: " + upperCaseStr); // Output: JAVAGUIDES
    }
}

Output:

Uppercase: JAVAGUIDES

trim()

Returns a string whose value is this string, with any leading and trailing whitespace removed.

public class TrimExample {
    public static void main(String[] args) {
        String str = "   javaguides   ";
        String trimmedStr = str.trim();
        System.out.println("Trimmed: '" + trimmedStr + "'"); // Output: 'javaguides'
    }
}

Output:

Trimmed: 'javaguides'

valueOf()

The valueOf() method converts different types of values into a string. It has multiple overloaded forms.

public class ValueOfExample {
    public static void main(String[] args) {
        boolean b = true;
        char c = 'A';
        int i = 123;
        long l = 12345L;
        float f = 1.23f;
        double d = 1.234567;

        System.out.println(String.valueOf(b)); // Output: true
        System.out.println(String.valueOf(c)); // Output: A
        System.out.println(String.valueOf(i)); // Output: 123
        System.out.println(String.valueOf(l)); // Output: 12345
        System.out.println(String.valueOf(f)); // Output: 1.23
        System.out.println(String.valueOf(d)); // Output: 1.234567
    }
}

Output:

true
A
123
12345
1.23
1.234567

strip()

Removes leading and trailing white space according to the Unicode definition of whitespace.

public class StripExample {
    public static void main(String[] args) {
        String str = "   javaguides   ";
        String strippedStr = str.strip();
        System.out.println("Stripped: '" + strippedStr + "'"); // Output: 'javaguides'
    }
}

Output:

Stripped: 'javaguides'

stripLeading()

Removes leading whitespace.

public class StripLeadingExample {
    public static void main(String[] args) {
        String str = "   javaguides";
        String strippedLeadingStr = str.stripLeading();
        System.out.println("Leading stripped: '" + strippedLeadingStr + "'"); // Output: 'javaguides'
    }
}

Output:

Leading stripped: 'javaguides'

stripTrailing()

Removes trailing whitespace.

public class StripTrailingExample {
    public static void main(String[] args) {
        String str = "javaguides   ";
        String strippedTrailingStr = str.stripTrailing();
        System.out.println("Trailing stripped: '" + strippedTrailingStr + "'"); // Output: 'javaguides'
    }
}

Output:

Trailing stripped: 'javaguides'

isBlank()

Checks if the string is empty or contains only whitespace characters.

public class IsBlankExample {
    public static void main(String[] args) {
        String str = "   ";
        boolean isBlank = str.isBlank();
        System.out.println("Is blank: " + isBlank); // Output: true
    }
}

Output:

Is blank: true

lines()

Returns a stream of lines extracted from the string, separated by line terminators.

public class LinesExample {
    public static void main(String[] args) {
        String str = "javaguides\nJava 11";
        str.lines().forEach(System.out::println);
    }
}

Output:

javaguides
Java 11

repeat()

Repeats the string the specified number of times.

public class RepeatExample {
    public static void main(String[] args) {
        String str = "javaguides ";
        String repeatedStr = str.repeat(3);
        System.out.println("Repeated: " + repeatedStr); // Output: javaguides javaguides javaguides
    }
}

Output:

Repeated: javaguides javaguides javaguides

indent()

Adjusts the indentation of each line of the string based on the value of n.

public class IndentExample {
    public static void main(String[] args) {
        String str = "Java\n12";
        String indentedStr = str.indent(4);
        System.out.println("Indented:\n" + indentedStr);
    }
}

Output:

Indented:
    Java
    12

transform()

Applies the provided function to the string.

public class TransformExample {
    public static void main(String[] args) {
        String original = "  java 12  ";
        String transformed = original
                .transform(String::strip)
                .transform(s -> s.concat(" is awesome"))
                .transform(String::toUpperCase);
        System.out.println("Transformed: " + transformed); // Output: JAVA 12 IS AWESOME
    }
}

Output:

Transformed: JAVA 12 IS AWESOME

describeConstable()

Returns an Optional describing the string, suitable for use in constant expression.

import java.util.Optional;

public class DescribeConstableExample {
    public static void main(String[] args) {
        String str = "Java";
        Optional<String> opt = str.describeConstable();
        opt.ifPresent(System.out::println); // Output: Java
    }
}

Output:

Java

resolveConstantDesc()

Part of the JVM's constant API, resolving a String constant description to a String.

import java.lang.invoke.MethodHandles;

public class ResolveConstantDescExample {
    public static void main(String[] args) {
        String str = "Java";
        String resolved = str.resolveConstantDesc(MethodHandles.lookup());
        System.out.println("Resolved: " + resolved); // Output: Java
    }
}

Output:

Resolved: Java

formatted()

Formats the string using the given arguments, similar to String.format().

public class FormattedExample {
    public static void main(String[] args) {
        String template = "Welcome to %s!";
        String result = template.formatted("javaguides");
        System.out.println("Formatted: " + result); // Output: Welcome to javaguides!
    }
}

Output:

Formatted: Welcome to javaguides!

stripIndent()

Removes incidental white space from the beginning and end of every line in the string.

public class StripIndentExample {
    public static void main(String[] args) {
        String textBlock = """
               javaguides
               Java 15
            """;
        String result = textBlock.stripIndent();
        System.out.println("Stripped Indent:\n" + result);
    }
}

Output:

Stripped Indent:
javaguides
Java 15

translateEscapes()

Translates escape sequences like \n, \t, etc., in the string as if in a string literal.

public class TranslateEscapesExample {
    public static void main(String[] args) {
        String str = "javaguides\\nJava 15";
        String result = str.translateEscapes();
        System.out.println("Translated Escapes:\n" + result);
    }
}

Output:

Translated Escapes:
javaguides
Java 15

Conclusion

The String class in Java provides a comprehensive set of methods for creating, manipulating, and handling strings. By understanding and utilizing these methods, you can efficiently manage string operations in your Java applications. This guide covers a broad range of methods introduced up to Java 21, demonstrating how to use each with simple, beginner-friendly examples.

References

Comments

Post a Comment

Leave Comment