1. Overview
In this tutorial, we’ll explore how to convert a String to a long primitive or Long object.
Let’s suppose we have a String whose value reflects a number just outside the range of a signed int. Let’s go with Integer.MAX_VALUE + 1 which is 2,147,483,648.
2. Using Long‘s Constructor
Given our String, we can use the overloaded Long constructor that takes a String as an argument:
Long l = new Long("2147483648");This creates a new Long instance which can be converted to a primitive long by invoking the longValue() method.
Alternatively, we can take advantage of unboxing to convert our Long object to its primitive equivalent in one statement:
long l = new Long("2147483648");However, since Java 9, the use of this constructor has been deprecated in favor of using the static factory methods valueOf() or parseLong() of the Long class.
3. Using the Long.valueOf() Method
When we want to obtain a Long object from our String, it’s recommended to use the static factory method valueOf():
Long l = Long.valueOf("2147483648");This method is preferred as it caches commonly used Long instances to deliver better performance and memory overhead. This is in contrast to the constructor which creates a new instance each time it’s invoked.
4. Using the Long.parseLong() Method
When we want to return a long primitive, we can use the parseLong() static factory method:
long l = Long.parseLong("2147483648");This approach is preferred over the constructor and valueOf() when we want to obtain a long primitive. This is because it returns a long primitive directly without creating an unnecessary Long object as part of the conversion.
5. Using the Long.decode() Method
If our String is in hexadecimal form, we can use the static factory method decode() to convert it to a Long object.
Thus, let’s say we have a hexadecimal notation for our String:
Long l = Long.decode("0x80000000");Notably, this method also supports decimal and octal notations. Thus, we must be vigilant for leading zeros in our String when using this method.
6. Using Apache Commons’ NumberUtils.createLong() Method
To use Apache Commons Lang 3, we add the following dependency to our pom.xml:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.14.0</version>
</dependency>The static factory method createLong() converts a String to a Long object:
Long l = NumberUtils.createLong("0x80000000");It uses Long.decode() under the hood with one important addition – if the String argument is null, then it returns null.
7. Using the Long.parseUnsignedLong() Method
Now, let’s suppose we have a String which represents a value outside of the signed range of the long primitive. We can obtain an unsigned long using the parseUnsignedLong() static factory method for the range 0 to 18,446,744,073,709,551,615:
long l = Long.parseUnsignedLong("9223372036854775808");In contrast to the other options we explored in this article, if the first character in the String is the ASCII negative sign a NumberFormatException is thrown.
8. Using Google Guava’s Longs.tryParse() Method
To use Google Guava, we add the following dependency to our pom.xml:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>33.0.0-jre</version>
</dependency>Now, given our String we can convert it to a Long object using tryParse():
Long l = Longs.tryParse("2147483648");All of the options explored so far throw a NumberFormatException in the event of a non-parseable String. Therefore, if we want to avoid the possibility of this exception being thrown, we can use the static factory method tryParse() which returns null instead:
@Test
void givenInvalidString_whenUsingGuavaLongs_thenObtainNull() {
assertThat(Longs.tryParse("Invalid String")).isNull();
}9. Conclusion
In this article, we’ve learned that parseLong() is the preferred approach to obtain a long primitive for a given String. We also saw that valueOf() is the preferred approach to obtain a Long object for a given String.
As always, the code samples used in this article can be found over on GitHub.
