IntOutput (Integer output functions 3.0 API)

java.lang.Object
- io.jstuff.util.IntOutput

```
public class IntOutput
extends Object
```
A set of static functions used in the conversion of integer values to string representations.

Author:

Peter Wall

Field Summary

Fields
Modifier and Type	Field and Description
`static char[]`	`digits`
`static char[]`	`digitsHex`
`static char[]`	`digitsHexLC`
`static String`	`MIN_INTEGER_DIGITS`
`static String`	`MIN_LONG_DIGITS`
`static char[]`	`tensDigits`

Constructor Summary

Constructors
Constructor and Description

IntOutput()

Constructors
Constructor and Description
`IntOutput()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`append1Digit(Appendable a, int i)` Append an `int` to an `Appendable` as a single decimal digit.
`static void`	`append1DigitSafe(Appendable a, int i)` Append the least significant decimal digit of an `int` to an `Appendable`.
`static void`	`append1Hex(Appendable a, int i)` Append an `int` to an `Appendable` as a single hexadecimal digit.
`static void`	`append1HexLC(Appendable a, int i)` Append an `int` to an `Appendable` as a single hexadecimal digit, using lower-case for the alphabetic characters.
`static void`	`append2Digits(Appendable a, int i)` Append an `int` to an `Appendable` as two decimal digits.
`static void`	`append2DigitsSafe(Appendable a, int i)` Append the least significant two decimal digits of an `int` to an `Appendable`.
`static void`	`append2Hex(Appendable a, int i)` Append an `int` to an `Appendable` as two hexadecimal digits.
`static void`	`append2HexLC(Appendable a, int i)` Append an `int` to an `Appendable` as two hexadecimal digits, using lower-case for the alphabetic characters.
`static void`	`append3Digits(Appendable a, int i)` Append an `int` to an `Appendable` as three decimal digits.
`static void`	`append3DigitsSafe(Appendable a, int i)` Append the least significant three decimal digits of an `int` to an `Appendable`.
`static void`	`append4Hex(Appendable a, int i)` Append an `int` to an `Appendable` as four hexadecimal digits.
`static void`	`append4HexLC(Appendable a, int i)` Append an `int` to an `Appendable` as four hexadecimal digits, using lower-case for the alphabetic characters.
`static void`	`append8Hex(Appendable a, int i)` Append an `int` to an `Appendable` as eight hexadecimal digits.
`static void`	`append8HexLC(Appendable a, int i)` Append an `int` to an `Appendable` as eight hexadecimal digits, using lower-case for the alphabetic characters.
`static void`	`appendInt(Appendable a, int i)` Append an `int` left-trimmed to an `Appendable`.
`static void`	`appendIntGrouped(Appendable a, int i, char groupingChar)` Append an `int` left-trimmed to an `Appendable` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`appendIntHex(Appendable a, int i)` Append an `int` left-trimmed to an `Appendable` in hexadecimal.
`static void`	`appendIntHexLC(Appendable a, int i)` Append an `int` left-trimmed to an `Appendable` in hexadecimal, using lower-case for the alphabetic characters.
`static void`	`appendIntScaled(Appendable a, int i, int scale, char separator)` Append an `int` left-trimmed to an `Appendable`, using a scale parameter to indicate the number of decimal places.
`static void`	`appendLong(Appendable a, long n)` Append a `long` left-trimmed to an `Appendable`.
`static void`	`appendLongGrouped(Appendable a, long n, char groupingChar)` Append a `long` left-trimmed to an `Appendable` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`appendLongHex(Appendable a, long n)` Append a `long` left-trimmed to an `Appendable` in hexadecimal.
`static void`	`appendLongHexLC(Appendable a, long n)` Append a `long` left-trimmed to an `Appendable` in hexadecimal, using lower-case for the alphabetic characters.
`static void`	`appendLongScaled(Appendable a, long n, int scale, char separator)` Append a `long` left-trimmed to an `Appendable`, using a scale parameter to indicate the number of decimal places.
`static void`	`appendPositiveInt(Appendable a, int i)` Append a positive `int` left-trimmed to an `Appendable`.
`static void`	`appendPositiveIntGrouped(Appendable a, int i, char groupingChar)` Append a positive `int` left-trimmed to an `Appendable` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`appendPositiveIntScaled(Appendable a, int i, int scale, char separator)` Append a positive `int` left-trimmed to an `Appendable`, using a scale parameter to indicate the number of decimal places.
`static void`	`appendPositiveLong(Appendable a, long n)` Append a positive `long` left-trimmed to an `Appendable`.
`static void`	`appendPositiveLongGrouped(Appendable a, long n, char groupingChar)` Append a positive `long` left-trimmed to an `Appendable` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`appendPositiveLongScaled(Appendable a, long n, int scale, char separator)` Append a positive `long` left-trimmed to an `Appendable`, using a scale parameter to indicate the number of decimal places.
`static void`	`appendUnsignedInt(Appendable a, int i)` Append an unsigned `int` left-trimmed to an `Appendable`.
`static void`	`appendUnsignedLong(Appendable a, long n)` Append an unsigned `long` left-trimmed to an `Appendable`.
`static void`	`output1Digit(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as a single decimal digit.
`static void`	`output1DigitSafe(int i, IntConsumer consumer)` Output the least significant decimal digit of an `int` using an `IntConsumer`.
`static void`	`output1Hex(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as a single hexadecimal digit.
`static void`	`output1HexLC(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as a single hexadecimal digit, using lower-case for the alphabetic characters.
`static void`	`output2Digits(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as two decimal digits.
`static void`	`output2DigitsSafe(int i, IntConsumer consumer)` Output the least significant two decimal digits of an `int` using an `IntConsumer`.
`static void`	`output2Hex(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as two hexadecimal digits.
`static void`	`output2HexLC(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as two hexadecimal digits, using lower-case for the alphabetic characters.
`static void`	`output3Digits(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as three decimal digits.
`static void`	`output3DigitsSafe(int i, IntConsumer consumer)` Output the least significant three decimal digits of an `int` using an `IntConsumer`.
`static void`	`output4Hex(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as four hexadecimal digits.
`static void`	`output4HexLC(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as four hexadecimal digits, using lower-case for the alphabetic characters.
`static void`	`output8Hex(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as eight hexadecimal digits.
`static void`	`output8HexLC(int i, IntConsumer consumer)` Output an `int` using an `IntConsumer` as eight hexadecimal digits, using lower-case for the alphabetic characters.
`static void`	`outputInt(int i, IntConsumer consumer)` Output an `int` left-trimmed using an `IntConsumer`.
`static void`	`outputIntGrouped(int i, char groupingChar, IntConsumer consumer)` Output an `int` left-trimmed using an `IntConsumer` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`outputIntHex(int i, IntConsumer consumer)` Output an `int` left-trimmed using an `IntConsumer` in hexadecimal.
`static void`	`outputIntHexLC(int i, IntConsumer consumer)` Output an `int` left-trimmed using an `IntConsumer` in hexadecimal, using lower-case for the alphabetic characters.
`static void`	`outputIntScaled(int i, int scale, char separator, IntConsumer consumer)` Output an `int` left-trimmed using an `IntConsumer`, using a scale parameter to indicate the number of decimal places.
`static void`	`outputLong(long n, IntConsumer consumer)` Output a `long` left-trimmed using an `IntConsumer`.
`static void`	`outputLongGrouped(long n, char groupingChar, IntConsumer consumer)` Output a `long` left-trimmed using an `IntConsumer` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`outputLongHex(long n, IntConsumer consumer)` Output a `long` left-trimmed using an `IntConsumer` in hexadecimal.
`static void`	`outputLongHexLC(long n, IntConsumer consumer)` Output a `long` left-trimmed using an `IntConsumer` in hexadecimal, using lower-case for the alphabetic characters.
`static void`	`outputLongScaled(long n, int scale, char separator, IntConsumer consumer)` Append an `int` left-trimmed to an `Appendable`, using a scale parameter to indicate the number of decimal places.
`static void`	`outputPositiveInt(int i, IntConsumer consumer)` Output a positive `int` left-trimmed using an `IntConsumer`.
`static void`	`outputPositiveIntGrouped(int i, char groupingChar, IntConsumer consumer)` Output a positive `int` left-trimmed using an `IntConsumer` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`outputPositiveIntScaled(int i, int scale, char separator, IntConsumer consumer)` Output a positive `int` left-trimmed using an `IntConsumer`, using a scale parameter to indicate the number of decimal places.
`static void`	`outputPositiveLong(long n, IntConsumer consumer)` Output a positive `int` left-trimmed using an `IntConsumer`.
`static void`	`outputPositiveLongGrouped(long n, char groupingChar, IntConsumer consumer)` Output a positive `long` left-trimmed using an `IntConsumer` with digits grouped in 3s and separated by the specified grouping character.
`static void`	`outputPositiveLongScaled(long n, int scale, char separator, IntConsumer consumer)` Append a positive `long` left-trimmed to an `Appendable`, using a scale parameter to indicate the number of decimal places.
`static void`	`outputUnsignedInt(int i, IntConsumer consumer)` Output an unsigned `int` left-trimmed using an `IntConsumer`.
`static void`	`outputUnsignedLong(long n, IntConsumer consumer)` Output an unsigned `long` left-trimmed using an `IntConsumer`.

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

- Field Detail
  - digits
```
public static final char[] digits
```
  - tensDigits
```
public static final char[] tensDigits
```
  - digitsHex
```
public static final char[] digitsHex
```
  - digitsHexLC
```
public static final char[] digitsHexLC
```
  - MIN_INTEGER_DIGITS
```
public static final String MIN_INTEGER_DIGITS
```
    See Also:
    
    Constant Field Values
  - MIN_LONG_DIGITS
```
public static final String MIN_LONG_DIGITS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - IntOutput
```
public IntOutput()
```
- Method Detail
  - appendInt
```
public static void appendInt(Appendable a,
                             int i)
                      throws IOException
```
    Append an int left-trimmed to an Appendable. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendPositiveInt
```
public static void appendPositiveInt(Appendable a,
                                     int i)
                              throws IOException
```
    Append a positive int left-trimmed to an Appendable. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendUnsignedInt
```
public static void appendUnsignedInt(Appendable a,
                                     int i)
                              throws IOException
```
    Append an unsigned int left-trimmed to an Appendable. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendIntScaled
```
public static void appendIntScaled(Appendable a,
                                   int i,
                                   int scale,
                                   char separator)
                            throws IOException
```
    Append an int left-trimmed to an Appendable, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    Negative scale values (indicating that decimal point is to the right of the last digit) are ignored. It is left to the user to decide whether to output additional zeros following the number, or to add an exponent suffix.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendPositiveIntScaled
```
public static void appendPositiveIntScaled(Appendable a,
                                           int i,
                                           int scale,
                                           char separator)
                                    throws IOException
```
    Append a positive int left-trimmed to an Appendable, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendLong
```
public static void appendLong(Appendable a,
                              long n)
                       throws IOException
```
    Append a long left-trimmed to an Appendable. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendPositiveLong
```
public static void appendPositiveLong(Appendable a,
                                      long n)
                               throws IOException
```
    Append a positive long left-trimmed to an Appendable. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendUnsignedLong
```
public static void appendUnsignedLong(Appendable a,
                                      long n)
                               throws IOException
```
    Append an unsigned long left-trimmed to an Appendable. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendLongScaled
```
public static void appendLongScaled(Appendable a,
                                    long n,
                                    int scale,
                                    char separator)
                             throws IOException
```
    Append a long left-trimmed to an Appendable, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    Negative scale values (indicating that decimal point is to the right of the last digit) are ignored. It is left to the user to decide whether to output additional zeros following the number, or to add an exponent suffix.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendPositiveLongScaled
```
public static void appendPositiveLongScaled(Appendable a,
                                            long n,
                                            int scale,
                                            char separator)
                                     throws IOException
```
    Append a positive long left-trimmed to an Appendable, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    n - the int
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append1Digit
```
public static void append1Digit(Appendable a,
                                int i)
                         throws IOException
```
    Append an int to an Appendable as a single decimal digit. Note that there is no range check on the input value; to append the least significant digit in cases where the value is not guaranteed to be in the range 0..9, use append1DigitSafe(java.lang.Appendable, int).
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append1DigitSafe
```
public static void append1DigitSafe(Appendable a,
                                    int i)
                             throws IOException
```
    Append the least significant decimal digit of an int to an Appendable.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append2Digits
```
public static void append2Digits(Appendable a,
                                 int i)
                          throws IOException
```
    Append an int to an Appendable as two decimal digits. There is often a requirement to output a number as 2 digits, for example the cents value in dollars and cents, or hours, minutes and seconds in a time string. Note that there is no range check on the input value; to append the least significant two digits in cases where the value is not guaranteed to be in the range 00..99, use append2DigitsSafe(java.lang.Appendable, int).
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append2DigitsSafe
```
public static void append2DigitsSafe(Appendable a,
                                     int i)
                              throws IOException
```
    Append the least significant two decimal digits of an int to an Appendable.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append3Digits
```
public static void append3Digits(Appendable a,
                                 int i)
                          throws IOException
```
    Append an int to an Appendable as three decimal digits. There is less frequently a requirement to output a number as 3 digits, for example the milliseconds in a time string. Note that there is no range check on the input value; to append the least significant three digits in cases where the value is not guaranteed to be in the range 000..999, use append3DigitsSafe(java.lang.Appendable, int).
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append3DigitsSafe
```
public static void append3DigitsSafe(Appendable a,
                                     int i)
                              throws IOException
```
    Append the least significant three decimal digits of an int to an Appendable.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendIntGrouped
```
public static void appendIntGrouped(Appendable a,
                                    int i,
                                    char groupingChar)
                             throws IOException
```
    Append an int left-trimmed to an Appendable with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    groupingChar - the grouping character (e.g. ',')
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendPositiveIntGrouped
```
public static void appendPositiveIntGrouped(Appendable a,
                                            int i,
                                            char groupingChar)
                                     throws IOException
```
    Append a positive int left-trimmed to an Appendable with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    groupingChar - the grouping character (e.g. ',')
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendLongGrouped
```
public static void appendLongGrouped(Appendable a,
                                     long n,
                                     char groupingChar)
                              throws IOException
```
    Append a long left-trimmed to an Appendable with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    groupingChar - the grouping character (e.g. ',')
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendPositiveLongGrouped
```
public static void appendPositiveLongGrouped(Appendable a,
                                             long n,
                                             char groupingChar)
                                      throws IOException
```
    Append a positive long left-trimmed to an Appendable with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    groupingChar - the grouping character (e.g. ',')
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendIntHex
```
public static void appendIntHex(Appendable a,
                                int i)
                         throws IOException
```
    Append an int left-trimmed to an Appendable in hexadecimal. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendIntHexLC
```
public static void appendIntHexLC(Appendable a,
                                  int i)
                           throws IOException
```
    Append an int left-trimmed to an Appendable in hexadecimal, using lower-case for the alphabetic characters. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendLongHex
```
public static void appendLongHex(Appendable a,
                                 long n)
                          throws IOException
```
    Append a long left-trimmed to an Appendable in hexadecimal. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    Throws:
    
    IOException - if thrown by the Appendable
  - appendLongHexLC
```
public static void appendLongHexLC(Appendable a,
                                   long n)
                            throws IOException
```
    Append a long left-trimmed to an Appendable in hexadecimal, using lower-case for the alphabetic characters. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    a - the Appendable
    
    n - the long
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append8Hex
```
public static void append8Hex(Appendable a,
                              int i)
                       throws IOException
```
    Append an int to an Appendable as eight hexadecimal digits.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append8HexLC
```
public static void append8HexLC(Appendable a,
                                int i)
                         throws IOException
```
    Append an int to an Appendable as eight hexadecimal digits, using lower-case for the alphabetic characters.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append4Hex
```
public static void append4Hex(Appendable a,
                              int i)
                       throws IOException
```
    Append an int to an Appendable as four hexadecimal digits.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append4HexLC
```
public static void append4HexLC(Appendable a,
                                int i)
                         throws IOException
```
    Append an int to an Appendable as four hexadecimal digits, using lower-case for the alphabetic characters.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append2Hex
```
public static void append2Hex(Appendable a,
                              int i)
                       throws IOException
```
    Append an int to an Appendable as two hexadecimal digits.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append2HexLC
```
public static void append2HexLC(Appendable a,
                                int i)
                         throws IOException
```
    Append an int to an Appendable as two hexadecimal digits, using lower-case for the alphabetic characters.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append1Hex
```
public static void append1Hex(Appendable a,
                              int i)
                       throws IOException
```
    Append an int to an Appendable as a single hexadecimal digit.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - append1HexLC
```
public static void append1HexLC(Appendable a,
                                int i)
                         throws IOException
```
    Append an int to an Appendable as a single hexadecimal digit, using lower-case for the alphabetic characters.
    
    Parameters:
    
    a - the Appendable
    
    i - the int
    
    Throws:
    
    IOException - if thrown by the Appendable
  - outputInt
```
public static void outputInt(int i,
                             IntConsumer consumer)
```
    Output an int left-trimmed using an IntConsumer. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - outputPositiveInt
```
public static void outputPositiveInt(int i,
                                     IntConsumer consumer)
```
    Output a positive int left-trimmed using an IntConsumer. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - outputUnsignedInt
```
public static void outputUnsignedInt(int i,
                                     IntConsumer consumer)
```
    Output an unsigned int left-trimmed using an IntConsumer. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - outputIntScaled
```
public static void outputIntScaled(int i,
                                   int scale,
                                   char separator,
                                   IntConsumer consumer)
```
    Output an int left-trimmed using an IntConsumer, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    i - the int
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    consumer - the IntConsumer
  - outputPositiveIntScaled
```
public static void outputPositiveIntScaled(int i,
                                           int scale,
                                           char separator,
                                           IntConsumer consumer)
```
    Output a positive int left-trimmed using an IntConsumer, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    i - the int
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    consumer - the IntConsumer
  - outputLong
```
public static void outputLong(long n,
                              IntConsumer consumer)
```
    Output a long left-trimmed using an IntConsumer. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    n - the int
    
    consumer - the IntConsumer
  - outputPositiveLong
```
public static void outputPositiveLong(long n,
                                      IntConsumer consumer)
```
    Output a positive int left-trimmed using an IntConsumer. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    n - the long
    
    consumer - the IntConsumer
  - outputUnsignedLong
```
public static void outputUnsignedLong(long n,
                                      IntConsumer consumer)
```
    Output an unsigned long left-trimmed using an IntConsumer. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    n - the long
    
    consumer - the IntConsumer
  - outputLongScaled
```
public static void outputLongScaled(long n,
                                    int scale,
                                    char separator,
                                    IntConsumer consumer)
```
    Append an int left-trimmed to an Appendable, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    n - the long
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    consumer - the IntConsumer
  - outputPositiveLongScaled
```
public static void outputPositiveLongScaled(long n,
                                            int scale,
                                            char separator,
                                            IntConsumer consumer)
```
    Append a positive long left-trimmed to an Appendable, using a scale parameter to indicate the number of decimal places. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    n - the int
    
    scale - the number of decimal places
    
    separator - the decimal separator character to use
    
    consumer - the IntConsumer
  - output1Digit
```
public static void output1Digit(int i,
                                IntConsumer consumer)
```
    Output an int using an IntConsumer as a single decimal digit. Note that there is no range check on the input value; to output the least significant digit in cases where the value is not guaranteed to be in the range 0..9, use output1DigitSafe(int, java.util.function.IntConsumer).
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output1DigitSafe
```
public static void output1DigitSafe(int i,
                                    IntConsumer consumer)
```
    Output the least significant decimal digit of an int using an IntConsumer.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output2Digits
```
public static void output2Digits(int i,
                                 IntConsumer consumer)
```
    Output an int using an IntConsumer as two decimal digits. There is often a requirement to output a number as 2 digits, for example the cents value in dollars and cents, or hours, minutes and seconds in a time string. Note that there is no range check on the input value; to output the least significant two digits in cases where the value is not guaranteed to be in the range 00..99, use output2DigitsSafe(int, java.util.function.IntConsumer).
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output2DigitsSafe
```
public static void output2DigitsSafe(int i,
                                     IntConsumer consumer)
```
    Output the least significant two decimal digits of an int using an IntConsumer.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output3Digits
```
public static void output3Digits(int i,
                                 IntConsumer consumer)
```
    Output an int using an IntConsumer as three decimal digits. There is less frequently a requirement to output a number as 3 digits, for example the milliseconds in a time string. Note that there is no range check on the input value; to output the least significant three digits in cases where the value is not guaranteed to be in the range 000..999, use output3DigitsSafe(int, java.util.function.IntConsumer).
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output3DigitsSafe
```
public static void output3DigitsSafe(int i,
                                     IntConsumer consumer)
```
    Output the least significant three decimal digits of an int using an IntConsumer.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - outputIntGrouped
```
public static void outputIntGrouped(int i,
                                    char groupingChar,
                                    IntConsumer consumer)
```
    Output an int left-trimmed using an IntConsumer with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    i - the int
    
    groupingChar - the grouping character (e.g. ',')
    
    consumer - the IntConsumer
  - outputPositiveIntGrouped
```
public static void outputPositiveIntGrouped(int i,
                                            char groupingChar,
                                            IntConsumer consumer)
```
    Output a positive int left-trimmed using an IntConsumer with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    i - the int
    
    groupingChar - the grouping character (e.g. ',')
    
    consumer - the IntConsumer
  - outputLongGrouped
```
public static void outputLongGrouped(long n,
                                     char groupingChar,
                                     IntConsumer consumer)
```
    Output a long left-trimmed using an IntConsumer with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    n - the long
    
    groupingChar - the grouping character (e.g. ',')
    
    consumer - the IntConsumer
  - outputPositiveLongGrouped
```
public static void outputPositiveLongGrouped(long n,
                                             char groupingChar,
                                             IntConsumer consumer)
```
    Output a positive long left-trimmed using an IntConsumer with digits grouped in 3s and separated by the specified grouping character.
    
    Parameters:
    
    n - the long
    
    groupingChar - the grouping character (e.g. ',')
    
    consumer - the IntConsumer
  - outputIntHex
```
public static void outputIntHex(int i,
                                IntConsumer consumer)
```
    Output an int left-trimmed using an IntConsumer in hexadecimal. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - outputIntHexLC
```
public static void outputIntHexLC(int i,
                                  IntConsumer consumer)
```
    Output an int left-trimmed using an IntConsumer in hexadecimal, using lower-case for the alphabetic characters. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - outputLongHex
```
public static void outputLongHex(long n,
                                 IntConsumer consumer)
```
    Output a long left-trimmed using an IntConsumer in hexadecimal. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    n - the long
    
    consumer - the IntConsumer
  - outputLongHexLC
```
public static void outputLongHexLC(long n,
                                   IntConsumer consumer)
```
    Output a long left-trimmed using an IntConsumer in hexadecimal, using lower-case for the alphabetic characters. This method outputs the digits left to right, avoiding the need to allocate a separate object to hold the string form.
    
    Parameters:
    
    n - the long
    
    consumer - the IntConsumer
  - output8Hex
```
public static void output8Hex(int i,
                              IntConsumer consumer)
```
    Output an int using an IntConsumer as eight hexadecimal digits.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output8HexLC
```
public static void output8HexLC(int i,
                                IntConsumer consumer)
```
    Output an int using an IntConsumer as eight hexadecimal digits, using lower-case for the alphabetic characters.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output4Hex
```
public static void output4Hex(int i,
                              IntConsumer consumer)
```
    Output an int using an IntConsumer as four hexadecimal digits.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output4HexLC
```
public static void output4HexLC(int i,
                                IntConsumer consumer)
```
    Output an int using an IntConsumer as four hexadecimal digits, using lower-case for the alphabetic characters.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output2Hex
```
public static void output2Hex(int i,
                              IntConsumer consumer)
```
    Output an int using an IntConsumer as two hexadecimal digits.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output2HexLC
```
public static void output2HexLC(int i,
                                IntConsumer consumer)
```
    Output an int using an IntConsumer as two hexadecimal digits, using lower-case for the alphabetic characters.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output1Hex
```
public static void output1Hex(int i,
                              IntConsumer consumer)
```
    Output an int using an IntConsumer as a single hexadecimal digit.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer
  - output1HexLC
```
public static void output1HexLC(int i,
                                IntConsumer consumer)
```
    Output an int using an IntConsumer as a single hexadecimal digit, using lower-case for the alphabetic characters.
    
    Parameters:
    
    i - the int
    
    consumer - the IntConsumer

Class IntOutput

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

digits

tensDigits

digitsHex

digitsHexLC

MIN_INTEGER_DIGITS

MIN_LONG_DIGITS

Constructor Detail

IntOutput

Method Detail

appendInt

appendPositiveInt

appendUnsignedInt

appendIntScaled

appendPositiveIntScaled

appendLong

appendPositiveLong

appendUnsignedLong

appendLongScaled

appendPositiveLongScaled

append1Digit

append1DigitSafe

append2Digits

append2DigitsSafe

append3Digits

append3DigitsSafe

appendIntGrouped

appendPositiveIntGrouped

appendLongGrouped

appendPositiveLongGrouped

appendIntHex

appendIntHexLC

appendLongHex

appendLongHexLC

append8Hex

append8HexLC

append4Hex

append4HexLC

append2Hex

append2HexLC

append1Hex

append1HexLC

outputInt

outputPositiveInt

outputUnsignedInt

outputIntScaled

outputPositiveIntScaled

outputLong

outputPositiveLong

outputUnsignedLong

outputLongScaled

outputPositiveLongScaled

output1Digit

output1DigitSafe

output2Digits

output2DigitsSafe

output3Digits

output3DigitsSafe

outputIntGrouped

outputPositiveIntGrouped

outputLongGrouped

outputPositiveLongGrouped

outputIntHex

outputIntHexLC

outputLongHex

outputLongHexLC

output8Hex

output8HexLC

output4Hex

output4HexLC

output2Hex

output2HexLC

output1Hex

output1HexLC