Module  java.base
软件包  java.lang

Class Long

  • All Implemented Interfaces:
    SerializableComparable<Long>


    public final class Long
    extends Number
    implements Comparable<Long>
    Long类包装一个对象中的原始类型long的值。 类型为Long的对象包含一个单一字段,其类型为long

    此外,该类还提供了一些将long转换为StringString转换为long ,以及在处理long时有用的其他常数和方法。

    实施说明:“bit twiddling”方法(例如highestOneBitnumberOfTrailingZeros )的实现基于Henry S. Warren,Jr.的Hacker's Delight (Addison Wesley,2002)的材料。

    从以下版本开始:
    1.0
    另请参见:
    Serialized Form
    • Field Summary

      Fields  
      Modifier and Type Field 描述
      static int BYTES
      用于表示二进制补码二进制形式的 long值的字节数。
      static long MAX_VALUE
      一个持有最大值的常数a long可以有2 63 -1。
      static long MIN_VALUE
      的常量保持的最小值的 long可以具有-2 63。
      static int SIZE
      用于表示二进制补码二进制形式的 long值的位数。
      static Class<Long> TYPE
      所述 Class实例表示基本类型 long
    • 构造方法摘要

      构造方法  
      Constructor 描述
      Long​(long value)
      已过时。
      很少使用这个构造函数。 静态工厂valueOf(long)通常是一个更好的选择,因为它可能产生明显更好的空间和时间性能。
      Long​(String s)
      已过时。
      很少使用这个构造函数。 使用parseLong(String)将字符串转换为long原语,或使用valueOf(String)将字符串转换为Long对象。
    • 方法摘要

      所有方法  静态方法  接口方法  具体的方法 
      Modifier and Type 方法 描述
      static int bitCount​(long i)
      返回指定的 long值的二进制补码二进制表示中的 long
      byte byteValue​()
      在缩小原始转换后,返回 Long的值作为 byte
      static int compare​(long x, long y)
      数值比较两个 long
      int compareTo​(Long anotherLong)
      数值比较两个 Long对象。
      static int compareUnsigned​(long x, long y)
      比较两个 long值,以数值方式将值视为无符号。
      static Long decode​(String nm)
      String解码成 Long
      static long divideUnsigned​(long dividend, long divisor)
      返回将第一个参数除以秒的无符号商,其中每个参数和结果被解释为无符号值。
      double doubleValue​()
      返回此值 Longdouble一个宽元转换后。
      boolean equals​(Object obj)
      将此对象与指定的对象进行比较。
      float floatValue​()
      返回此值 Longfloat一个宽元转换后。
      static Long getLong​(String nm)
      确定具有指定名称的系统属性的值为 long
      static Long getLong​(String nm, long val)
      确定具有指定名称的系统属性的值为 long
      static Long getLong​(String nm, Long val)
      返回具有指定名称的系统属性的值为 long
      int hashCode​()
      返回此 Long的哈希码。
      static int hashCode​(long value)
      返回一个long值的哈希码; 兼容Long.hashCode()
      static long highestOneBit​(long i)
      在指定的 long值中,最高位(最左边)为1位,最多返回一个 long值,最多只有一个1位。
      int intValue​()
      在缩小的原始转换后,返回 Long的值作为 int
      long longValue​()
      返回此值 Longlong值。
      static long lowestOneBit​(long i)
      在指定的 long值中以最低位(最右边)为1位返回一个 long值,最多只有一个1位。
      static long max​(long a, long b)
      返回两个 long中的较大值,就像调用 Math.max一样
      static long min​(long a, long b)
      返回两个 long中的较小值,就像调用 Math.min一样
      static int numberOfLeadingZeros​(long i)
      返回指定的 long值的二进制补码二进制表示中最高位(“最左”)1位之前的零位数。
      static int numberOfTrailingZeros​(long i)
      返回在指定的 long值的二进制补码二进制表示中的最低位(“最右”)1位之后的零位数。
      static long parseLong​(CharSequence s, int beginIndex, int endIndex, int radix)
      解析CharSequence参数作为有符号long指定radix ,在指定的开始beginIndex并延伸至endIndex - 1
      static long parseLong​(String s)
      将字符串参数解析为有符号的二进制 long
      static long parseLong​(String s, int radix)
      将字符串参数解析为第二个参数指定的基数中的带符号的 long
      static long parseUnsignedLong​(CharSequence s, int beginIndex, int endIndex, int radix)
      解析CharSequence参数为一个无符号long在指定radix ,在指定的开始beginIndex并延伸到endIndex - 1
      static long parseUnsignedLong​(String s)
      将字符串参数解析为无符号小数 long
      static long parseUnsignedLong​(String s, int radix)
      将字符串参数解析为第二个参数指定的基数中的无符号 long
      static long remainderUnsigned​(long dividend, long divisor)
      返回无符号余数,将第一个参数除以秒,其中每个参数和结果被解释为无符号值。
      static long reverse​(long i)
      返回通过反转指定的 long值的二进制补码二进制表示中的位的顺序获得的值。
      static long reverseBytes​(long i)
      返回通过反转指定的 long值的二进制补码表示中的字节顺序获得的值。
      static long rotateLeft​(long i, int distance)
      返回通过将指定的 long值的二进制补码二进制表示旋转指定 long值。
      static long rotateRight​(long i, int distance)
      返回通过将指定的 long值的二进制补码二进制表示旋转指定 long值。
      short shortValue​()
      在缩小原始转换后,返回 Long的值作为 short
      static int signum​(long i)
      返回指定的 long值的signum函数。
      static long sum​(long a, long b)
      根据+操作符将两个 long值添加 long一起。
      static String toBinaryString​(long i)
      返回 long参数的字符串表示形式为基数2中的无符号整数。
      static String toHexString​(long i)
      返回 long参数的字符串表示形式,作为16位中的无符号整数。
      static String toOctalString​(long i)
      在基数8中返回 long参数的字符串表示形式为无符号整数。
      String toString​()
      返回一个表示 Long的值的 String对象。
      static String toString​(long i)
      返回 String表示指定对象 long
      static String toString​(long i, int radix)
      返回由第二个参数指定的基数中的第一个参数的字符串表示形式。
      static String toUnsignedString​(long i)
      将参数的字符串表示形式返回为无符号十进制值。
      static String toUnsignedString​(long i, int radix)
      以第二个参数指定的基数中的无符号整数值返回第一个参数的字符串表示形式。
      static Long valueOf​(long l)
      返回表示指定的 long值的 Long实例。
      static Long valueOf​(String s)
      返回一个保存指定值的 Long对象 String
      static Long valueOf​(String s, int radix)
      返回一个 Long对象,该对象保存从指定的 String提取的值,并使用第二个参数给出的基数进行解析。
    • 字段详细信息

      • MIN_VALUE

        @Native
        public static final long MIN_VALUE
        的常量保持的最小值的 long可以具有-2 63。
        另请参见:
        Constant Field Values
      • MAX_VALUE

        @Native
        public static final long MAX_VALUE
        一个持有最大值a的常数a long可以有2 63 -1。
        另请参见:
        Constant Field Values
      • TYPE

        public static final Class<Long> TYPE
        所述 Class实例表示基本类型 long
        从以下版本开始:
        1.1
      • SIZE

        @Native
        public static final int SIZE
        用于表示二进制补码二进制形式的 long值的位数。
        从以下版本开始:
        1.5
        另请参见:
        Constant Field Values
      • BYTES

        public static final int BYTES
        用于表示二进制补码二进制形式的 long值的字节数。
        从以下版本开始:
        1.8
        另请参见:
        Constant Field Values
    • 构造方法详细信息

      • Long

        @Deprecated(since="9")
        public Long​(long value)
        已过时。 很少使用这个构造函数。 静态工厂valueOf(long)通常是更好的选择,因为它可能产生明显更好的空间和时间性能。
        构造一个新分配的 Long对象,该对象表示指定的 long参数。
        参数
        value - 要由 Long对象表示的值。
      • Long

        @Deprecated(since="9")
        public Long​(String s)
             throws NumberFormatException
        已过时。 很少使用这个构造函数。 使用parseLong(String)将字符串转换为long原语,或使用valueOf(String)将字符串转换为Long对象。
        构造一个新分配的Long对象,表示由String参数指示的long值。 字符串转换为long值,正好与基数为parseLong方法一样。
        参数
        s -的 String转换为一个 Long
        异常
        NumberFormatException - 如果 String不包含可解析的 long
    • 方法详细信息

      • toString

        public static String toString​(long i,
                                      int radix)
        返回由第二个参数指定的基数中的第一个参数的字符串表示形式。

        如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ,则使用基数10

        如果第一个参数为负,则结果的第一个元素为ASCII减号'-''\u002d' )。 如果第一个参数不为负,则结果中不会出现符号字符。

        结果的剩余字符表示第一个参数的大小。 如果幅度为零,则由单个零字符'0''\u0030' )表示; 否则,幅度的表示的第一个字符将不是零字符。 以下ASCII字符用作数字:

        0123456789abcdefghijklmnopqrstuvwxyz
        这些是'\u0030''\u0039''\u0061''\u007a' 如果radixN ,则这些字符的前N个按照所示顺序用作小数N位。 因此,十六进制( 0123456789abcdef 16)的数字是0123456789abcdef 如果需要大写字母,可以对结果调用String.toUpperCase()方法:
        Long.toString(n, 16).toUpperCase()
        参数
        i - 要转换为字符串的 long
        radix - 在字符串表示中使用的基数。
        结果
        指定基数中的参数的字符串表示形式。
        另请参见:
        Character.MAX_RADIXCharacter.MIN_RADIX
      • toUnsignedString

        public static String toUnsignedString​(long i,
                                              int radix)
        以第二个参数指定的基数中的无符号整数值返回第一个参数的字符串表示形式。

        如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ,则使用基数10

        请注意,由于第一个参数被视为无符号值,因此不会打印前导符号。

        如果幅度为零,则由单个零字符'0''\u0030' )表示; 否则,幅度的表示的第一个字符将不是零字符。

        基数的行为和用作数字的字符与toString相同。

        参数
        i - 要转换为无符号字符串的整数。
        radix - 在字符串表示中使用的基数。
        结果
        指定基数中的参数的无符号字符串表示形式。
        从以下版本开始:
        1.8
        另请参见:
        toString(long, int)
      • toHexString

        public static String toHexString​(long i)
        返回long参数的字符串表示形式,作为基数16中的无符号整数。

        无符号的long值是参数加上2 64,如果参数为负数; 否则,它等于论证。 该值转换为十六进制(基数16)的ASCII数字字符串,无额外引导0 s。

        可以通过调用Long.parseUnsignedLong(s, 16)从返回的字符串s恢复参数的值。

        如果无符号大小为零,则由单个零字符'0''\u0030' )表示; 否则,无符号大小的表示的第一个字符将不是零字符。 以下字符用作十六进制数字:

        0123456789abcdef
        这些是'\u0030''\u0039''\u0061''\u0066' 如果需要大写字母,可以对结果调用String.toUpperCase()方法:
        Long.toHexString(n).toUpperCase()
        参数
        i - 一个 long要转换成一个字符串。
        结果
        由十六进制参数(基数16)表示的无符号 long值的字符串表示。
        从以下版本开始:
        1.0.2
        另请参见:
        parseUnsignedLong(String, int)toUnsignedString(long, int)
      • toOctalString

        public static String toOctalString​(long i)
        在基数8中返回long参数的字符串表示形式为无符号整数。

        无符号的long值是参数加上2 64,如果参数为负数; 否则,它等于论证。 该值转换为八进制(基数8)中的ASCII数字字符串,没有额外的前导0 s。

        可以通过调用Long.parseUnsignedLong(s, 8)从返回的字符串s恢复参数的值。

        如果无符号幅度为零,则由单个零字符'0''\u0030' )表示; 否则,无符号大小的表示的第一个字符将不是零字符。 以下字符用作八进制数字:

        01234567
        这些是'\u0030''\u0037'
        参数
        i - 一个 long要转换成一个字符串。
        结果
        由参数以八进制表示的无符号 long值的字符串表示(基数8)。
        从以下版本开始:
        1.0.2
        另请参见:
        parseUnsignedLong(String, int)toUnsignedString(long, int)
      • toBinaryString

        public static String toBinaryString​(long i)
        返回long参数的字符串表示形式为基数2中的无符号整数。

        无符号的long值是参数加上2 64,如果参数为负数; 否则,它等于论证。 该值转换为二进制(基数2)的ASCII数字字符串,没有额外的前导0 s。

        可以通过调用Long.parseUnsignedLong(s, 2)从返回的字符串s恢复参数的值。

        如果无符号大小为零,则由单个零字符'0''\u0030' )表示; 否则,无符号大小的表示的第一个字符将不是零字符。 字符'0''\u0030' )和'1''\u0031' )用作二进制数字。

        参数
        i - 一个 long要转换为字符串。
        结果
        由二进制(基数2)中的参数表示的无符号 long值的字符串表示。
        从以下版本开始:
        1.0.2
        另请参见:
        parseUnsignedLong(String, int)toUnsignedString(long, int)
      • toString

        public static String toString​(long i)
        返回String表示指定对象long 参数被转换为带符号的十进制表示形式,并作为字符串返回,就好像参数和基数10作为toString(long, int)方法的参数。
        参数
        i - a long待转换。
        结果
        基数10中的参数的字符串表示形式。
      • toUnsignedString

        public static String toUnsignedString​(long i)
        将参数的字符串表示形式返回为无符号十进制值。 参数转换为无符号十进制表示形式,并作为字符串返回,正如参数和小数10作为toUnsignedString(long, int)方法的参数一样
        参数
        i - 要转换为无符号字符串的整数。
        结果
        参数的无符号字符串表示形式。
        从以下版本开始:
        1.8
        另请参见:
        toUnsignedString(long, int)
      • parseLong

        public static long parseLong​(String s,
                                     int radix)
                              throws NumberFormatException
        在第二个参数指定的基数中将字符串参数解析为带符号的long 字符串中的字符必须全部是指定基数的数字(由Character.digit(char, int)是否返回非负值确定),除了第一个字符可能是ASCII减号'-''\u002D' )以指示负值或ASCII加号'+''\u002B' )以表示正值。 返回产生的long值。

        请注意,字符L'\u004C' )和L'\u004C' )以及l'\u006C' )均不允许出现在字符串的末尾作为类型指示符,如Java编程语言源代码中允许的那样,除了Ll可能显示为数字为大于或等于22的基数。

        如果发生以下任何一种情况,则抛出类型为NumberFormatException的异常:

        • 第一个参数是null或是长度为零的字符串。
        • radix或小于Character.MIN_RADIX或大于Character.MAX_RADIX
        • 字符串的任何字符不是指定基数的数字,除了第一个字符可能是负号'-''\u002d' )或加号'+''\u002B' ),前提是字符串长于长度1。
        • 由字符串表示的值不是long类型的值。

        例子:

         parseLong("0", 10) returns 0L
         parseLong("473", 10) returns 473L
         parseLong("+42", 10) returns 42L
         parseLong("-0", 10) returns 0L
         parseLong("-FF", 16) returns -255L
         parseLong("1100110", 2) returns 102L
         parseLong("99", 8) throws a NumberFormatException
         parseLong("Hazelnut", 10) throws a NumberFormatException
         parseLong("Hazelnut", 36) returns 1356099454469L
         
        参数
        s -所述 String含有 long表示来进行解析。
        radix - 解析时使用的基数 s
        结果
        由指定基数中的字符串参数表示的 long
        异常
        NumberFormatException - 如果字符串不包含可解析的 long
      • parseLong

        public static long parseLong​(CharSequence s,
                                     int beginIndex,
                                     int endIndex,
                                     int radix)
                              throws NumberFormatException
        解析CharSequence参数作为有符号long指定radix ,在指定的开始beginIndex并延伸至endIndex - 1

        该方法在解析时不采取措施来防范CharSequence被突变。

        参数
        s -所述 CharSequence含有 long表示被解析
        beginIndex - 包含起始索引。
        endIndex - 结束索引,独占。
        radix - 解析时使用的基数 s
        结果
        由指定基数的子 long表示的带符号的 long
        异常
        NullPointerException - 如果 s为空。
        IndexOutOfBoundsException - 如果 beginIndex为负数,或者如果 beginIndex大于 endIndex或者如果 endIndex大于 s.length()
        NumberFormatException - 如果 int在指定的 CharSequence中不包含可解析的 radix ,或者如果 radix小于 Character.MIN_RADIX或大于 Character.MAX_RADIX
        从以下版本开始:
        9
      • parseLong

        public static long parseLong​(String s)
                              throws NumberFormatException
        解析字符串参数作为带符号的二进制long 字符串中的字符必须都是十进制数字,除了第一个字符可能是ASCII减号'-'\u002D' )以指示负值或ASCII加号'+''\u002B' )表示正值。 返回的结果为long ,就像参数和基数10作为parseLong(java.lang.String, int)方法的参数一样

        注意字符L'\u004C' )和L'\u004C' )以及l'\u006C' )都不允许作为类型指示符出现在字符串的末尾,如在Java编程语言源代码中允许的那样。

        参数
        s - a String包含要解析的 long表示
        结果
        long由参数以十进制表示。
        异常
        NumberFormatException - 如果字符串不包含可解析的 long
      • parseUnsignedLong

        public static long parseUnsignedLong​(String s,
                                             int radix)
                                      throws NumberFormatException
        在第二个参数指定的基数中将字符串参数解析为无符号的long 无符号整数将通常与负数相关联的值映射到大于MAX_VALUE正数。 字符串中的字符必须全部是指定基数的数字(由Character.digit(char, int)是否返回非负值确定),但第一个字符可能是ASCII加号'+''\u002B' )。 返回所得到的整数值。

        如果发生以下任何一种情况,则抛出类型为NumberFormatException的异常:

        • 第一个参数是null或是长度为零的字符串。
        • 基数小于Character.MIN_RADIX或大于Character.MAX_RADIX
        • 字符串的任何字符不是指定基数的数字,除了第一个字符可能是加号'+''\u002B' ),条件是字符串长于长度1。
        • 由字符串表示的值大于最大无符号long 64 -1。
        参数
        s - 包含要解析的无符号整数表示的 String
        radix - 解析时使用的基数 s
        结果
        long由指定基数中的字符串参数表示。
        异常
        NumberFormatException - 如果 String不包含可解析的 long
        从以下版本开始:
        1.8
      • parseUnsignedLong

        public static long parseUnsignedLong​(CharSequence s,
                                             int beginIndex,
                                             int endIndex,
                                             int radix)
                                      throws NumberFormatException
        解析CharSequence参数为一个无符号long在指定radix ,在指定的开始beginIndex并延伸到endIndex - 1

        该方法没有采取措施来防止CharSequence在解析时被突变。

        参数
        s -所述 CharSequence含有无符号 long表示被解析
        beginIndex - 包含起始索引。
        endIndex - 结束索引,独家。
        radix - 解析时使用的基数 s
        结果
        无符号的 long由指定基数的子 long表示。
        异常
        NullPointerException - 如果 s为空。
        IndexOutOfBoundsException - 如果 beginIndex为负数,或者如果 beginIndex大于 endIndex或者如果 endIndex大于 s.length()
        NumberFormatException - 如果 long在指定的 CharSequence中不包含可解析的无符号 radix ,或者如果 radix小于 Character.MIN_RADIX或大于 Character.MAX_RADIX
        从以下版本开始:
        9
      • parseUnsignedLong

        public static long parseUnsignedLong​(String s)
                                      throws NumberFormatException
        将字符串参数解析为无符号小数long 字符串中的字符必须都是十进制数字,除了第一个字符可能是ASCII加号'+''\u002B' )。 返回所得到的整数值,就像参数和小数 10被赋予parseUnsignedLong(java.lang.String, int)方法的参数一样
        参数
        s - a String其中包含要解析的无符号 long表示
        结果
        无符号的 long值由十进制字符串参数表示
        异常
        NumberFormatException - 如果字符串不包含可分析的无符号整数。
        从以下版本开始:
        1.8
      • valueOf

        public static Long valueOf​(String s,
                                   int radix)
                            throws NumberFormatException
        当使用第二个参数给出的基数进行解析时,返回一个保存从指定的String提取的值的Long对象。 第一个参数被解释为表示由第二个参数指定的基数中的带符号的long ,就像向parseLong(java.lang.String, int)方法给出的参数一样 结果是一个Long对象,表示由字符串指定的long值。

        换句话说,该方法返回一个Long对象等于的值:

        new Long(Long.parseLong(s, radix))
        参数
        s - 要解析的字符串
        radix - 用于解释的基数 s
        结果
        一个 Long对象,其持有由指定基数中的字符串参数表示的值。
        异常
        NumberFormatException - 如果 String不包含可解析的 long
      • valueOf

        public static Long valueOf​(String s)
                            throws NumberFormatException
        返回一个持有指定值的Long对象String 该参数被解释为表示一个有符号的二进制long ,完全相同于parseLong(java.lang.String)方法的参数。 结果是一个表示由字符串指定的整数值的Long对象。

        换句话说,此方法返回一个Long对象的值等于:

        new Long(Long.parseLong(s))
        参数
        s - 要解析的字符串。
        结果
        一个 Long对象保存由string参数表示的值。
        异常
        NumberFormatException - 如果字符串不能被解析为 long
      • valueOf

        public static Long valueOf​(long l)
        返回表示指定的long值的Long实例。 如果不需要新的Long实例,则该方法通常应优先于构造函数Long(long)使用 ,因为该方法可能通过缓存经常请求的值而产生明显更好的空间和时间性能。 请注意,与corresponding methodInteger类,这种方法不需要缓存值的特定范围内。
        参数
        l - 一个长的值。
        结果
        一个 Long实例,代表 l
        从以下版本开始:
        1.5
      • decode

        public static Long decode​(String nm)
                           throws NumberFormatException
        String解码成Long 接受以下语法给出的十进制,十六进制和八进制数:
        DecodableString:
        Signopt DecimalNumeral
        Signopt 0x HexDigits
        Signopt 0X HexDigits
        Signopt # HexDigits
        Signopt 0 OctalDigits
        Sign:
        -
        +
        DecimalNumeral,HexDigits,OctalDigits如在The Java™ Language Specification 3.10.1部分所定义,所不同的是下划线不数字之间接受。

        可选符号和/或基数说明符(“ 0x ”,“ 0X ”,“ # ”或前导零)之后的Long.parseLong由具有指示的基数(10,16或8)的Long.parseLong方法进行解析。 这个字符序列必须表示正值,或者将抛出一个NumberFormatException 如果指定的String第一个字符为负号,则结果为否定。 String中不允许使用空格字符。

        参数
        nm - 要解码的 String
        结果
        一个 Long对象持有 long值由 nm
        异常
        NumberFormatException - 如果 String不包含可解析的 long
        从以下版本开始:
        1.2
        另请参见:
        parseLong(String, int)
      • byteValue

        public byte byteValue​()
        在缩小原始转换后,返回 Long的值作为 byte
        重写:
        byteValueNumber
        结果
        该对象在转换为 byte之后表示的数值。
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • shortValue

        public short shortValue​()
        返回此值 Longshort的基本收缩转换后。
        重写:
        shortValueNumber
        结果
        该对象在转换为 short之后表示的数值。
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • intValue

        public int intValue​()
        在缩小原始转换后,返回 Long的值作为 int
        Specified by:
        intValueNumber
        结果
        该对象在转换为 int之后表示的数值。
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • longValue

        public long longValue​()
        返回此值 Longlong值。
        Specified by:
        longValueNumber
        结果
        该对象在转换为 long之后表示的数值。
      • floatValue

        public float floatValue​()
        返回此值 Longfloat一个宽元转换后。
        Specified by:
        floatValueNumber
        结果
        该对象在转换为 float之后表示的数值。
        See The Java™ Language Specification:
        5.1.2扩大原始转换
      • doubleValue

        public double doubleValue​()
        返回此值 Longdouble一个宽元转换后。
        Specified by:
        doubleValueNumber
        结果
        该对象在转换为 double之后表示的数值。
        See The Java™ Language Specification:
        5.1.2扩大原始转换
      • toString

        public String toString​()
        返回一个表示Long的值的String对象。 该值将转换为带符号的十进制表示形式,并作为字符串返回,就像long值作为toString(long)方法的参数一样
        重写:
        toStringObject
        结果
        这个对象在基数10中的值的字符串表示。
      • hashCode

        public static int hashCode​(long value)
        返回一个long值的哈希码; 兼容Long.hashCode()
        参数
        value - 哈希值
        结果
        一个 long值的哈希码值。
        从以下版本开始:
        1.8
      • equals

        public boolean equals​(Object obj)
        将此对象与指定的对象进行比较。 如果且仅当参数不是null并且是包含与此对象相同的long值的Long对象时,结果为true
        重写:
        equalsObject
        参数
        obj - 要比较的对象。
        结果
        true如果对象是一样的; false否则。
        另请参见:
        Object.hashCode()HashMap
      • getLong

        public static Long getLong​(String nm,
                                   long val)
        确定具有指定名称的系统属性的值为long

        第一个参数被视为系统属性的名称。 系统属性可通过System.getProperty(java.lang.String)方法访问。 然后,使用long支持的语法将该属性的字符串值解释为long,并返回表示此值的Long对象。

        第二个参数是默认值。 如果没有指定名称的属性,如果该属性没有正确的数字格式,或者指定的名称为空或为空,则返回表示第二个参数的值的Long对象。

        换句话说,该方法返回一个Long对象的值等于:

        getLong(nm, new Long(val))
        但实际上可以以下列方式实现:
         Long result = getLong(nm, null);
         return (result == null) ? new Long(val) : result;
         
        以避免在不需要默认值时不必要地分配Long对象。
        参数
        nm - 属性名称。
        val - 默认值。
        结果
        Long价值为 Long
        异常
        SecurityException - 原因与 System.getProperty相同
        另请参见:
        System.getProperty(java.lang.String)System.getProperty(java.lang.String, java.lang.String)
      • getLong

        public static Long getLong​(String nm,
                                   Long val)
        返回具有指定名称的系统属性的值为long 第一个参数被视为系统属性的名称。 系统属性可通过System.getProperty(java.lang.String)方法访问。 然后将该属性的字符串值解释为long值,按照decode方法,并返回表示此值的Long对象; 综上所述:
        • 如果属性值以两个ASCII字符0x或ASCII字符# ,而不是后跟减号,则其余部分将被解析为与基数16的方法valueOf(java.lang.String, int)完全一致的十六进制整数。
        • 如果属性值以ASCII字符0后跟另一个字符开头,则将其解析为与基数8的方法valueOf(java.lang.String, int)完全一致的八进制整数。
        • 否则,属性值将被解析为十进制整数,与使用基数10的方法valueOf(java.lang.String, int)完全相同。

        注意,在每种情况下, L'\u004C' )和l'\u006C' )作为类型指示符出现在属性值的末尾,如Java编程语言源代码中允许的那样。

        第二个参数是默认值。 如果没有指定名称的属性,如果该属性没有正确的数字格式,或者指定的名称为空,则返回默认值,或者是null

        参数
        nm - 属性名称。
        val - 默认值。
        结果
        Long价值 Long
        异常
        SecurityException - 原因与 System.getProperty相同
        另请参见:
        System.getProperty(java.lang.String)System.getProperty(java.lang.String, java.lang.String)
      • compareTo

        public int compareTo​(Long anotherLong)
        以数字方式比较两个 Long对象。
        Specified by:
        compareTo在接口 Comparable<Long>
        参数
        anotherLong - 要比较的 Long
        结果
        0如果这个Long等于参数Long ; 的值小于0 ,如果这Long在数值上小于该参数Long ; 和大于一个值0 ,如果这Long在数值上大于该参数Long (带符号的比较)。
        从以下版本开始:
        1.2
      • compare

        public static int compare​(long x,
                                  long y)
        数值比较两个long 返回的值与以下内容相同:
          Long.valueOf(x).compareTo(Long.valueOf(y)) 
        参数
        x - 第一个 long进行比较
        y - 第二个 long进行比较
        结果
        0如果是x == y ; 一个值小于0如果是x < y ; 和值大于0如果x > y
        从以下版本开始:
        1.7
      • compareUnsigned

        public static int compareUnsigned​(long x,
                                          long y)
        比较两个 long值,以数值方式将值视为无符号。
        参数
        x - 第一个 long进行比较
        y - 第二个 long进行比较
        结果
        0如果是x == y ; 一个值小于0如果x < y为无符号值; 并且如果x > y为无符号值,则值大于0
        从以下版本开始:
        1.8
      • divideUnsigned

        public static long divideUnsigned​(long dividend,
                                          long divisor)
        返回将第一个参数除以秒的无符号商,其中每个参数和结果被解释为无符号值。

        注意,在二进制补码算术中,如果两个操作数被认为是被签名的或者两个都是无符号的,则加法,减法和乘法的三个其他基本算术运算是逐位相同的。 因此不提供addUnsigned等方法。

        参数
        dividend - 要划分的值
        divisor - 做分割的值
        结果
        第一个参数的无符号商除以第二个参数
        从以下版本开始:
        1.8
        另请参见:
        remainderUnsigned(long, long)
      • remainderUnsigned

        public static long remainderUnsigned​(long dividend,
                                             long divisor)
        返回无符号余数,将第一个参数除以秒,其中每个参数和结果被解释为无符号值。
        参数
        dividend - 要划分的值
        divisor - 做分割的价值
        结果
        第一个参数的无符号余数除以第二个参数
        从以下版本开始:
        1.8
        另请参见:
        divideUnsigned(long, long)
      • highestOneBit

        public static long highestOneBit​(long i)
        返回一个long值至多一个单个1位,在最高阶(“最左侧”)的位置在指定的一比特long值。 如果指定的值在其二进制补码二进制表示中没有1位,也就是说,如果它等于零,则返回零。
        参数
        i - 要计算其最高一位的值
        结果
        具有单个1位的 long值,在指定值中的最高位1位的位置,如果指定的值本身等于零,则为零。
        从以下版本开始:
        1.5
      • lowestOneBit

        public static long lowestOneBit​(long i)
        在指定的long值中以最低位(最右)的位置返回long值,最多只有一个1位。 如果指定的值在其二进制补码二进制表示中没有1位,也就是说,如果它等于零,则返回零。
        参数
        i - 要计算最低一位的值
        结果
        具有单个1位的 long值,在指定值中的最低位1位的位置,如果指定的值本身等于零,则为零。
        从以下版本开始:
        1.5
      • numberOfLeadingZeros

        public static int numberOfLeadingZeros​(long i)
        返回指定的long值的二进制补码二进制表示中最高位(“最左”)1位之前的零位数。 如果指定的值在其二进制补码表示中没有一位,换句话说如果它等于零则返回64。

        请注意,该方法与对数基数2密切相关。对于所有正值long值x:

        • floor(log 2 (x))= 63 - numberOfLeadingZeros(x)
        • ceil(log 2 (x))= 64 - numberOfLeadingZeros(x - 1)
        参数
        i - 要计算前导零数的值
        结果
        在指定的 long值的二进制补码二进制表示中的最高位(“最左”)1位之前的零位数,如果该值等于零,则为64。
        从以下版本开始:
        1.5
      • numberOfTrailingZeros

        public static int numberOfTrailingZeros​(long i)
        返回在指定的long值的二进制补码二进制表示中的最低位(“最右”)1位之后的零位数。 如果指定的值在其二进制补码表示中没有一位,换句话说如果它等于零则返回64。
        参数
        i - 要计算尾数零的值
        结果
        在指定的 long值的二进制补码二进制表示中的最低位(“最右”)1位后的零位数,如果该值等于零,则为64位。
        从以下版本开始:
        1.5
      • bitCount

        public static int bitCount​(long i)
        返回指定的long值的二进制补码二进制表示中的long 此功能有时称为人口数量
        参数
        i - 要对其位进行计数的值
        结果
        二进制数的二进制补码二进制表示为指定的 long值。
        从以下版本开始:
        1.5
      • rotateLeft

        public static long rotateLeft​(long i,
                                      int distance)
        返回通过将指定的long值的二进制补码二进制表示旋转指定的long值。 (左侧移位的位或右侧的高位侧重新输入,或低位)。

        请注意,具有负距离的左旋转相当于右旋: rotateLeft(val, -distance) == rotateRight(val, distance) 由64多个任何还需要注意的是旋转是一个空操作,所以所有,但旋转距离的后6位可以忽略,即使距离为负: rotateLeft(val, distance) == rotateLeft(val, distance & 0x3F)

        参数
        i - 其位要向左旋转的值
        distance - 向左旋转的位位数
        结果
        通过将指定的 long值的二进制补码二进制表示旋转指定的 long值。
        从以下版本开始:
        1.5
      • rotateRight

        public static long rotateRight​(long i,
                                       int distance)
        返回通过将指定的long值的二进制补码二进制表示旋转指定long值。 (右侧移位的位或左侧的低位侧重新输入,或高位)。

        注意,具有负距离的右旋转相当于左旋: rotateRight(val, -distance) == rotateLeft(val, distance) 还要注意,64的任意倍数的旋转是无操作的,因此除旋转距离的最后六位之外,除了距离为负值外,也可以忽略旋转距离的最后六位之外的所有旋转: rotateRight(val, distance) == rotateRight(val, distance & 0x3F)

        参数
        i - 其位要向右旋转的值
        distance - 要向右旋转的位位数
        结果
        通过将指定的 long值的二进制补码二进制表示旋转指定的 long值。
        从以下版本开始:
        1.5
      • reverse

        public static long reverse​(long i)
        返回通过反转指定的 long值的二进制补码二进制表示中的位的顺序获得的值。
        参数
        i - 要反转的值
        结果
        通过在指定的 long值中反转位的顺序获得的值。
        从以下版本开始:
        1.5
      • signum

        public static int signum​(long i)
        返回指定的long值的signum函数。 (如果指定的值为负,返回值为-1;如果指定的值为零,返回值为0;如果指定的值为正,返回值为1)。
        参数
        i - 要计算其符号的值
        结果
        指定功能的指定值为 long
        从以下版本开始:
        1.5
      • reverseBytes

        public static long reverseBytes​(long i)
        返回通过反转指定的 long值的二进制补码表示中的字节顺序获得的值。
        参数
        i - 要颠倒其字节的值
        结果
        通过在指定的 long值中反转字节获得的值。
        从以下版本开始:
        1.5
      • sum

        public static long sum​(long a,
                               long b)
        根据+运算符将两个 long值相加。
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        总和为 ab
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator
      • max

        public static long max​(long a,
                               long b)
        返回两个 long值中的较大值,如同通过调用 Math.max一样
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        较大的 ab
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator
      • min

        public static long min​(long a,
                               long b)
        返回两个 long中的较小值,就像调用 Math.min一样
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        较小的 ab
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator