1. Overview

1.概述

In this tutorial, we’ll explore how to convert a String to a long primitive or Long object.

在本教程中，我们将探讨如何将 String 转换为 long 基元或 Long 对象。

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.

假设我们有一个 字符串，其值反映的数字刚好超出有符号 Int 的范围。让我们使用 Integer.MAX_VALUE + 1，它的值是 2,147,483,648.

2. Using Long‘s Constructor

2.使用 Long 的构造函数

Given our String, we can use the overloaded Long constructor that takes a String as an argument:

有了 String 之后，我们可以 使用重载的 Long 构造函数，该构造函数将 String 作为参数：

Long l = new Long("2147483648");

This creates a new Long instance which can be converted to a primitive long by invoking the longValue() method.

这会创建一个新的 Long 实例，通过调用 longValue() 方法，可以将该实例转换为基元 long 。

Alternatively, we can take advantage of unboxing to convert our Long object to its primitive equivalent in one statement:

或者，我们可以利用开箱功能，在一条语句中将 Long 对象转换为其原始等价物：

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.

不过，自 Java 9 起，该构造函数已被弃用，转而使用 Long 类的静态工厂方法 valueOf() 或 parseLong() 。

3. Using the Long.valueOf() Method

3.使用 Long.valueOf() 方法

When we want to obtain a Long object from our String, it’s recommended to use the static factory method valueOf():

当我们想从 String 中获取 Long 对象时，建议使用静态工厂方法 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.

这种方法是首选，因为它可以缓存常用的 Long 实例，从而提供更好的性能和内存开销。这与构造函数形成鲜明对比，后者每次调用都会创建一个新实例。

4. Using the Long.parseLong() Method

4.使用 Long.parseLong() 方法

When we want to return a long primitive, we can use the parseLong() static factory method:

当我们要返回 long 基元时，可以使用 parseLong() 静态工厂方法：

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.

当我们想获得一个 long 基元时，这种方法比构造函数和 valueOf() 更受青睐。这是因为 它可以直接返回 long 基元，而无需在转换过程中创建不必要的 Long 对象。

5. Using the Long.decode() Method

5.使用 Long.decode() 方法

If our String is in hexadecimal form, we can use the static factory method decode() to convert it to a Long object.

如果 String 是十六进制形式，我们可以使用静态工厂方法 decode() 将其转换为 Long 对象。

Thus, let’s say we have a hexadecimal notation for our String:

因此，假设我们的 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.

值得注意的是，该方法还支持十进制和八进制符号。因此，在使用此方法时，我们必须警惕String中的前导零。

6. Using Apache Commons’ NumberUtils.createLong() Method

6.使用 Apache Commons 的 NumberUtils.createLong() 方法

To use Apache Commons Lang 3, we add the following dependency to our pom.xml:

要使用 Apache Commons Lang 3，我们需要在 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:

静态工厂方法 createLong() 将 String 转换为 Long 对象：

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.

它在引擎盖下使用了 Long.decode() 并增加了一个重要参数–如果 String 参数为 null，则返回 null.

7. Using the Long.parseUnsignedLong() Method

7.使用 Long.parseUnsignedLong() 方法

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:

现在，假设我们有一个 String 字符串，它表示的值超出了 long 基元的有符号范围。我们可以使用范围为 0 至 18,446,744,073,709,551,615 的 parseUnsignedLong() 静态工厂方法获得一个 unsigned long ：

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.

与我们在本文中探讨的其他选项不同，如果 String 中的第一个字符是 ASCII 负号，则会抛出 NumberFormatException 异常。

8. Using Google Guava’s Longs.tryParse() Method

8.使用 Google Guava 的 Longs.tryParse() 方法

To use Google Guava, we add the following dependency to our pom.xml:

要使用 Google Guava，我们需要在 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():

现在，我们可以使用 tryParse() 将 String 转换为 Long 对象：

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:

如果出现不可解析的字符串，迄今为止探索的所有选项都会抛出NumberFormatException异常。因此，如果我们想避免抛出此异常，可以使用静态工厂方法 tryParse() 代替返回 null 的方法：

@Test
void givenInvalidString_whenUsingGuavaLongs_thenObtainNull() {
    assertThat(Longs.tryParse("Invalid String")).isNull();
}

9. Conclusion

9.结论

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.

在本文中，我们了解到 parseLong() 是获取给定 String 的 long 基元的首选方法。我们还看到，valueOf() 是为给定的 String 获取 Long 对象的首选方法。

As always, the code samples used in this article can be found over on GitHub.

一如既往，本文中使用的代码示例可在 GitHub 上找到。