Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.google.common.primitives
Class UnsignedLongs

    java.lang.Object
      com.google.common.primitives.UnsignedLongs

    @Beta
    @GwtCompatible
    public final class UnsignedLongs

extends Object

Static utility methods pertaining to `long` primitives that interpret values as unsigned (that is, any negative value `x` is treated as the positive value `2^64 + x`). The methods for which signedness is not an issue are in `Longs`, as well as signed versions of methods for which signedness is an issue.

In addition, this class provides several static methods for converting a `long` to a `String` and a `String` to a `long` that treat the `long` as an unsigned number.

Users of these utilities must be extremely careful not to mix up signed and unsigned `long` values. When possible, it is recommended that the `UnsignedLong` wrapper class be used, at a small efficiency penalty, to enforce the distinction in the type system.

Since:
  10.0
Author:
  Louis Wasserman, Brian Milch, Colin Evans

Field Summary
`static long` | `MAX_VALUE`

Method Summary
`static int` | `compare(long a, long b)` Compares the two specified `long` values, treating them as unsigned values between `0` and `2^64 - 1` inclusive.
`static long` | `divide(long dividend, long divisor)` Returns dividend / divisor, where the dividend and divisor are treated as unsigned 64-bit quantities.
`static String` | `join(String separator, long... array)` Returns a string containing the supplied unsigned `long` values separated by `separator`.
`static Comparator<long[]>` | `lexicographicalComparator()` Returns a comparator that compares two `long` arrays lexicographically.
`static long` | `max(long... array)` Returns the greatest value present in `array`.
`static long` | `min(long... array)` Returns the least value present in `array`.
`static long` | `parseUnsignedLong(String s)` Returns the unsigned `long` value represented by the given decimal string.
`static long` | `parseUnsignedLong(String s, int radix)` Returns the unsigned `long` value represented by a string with the given radix.
`static long` | `remainder(long dividend, long divisor)` Returns dividend % divisor, where the dividend and divisor are treated as unsigned 64-bit quantities.
`static String` | `toString(long x)` Returns a string representation of x, where x is treated as unsigned.
`static String` | `toString(long x, int radix)` Returns a string representation of `x` for the given radix, where `x` is treated as unsigned.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### MAX_VALUE

    public static final long MAX_VALUE

See Also:
  Constant Field Values

Method Detail

### compare

    public static int compare(long a,
                              long b)

  Compares the two specified `long` values, treating them as unsigned values between `0` and `2^64 - 1` inclusive.

  Parameters:
    `a` - the first unsigned `long` to compare
    `b` - the second unsigned `long` to compare
  Returns:
    a negative value if `a` is less than `b`; a positive value if `a` is greater than `b`; or zero if they are equal

### min

    public static long min(long... array)

  Returns the least value present in `array`.

  Parameters:
    `array` - a nonempty array of unsigned `long` values
  Returns:
    the value present in `array` that is less than or equal to every other value in the array according to `compare(long, long)`
  Throws:
    `IllegalArgumentException` - if `array` is empty

### max

    public static long max(long... array)

  Returns the greatest value present in `array`.

  Parameters:
    `array` - a nonempty array of unsigned `long` values
  Returns:
    the value present in `array` that is greater than or equal to every other value in the array according to `compare(long, long)`
  Throws:
    `IllegalArgumentException` - if `array` is empty

### join

    public static String join(String separator,
                              long... array)

  Returns a string containing the supplied unsigned `long` values separated by `separator`. For example, `join("-", 1, 2, 3)` returns the string `"1-2-3"`.

  Parameters:
    `separator` - the text that should appear between consecutive values in the resulting string (but not at the start or end)
    `array` - an array of unsigned `long` values, possibly empty

### lexicographicalComparator

    public static Comparator<long[]> lexicographicalComparator()

  Returns a comparator that compares two `long` arrays lexicographically. That is, it compares, using `compare(long, long)`), the first pair of values that follow any common prefix, or when one array is a prefix of the other, treats the shorter array as the lesser. For example, `[] < [1L] < [1L, 2L] < [2L]`. Values are treated as unsigned.

  The returned comparator is inconsistent with `Object.equals(Object)` (since arrays support only identity equality), but it is consistent with `Arrays.equals(long[], long[])`.

  See Also:
    Lexicographical order article at Wikipedia

### divide

    public static long divide(long dividend,
                              long divisor)

  Returns dividend / divisor, where the dividend and divisor are treated as unsigned 64-bit quantities.

  Parameters:
    `dividend` - the dividend (numerator)
    `divisor` - the divisor (denominator)
  Throws:
    `ArithmeticException` - if divisor is 0

### remainder

    public static long remainder(long dividend,
                                 long divisor)

  Returns dividend % divisor, where the dividend and divisor are treated as unsigned 64-bit quantities.

  Parameters:
    `dividend` - the dividend (numerator)
    `divisor` - the divisor (denominator)
  Throws:
    `ArithmeticException` - if divisor is 0

### parseUnsignedLong

    public static long parseUnsignedLong(String s)

  Returns the unsigned `long` value represented by the given decimal string.

  Throws:
    `NumberFormatException` - if the string does not contain a valid unsigned `long` value

### parseUnsignedLong

    public static long parseUnsignedLong(String s,
                                         int radix)

  Returns the unsigned `long` value represented by a string with the given radix.

  Parameters:
    `s` - the string containing the unsigned `long` representation to be parsed.
    `radix` - the radix to use while parsing `s`
  Throws:
    `NumberFormatException` - if the string does not contain a valid unsigned `long` with the given radix, or if `radix` is not between `Character.MIN_RADIX` and `Character.MAX_RADIX`.

### toString

    public static String toString(long x)

  Returns a string representation of x, where x is treated as unsigned.

### toString

    public static String toString(long x,
                                  int radix)

  Returns a string representation of `x` for the given radix, where `x` is treated as unsigned.

  Parameters:
    `x` - the value to convert to a string.
    `radix` - the radix to use while working with `x`
  Throws:
    `IllegalArgumentException` - if `radix` is not between `Character.MIN_RADIX` and `Character.MAX_RADIX`.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2010-2011. All Rights Reserved.