Title here
Summary here
The standard library’s String
class provides many useful string-related functions. Here are some examples to give you a sense of the class and its methods.
import java.util.Arrays;
public class StringFunctions {
// We create a shorthand for System.out.println as we'll use it a lot below.
private static void p(String s) {
System.out.println(s);
}
public static void main(String[] args) {
// Here's a sample of the methods available in String.
// Since these are methods on the String object itself,
// we call them directly on the string in question.
// You can find more methods in the String class documentation.
p("Contains: " + "test".contains("es"));
p("Count: " + countOccurrences("test", 't'));
p("StartsWith: " + "test".startsWith("te"));
p("EndsWith: " + "test".endsWith("st"));
p("IndexOf: " + "test".indexOf("e"));
p("Join: " + String.join("-", "a", "b"));
p("Repeat: " + "a".repeat(5));
p("Replace: " + "foo".replace("o", "0"));
p("Replace: " + "foo".replaceFirst("o", "0"));
p("Split: " + Arrays.toString("a-b-c-d-e".split("-")));
p("ToLower: " + "TEST".toLowerCase());
p("ToUpper: " + "test".toUpperCase());
}
// Java doesn't have a built-in count method, so we implement our own
private static int countOccurrences(String str, char ch) {
return (int) str.chars().filter(c -> c == ch).count();
}
}
When you run this program, you’ll get:
$ java StringFunctions
Contains: true
Count: 2
StartsWith: true
EndsWith: true
IndexOf: 1
Join: a-b
Repeat: aaaaa
Replace: f00
Replace: f0o
Split: [a, b, c, d, e]
ToLower: test
ToUpper: TEST
Note that Java’s String methods are slightly different from the functions in the Go strings
package:
Count
method, so we implemented our own.HasPrefix
and HasSuffix
are called startsWith
and endsWith
in Java.Index
is called indexOf
in Java.Join
is a static method on the String class in Java.Replace
in Java replaces all occurrences by default, while replaceFirst
replaces only the first occurrence.These differences reflect the object-oriented nature of Java compared to Go’s more procedural approach to string manipulation.