模块  java.base
软件包  java.lang

Class Long

  • 实现的所有接口
    SerializableComparable<Long>

    public final class Longextends Numberimplements 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
    • 字段汇总

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

      构造方法  
      构造器 描述
      Long​(long value)
      已过时。
      使用此构造函数很少是合适的。
      Long​(String s)
      已过时。
      使用此构造函数很少是合适的。
    • 方法摘要

      所有方法  静态方法  实例方法 具体的方法 
      变量和类型 方法 描述
      static int bitCount​(long i)
      返回指定的 long值的二进制补码表示形式中的 long
      byte byteValue()
      返回此值 Longbyte的基本收缩转换后。
      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值,最多只有一位,位于指定 long值中最高位(“最左侧”)的一位。
      int intValue()
      返回此的值 Long作为 int的基本收缩转换之后。
      long longValue()
      long值的形式返回此 Long的值。
      static long lowestOneBit​(long i)
      返回 long值,最多只有一位,位于指定 long值中最低位(“最右侧”)的一位。
      static long max​(long a, long b)
      返回两个 long值中较大的一个, long调用 Math.max一样
      static long min​(long a, long b)
      返回两个 long值中较小的一个, long调用 Math.min一样
      static int numberOfLeadingZeros​(long i)
      返回指定 long值的二进制补码二进制表示中最高位(“最左侧”)一位之前的零位数。
      static int numberOfTrailingZeros​(long i)
      返回指定 long值的二进制补码表达式中最低位(“最右侧”)一位之后的零位数。
      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值。
      static String toBinaryString​(long i)
      返回 long参数的字符串表示形式,作为base 2中的无符号整数。
      static String toHexString​(long i)
      返回 long参数的字符串表示形式,作为基数为16的无符号整数。
      static String toOctalString​(long i)
      返回 long参数的字符串表示形式,作为基数为8的无符号整数。
      String toString()
      返回表示此 Long值的 String对象。
      static String toString​(long i)
      返回表示指定的 longString对象。
      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

        @Nativepublic static final long MIN_VALUE
        保持最小值a long常数,-2 63
        另请参见:
        常数字段值
      • MAX_VALUE

        @Nativepublic static final long MAX_VALUE
        保持 long可以具有的最大值的常数,2 63 -1。
        另请参见:
        常数字段值
      • TYPE

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

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

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

      • Long

        @Deprecated(since="9")public Long​(long value)
        Deprecated.
        It is rarely appropriate to use this constructor. The static factory valueOf(long) is generally a better choice, as it is likely to yield significantly better space and time performance.
        构造一个新分配的 Long对象,该对象表示指定的 long参数。
        参数
        value - Long对象表示的值。
      • Long

        @Deprecated(since="9")public Long​(String s)     throws NumberFormatException
        Deprecated.
        It is rarely appropriate to use this constructor. Use parseLong(String) to convert a string to a long primitive, or use valueOf(String) to convert a string to a Long object.
        构造一个新分配Long对象,表示long由指示值String参数。 该字符串parseLong方法用于基数10的方式完全转换为long值。
        参数
        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数字。 因此,十六进制(基数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符号long值为参数加2 64 ; 否则,它等于参数。 此值将转换为十六进制(基数为16)的ASCII数字字符串,没有额外的前导0

        可以通过调用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)
        返回long参数的字符串表示形式,作为基数为8的无符号整数。

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

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

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

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

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

        如果参数为负, long符号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)
        返回表示指定的longString对象。 该参数将转换为带符号的十进制表示形式并作为字符串返回,就像参数和基数10作为toString(long, int)方法的参数一样
        参数
        i - 待转换的 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'\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大于 endIndexendIndex大于 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'\u006C' )都不允许作为类型指示符出现在字符串的末尾,这在Java编程语言源代码中是允许的。

        参数
        s -一个 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 -一个 String含有无符号 long表示被解析
        结果
        由十进制字符串参数表示的无符号 long
        异常
        NumberFormatException - 如果字符串不包含可解析的无符号整数。
        从以下版本开始:
        1.8
      • valueOf

        public static Long valueOf​(String s,                           int radix)                    throws NumberFormatException
        返回Long对象,当使用第二个参数给出的基数进行解析时,该对象保存从指定的String提取的值。 第一个参数被解释为表示由第二个参数指定的基数中的带符号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对象。
        异常
        NumberFormatException - 如果字符串无法解析为 long
      • valueOf

        public static Long valueOf​(long l)
        返回表示指定的long值的Long实例。 如果不需要新的Long实例,则通常应优先使用此方法而不是构造函数Long(long) ,因为此方法可能通过缓存频繁请求的值来显着提高空间和时间性能。 此方法将始终缓存-128到127(包括端点)范围内的值,并可以缓存此范围之外的其他值。
        参数
        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:
        -
        +
        DecimalNumeralHexDigitsOctalDigitsThe Java™ Language Specification的 3.10.1节中定义 ,但数字之间不接受下划线。

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

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

        public byte byteValue()
        返回此值 Longbyte的基本收缩转换后。
        重写:
        byteValueNumber
        结果
        转换为类型 byte后此对象表示的数值。
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • shortValue

        public short shortValue()
        在缩小基元转换后,将此 Long的值作为 short返回。
        重写:
        shortValue类别 Number
        结果
        转换为类型 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()
        long值的形式返回此 Long的值。
        Specified by:
        longValue在类 Number
        结果
        转换为类型 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)
        将此对象与指定的对象进行比较。 结果为true当且仅当参数不是null并且是Long对象时,该对象包含与此对象相同的long值。
        重写:
        equalsObject
        参数
        obj - 要与之比较的对象。
        结果
        true如果对象相同; 否则为false
        另请参见:
        Object.hashCode()HashMap
      • getLong

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

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

        第二个参数是默认值。 如果没有指定名称的属性,属性没有正确的数字格式,或者指定的名称为空或null,则返回表示第二个参数值的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)方法访问系统属性。 然后,根据decode方法将此属性的字符串值解释为long值,并返回表示此值的Long对象; 综上所述:
        • 如果属性值以两个ASCII字符0x或ASCII字符# ,后面没有减号,则其余部分将被解析为十六进制整数,与方法valueOf(java.lang.String, int)带基数16)完全相同。
        • 如果属性值以ASCII字符0开头,后跟另一个字符,则将其解析为八进制整数,与方法valueOf(java.lang.String, int) (基数为8)完全相同。
        • 否则,属性值将被解析为十进制整数,与方法valueOf(java.lang.String, int) (基数为10)完全相同。

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

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

        参数
        nm - 房产名称。
        val - 默认值。
        结果
        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 ; 如果此Long在数值上大于参数Long (带符号的比较),则值大于0
        从以下版本开始:
        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 ; 如果x < y为无符号值,则小于0值; 如果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值,最多只有一位,位于指定long值中最高位(“最左侧”)一位的位置。 如果指定的值在其二进制补码表示中没有一位,即,如果它等于零,则返回零。
        参数
        i - 要计算其最高一位的值
        结果
        long值,单个一位,在指定值的最高位一位的位置,如果指定值本身等于零,则为零。
        从以下版本开始:
        1.5
      • lowestOneBit

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

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

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

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

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

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

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

        请注意,具有负距离的左旋转等效于右旋转: rotateLeft(val, -distance) == rotateRight(val, distance) 另请注意,按任意倍数64旋转是无操作,因此即使距离为负,也可以忽略旋转距离的最后六位以外的所有位: 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 - 要计算其signum的值
        结果
        指定的 long值的signum函数。
        从以下版本开始:
        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值中较大的一个, long调用 Math.max一样
        参数
        a - 第一个操作数
        b - 第二个操作数
        结果
        ab的较大者
        从以下版本开始:
        1.8
        另请参见:
        BinaryOperator
      • min

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