java.lang.Object

java.util.HexFormat

public final class HexFormat extends Object

HexFormat 在字节和字符以及十六进制编码的字符串之间进行转换，这些字符串可能包含其他格式标记，例如前缀、后缀和分隔符。

HexFormat 有两个工厂，预设参数为 of() 和 ofDelimiter(delimiter) 。对于其他参数组合，withXXX 方法返回 HexFormat 修改后的副本 withPrefix(String) 、 withSuffix(String) 、 withDelimiter(String) 或选择 withUpperCase() 或 withLowerCase() 参数。

对于原始字符串到十六进制字符串的转换，toHexDigits 方法包括 toHexDigits(byte) 、toHexDigits(int) 和 toHexDigits(long) 等。默认情况下使用小写字符 "0-9","a-f"。对于生成大写十六进制的转换，字符为 "0-9","A-F" 。只考虑HexFormat.isUpperCase() 参数；不使用定界符、前缀和后缀。

对于十六进制字符串到原始类型的转换，fromHexDigits 方法包括 fromHexDigits(string) 、fromHexDigitsToLong(string) 和 fromHexDigit(int) 转换单个字符或代码点。对于十六进制字符的转换，"0-9", "a-f", and "A-F" 中的数字和大小写字符将转换为相应的值 0-15。不使用定界符、前缀、后缀和大写参数。

对于字节数组到格式化十六进制字符串的转换，formatHex 方法包括 formatHex(byte[]) 和 formatHex(Appendable, byte[]) 。格式化输出是一个字符串或附加到一个 Appendable 例如 StringBuilder 或 PrintStream 。每个字节值的格式为前缀、大写或小写数字中的两个十六进制字符和后缀。定界符跟在每个格式化值之后，最后一个除外。对于生成大写十六进制字符串的转换，请使用 withUpperCase() 。

对于格式化的十六进制字符串到字节数组的转换，parseHex 方法包括 parseHex(CharSequence) 和 parseHex(char[], offset, length) 。每个字节值都是从前缀、两个不区分大小写的十六进制字符和后缀中解析出来的。定界符跟在每个格式化值之后，最后一个除外。

API 注意：

例如，使用 toHexDigits(int) 将单个字节转换为十六进制数字字符串，并使用 fromHexDigits(string) 从字符串转换为原始值。


   HexFormat hex = HexFormat.of();
   byte b = 127;
   String byteStr = hex.toHexDigits(b);

   byte byteVal = (byte)hex.fromHexDigits(byteStr);
   assert(byteStr.equals("7f"));
   assert(b == byteVal);

   // The hexadecimal digits are: "7f"

对于使用小写十六进制数字的逗号 (", ") 分隔格式和前缀 ("#")，HexFormat 是：


   HexFormat commaFormat = HexFormat.ofDelimiter(", ").withPrefix("#");
   byte[] bytes = {0, 1, 2, 3, 124, 125, 126, 127};
   String str = commaFormat.formatHex(bytes);

   byte[] parsed = commaFormat.parseHex(str);
   assert(Arrays.equals(bytes, parsed));

   // The formatted string is: "#00, #01, #02, #03, #7c, #7d, #7e, #7f"

对于使用分隔符冒号 (":") 和大写字符的字节值指纹，HexFormat 是：


   HexFormat formatFingerprint = HexFormat.ofDelimiter(":").withUpperCase();
   byte[] bytes = {0, 1, 2, 3, 124, 125, 126, 127};
   String str = formatFingerprint.formatHex(bytes);
   byte[] parsed = formatFingerprint.parseHex(str);
   assert(Arrays.equals(bytes, parsed));

   // The formatted string is: "00:01:02:03:7C:7D:7E:7F"

这是一个value-based类；在 HexFormat 的实例上使用身份敏感操作（包括引用相等性 (==)、身份哈希码或同步）可能会产生不可预知的结果，应予以避免。 equals 方法应该用于比较。

这个类是不可变的和线程安全的。

除非另有说明，否则将 null 参数传递给任何方法都会导致抛出 NullPointerException 。

自从：

17

方法总结

修饰符和类型

方法

描述

String

delimiter()

返回格式化的十六进制字符串中十六进制值之间的分隔符。

boolean

equals(Object o)

如果另一个对象是具有相同参数的 HexFormat，则返回 true。

String

formatHex(byte[] bytes)

返回从字节数组格式化的十六进制字符串。

String

formatHex(byte[] bytes, int fromIndex, int toIndex)

返回从字节数组范围格式化的十六进制字符串。

<A extends Appendable> A

formatHex(A out, byte[] bytes)

将字节数组中的格式化十六进制字符串附加到 Appendable 。

<A extends Appendable> A

formatHex(A out, byte[] bytes, int fromIndex, int toIndex)

将字节数组范围内的格式化十六进制字符串附加到 Appendable 。

static int

fromHexDigit(int ch)

返回十六进制字符或代码点的值。

static int

fromHexDigits(CharSequence string)

返回从最多八个十六进制字符的字符串解析的 int 值。

static int

fromHexDigits(CharSequence string, int fromIndex, int toIndex)

返回从最多八个十六进制字符的字符串范围解析的 int 值。

static long

fromHexDigitsToLong(CharSequence string)

返回从最多 16 个十六进制字符的字符串解析的 long 值。

static long

fromHexDigitsToLong(CharSequence string, int fromIndex, int toIndex)

返回从最多 16 个十六进制字符的字符串范围解析的 long 值。

int

hashCode()

返回此 HexFormat 的哈希码。

static boolean

isHexDigit(int ch)

如果字符是有效的十六进制字符或代码点，则返回 true。

boolean

isUpperCase()

如果十六进制数字是大写，则返回 true，否则返回 false。

static HexFormat

of()

返回没有定界符和小写字符的十六进制格式化程序。

static HexFormat

ofDelimiter(String delimiter)

返回带有分隔符和小写字符的十六进制格式化程序。

byte[]

parseHex(char[] chars, int fromIndex, int toIndex)

返回包含从字符数组范围解析的十六进制值的字节数组。

byte[]

parseHex(CharSequence string)

返回包含从字符串解析的十六进制值的字节数组。

byte[]

parseHex(CharSequence string, int fromIndex, int toIndex)

返回包含从字符串范围解析的十六进制值的字节数组。

String

prefix()

返回用于格式化十六进制字符串中每个十六进制值的前缀。

String

suffix()

返回用于格式化十六进制字符串中每个十六进制值的后缀。

String

toHexDigits(byte value)

返回 byte 值的两个十六进制字符。

String

toHexDigits(char value)

返回 char 值的四个十六进制字符。

String

toHexDigits(int value)

返回 int 值的八个十六进制字符。

String

toHexDigits(long value)

返回 long 值的十六个十六进制字符。

String

toHexDigits(long value, int digits)

为 long 值返回最多 16 个十六进制字符。

String

toHexDigits(short value)

返回 short 值的四个十六进制字符。

<A extends Appendable> A

toHexDigits(A out, byte value)

将字节值的两个十六进制字符附加到 Appendable 。

char

toHighHexDigit(int value)

返回值的高 4 位的十六进制字符，认为它是一个字节。

char

toLowHexDigit(int value)

返回将值视为字节的低 4 位的十六进制字符。

String

toString()

返回大写字母、定界符、前缀和后缀的格式化程序参数的说明。

HexFormat

withDelimiter(String delimiter)

返回带有分隔符的 HexFormat 的副本。

HexFormat

withLowerCase()

返回此 HexFormat 的副本以使用小写十六进制字符。

HexFormat

withPrefix(String prefix)

返回带有前缀的此 HexFormat 的副本。

HexFormat

withSuffix(String suffix)

返回带有后缀的 HexFormat 的副本。

HexFormat

withUpperCase()

返回此 HexFormat 的副本以使用大写十六进制字符。

在类 java.lang.Object 中声明的方法
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

方法详情
- of
  
  public static HexFormat of()
  
  返回没有定界符和小写字符的十六进制格式化程序。定界符、前缀和后缀为空。 withDelimiter 、withUpperCase 、withLowerCase 、withPrefix 和 withSuffix 方法返回带有新参数的格式化程序的副本。
  
  返回：
  
  没有定界符和小写字符的十六进制格式化程序
- ofDelimiter
  
  public static HexFormat ofDelimiter(String delimiter)
  
  返回带有分隔符和小写字符的十六进制格式化程序。前缀和后缀为空。 withDelimiter 、withUpperCase 、withLowerCase 、withPrefix 和 withSuffix 方法返回带有新参数的格式化程序的副本。
  
  参数：
  
  delimiter - 分隔符，非空，可能为空
  
  返回：
  
  带有分隔符和小写字符的 HexFormat
- withDelimiter
  
  public HexFormat withDelimiter(String delimiter)
  
  返回带有分隔符的 HexFormat 的副本。
  
  参数：
  
  delimiter - 分隔符，非空，可能为空
  
  返回：
  
  带有分隔符的 HexFormat 的副本
- withPrefix
  
  public HexFormat withPrefix(String prefix)
  
  返回带有前缀的此 HexFormat 的副本。
  
  参数：
  
  prefix - 前缀，非空，可能为空
  
  返回：
  
  带有前缀的 HexFormat 的副本
- withSuffix
  
  public HexFormat withSuffix(String suffix)
  
  返回带有后缀的 HexFormat 的副本。
  
  参数：
  
  suffix - 后缀，非空，可能为空
  
  返回：
  
  带有后缀的此 HexFormat 的副本
- withUpperCase
  
  public HexFormat withUpperCase()
  
  返回此 HexFormat 的副本以使用大写十六进制字符。大写十六进制字符是 "0-9", "A-F" 。
  
  返回：
  
  带有大写十六进制字符的 HexFormat 的副本
- withLowerCase
  
  public HexFormat withLowerCase()
  
  返回此 HexFormat 的副本以使用小写十六进制字符。小写十六进制字符是 "0-9", "a-f" 。
  
  返回：
  
  带有小写十六进制字符的 HexFormat 的副本
- delimiter
  
  public String delimiter()
  
  返回格式化的十六进制字符串中十六进制值之间的分隔符。
  
  返回：
  
  分隔符，非空，可能为空""
- prefix
  
  public String prefix()
  
  返回用于格式化十六进制字符串中每个十六进制值的前缀。
  
  返回：
  
  前缀，非空，可能为空 ""
- suffix
  
  public String suffix()
  
  返回用于格式化十六进制字符串中每个十六进制值的后缀。
  
  返回：
  
  后缀，非空，可以为空""
- isUpperCase
  
  public boolean isUpperCase()
  
  如果十六进制数字是大写，则返回 true，否则返回 false。
  
  返回：
  
  true 如果十六进制数字是大写，否则 false
- formatHex
  
  public String formatHex(byte[] bytes)
  
  返回从字节数组格式化的十六进制字符串。每个字节值的格式为前缀、两个十六进制字符选自大写或小写数字以及后缀。定界符跟在每个格式化值之后，最后一个除外。该行为等同于 formatHex(bytes, 0, bytes.length)) 。
  
  参数：
  
  bytes - 非空字节数组
  
  返回：
  
  字节数组的字符串十六进制格式
- formatHex
  
  public String formatHex(byte[] bytes, int fromIndex, int toIndex)
  
  返回从字节数组范围格式化的十六进制字符串。每个字节值的格式为前缀、两个十六进制字符选自大写或小写数字以及后缀。定界符跟在每个格式化值之后，最后一个除外。
  
  参数：
  
  bytes - 非空字节数组
  
  fromIndex - 范围的初始索引，包括在内
  
  toIndex - 范围的最终索引，独占
  
  返回：
  
  一个字符串十六进制格式化数组范围的每个字节
  
  抛出：
  
  IndexOutOfBoundsException - 如果数组范围超出范围
- formatHex
  
  public <A extends Appendable > A formatHex(A out, byte[] bytes)
  
  将字节数组中的格式化十六进制字符串附加到 Appendable 。每个字节值的格式为前缀、两个十六进制字符选自大写或小写数字以及后缀。定界符跟在每个格式化值之后，最后一个除外。格式化的十六进制字符串附加在对 Appendable 方法的零次或多次调用中。
  
  类型参数：
  
  A - Appendable 的类型
  
  参数：
  
  out - 一个 Appendable ，非空
  
  bytes - 一个字节数组
  
  返回：
  
  Appendable
  
  抛出：
  
  UncheckedIOException - 如果 I/O 异常发生附加到输出
- formatHex
  
  public <A extends Appendable > A formatHex(A out, byte[] bytes, int fromIndex, int toIndex)
  
  将字节数组范围内的格式化十六进制字符串附加到 Appendable 。每个字节值的格式为前缀、两个十六进制字符选自大写或小写数字以及后缀。定界符跟在每个格式化值之后，最后一个除外。格式化的十六进制字符串附加在对 Appendable 方法的零次或多次调用中。
  
  类型参数：
  
  A - Appendable 的类型
  
  参数：
  
  out - 一个 Appendable ，非空
  
  bytes - 字节数组，非空
  
  fromIndex - 范围的初始索引，包括在内
  
  toIndex - 范围的最终索引，独占。
  
  返回：
  
  Appendable
  
  抛出：
  
  IndexOutOfBoundsException - 如果数组范围超出范围
  
  UncheckedIOException - 如果 I/O 异常发生附加到输出
- parseHex
  
  public byte[] parseHex(CharSequence string)
  
  返回包含从字符串解析的十六进制值的字节数组。每个字节值都是从前缀、两个不区分大小写的十六进制字符和后缀中解析出来的。定界符跟在每个格式化值之后，最后一个除外。分隔符、前缀和后缀字符串必须存在；它们可能是空字符串。一个有效的字符串只包含上述格式。
  
  参数：
  
  string - 包含带前缀、十六进制数字、后缀和定界符的字节值的字符串
  
  返回：
  
  具有从字符串解析的值的字节数组
  
  抛出：
  
  IllegalArgumentException - 如果每个字节值不存在前缀或后缀，则字节值不是十六进制字符，或者如果分隔符毕竟不存在但最后一个字节值
- parseHex
  
  public byte[] parseHex(CharSequence string, int fromIndex, int toIndex)
  
  返回包含从字符串范围解析的十六进制值的字节数组。每个字节值都是从前缀、两个不区分大小写的十六进制字符和后缀中解析出来的。定界符跟在每个格式化值之后，最后一个除外。分隔符、前缀和后缀字符串必须存在；它们可能是空字符串。一个有效的字符串只包含上述格式。
  
  参数：
  
  string - 包含十六进制数字、定界符、前缀和后缀的字符串范围。
  
  fromIndex - 范围的初始索引，包括在内
  
  toIndex - 范围的最终索引，独占。
  
  返回：
  
  具有从字符串范围解析的值的字节数组
  
  抛出：
  
  IllegalArgumentException - 如果每个字节值不存在前缀或后缀，则字节值不是十六进制字符，或者如果分隔符毕竟不存在但最后一个字节值
  
  IndexOutOfBoundsException - 如果字符串范围超出范围
- parseHex
  
  public byte[] parseHex(char[] chars, int fromIndex, int toIndex)
  
  返回包含从字符数组范围解析的十六进制值的字节数组。每个字节值都是从前缀、两个不区分大小写的十六进制字符和后缀中解析出来的。定界符跟在每个格式化值之后，最后一个除外。分隔符、前缀和后缀字符串必须存在；它们可能是空字符串。有效的字符数组范围仅包含上述格式。
  
  参数：
  
  chars - 包含偶数个十六进制数字、分隔符、前缀和后缀的字符数组范围。
  
  fromIndex - 范围的初始索引，包括在内
  
  toIndex - 范围的最终索引，独占。
  
  返回：
  
  具有从字符数组范围解析的值的字节数组
  
  抛出：
  
  IllegalArgumentException - 如果每个字节值不存在前缀或后缀，则字节值不是十六进制字符，或者如果分隔符毕竟不存在但最后一个字节值
  
  IndexOutOfBoundsException - 如果字符数组范围超出范围
- toLowHexDigit
  
  public char toLowHexDigit(int value)
  
  返回将值视为字节的低 4 位的十六进制字符。如果参数 isUpperCase() 是 true 值 10-15 返回的字符是大写的 "A-F" ，否则返回的字符是小写的 "a-f" 。 0-9 范围内的值作为 "0-9" 返回。
  
  参数：
  
  value - 一个值，只使用该值的低 4 位 0-3
  
  返回：
  
  值的低 4 位 0-3 的十六进制字符
- toHighHexDigit
  
  public char toHighHexDigit(int value)
  
  返回值的高 4 位的十六进制字符，认为它是一个字节。如果参数 isUpperCase() 是 true 值 10-15 返回的字符是大写的 "A-F" ，否则返回的字符是小写的 "a-f" 。 0-9 范围内的值作为 "0-9" 返回。
  
  参数：
  
  value - 一个值，仅使用该值的位 4-7
  
  返回：
  
  值的 4-7 位的十六进制字符
- toHexDigits
  
  public <A extends Appendable > A toHexDigits(A out, byte value)
  
  将字节值的两个十六进制字符附加到 Appendable 。从值的最高有效位到最低有效位的每个半字节（4 位）都被格式化为 toLowHexDigit(nibble) 。十六进制字符附加在对 Appendable 方法的一次或多次调用中。不使用定界符、前缀和后缀。
  
  类型参数：
  
  A - Appendable 的类型
  
  参数：
  
  out - 一个 Appendable ，非空
  
  value - 字节值
  
  返回：
  
  Appendable
  
  抛出：
  
  UncheckedIOException - 如果 I/O 异常发生附加到输出
- toHexDigits
  
  public String toHexDigits(byte value)
  
  返回 byte 值的两个十六进制字符。从值的最高有效位到最低有效位的每个半字节（4 位）都被格式化为 toLowHexDigit(nibble) 。不使用定界符、前缀和后缀。
  
  参数：
  
  value - 字节值
  
  返回：
  
  字节值的两个十六进制字符
- toHexDigits
  
  public String toHexDigits(char value)
  
  返回 char 值的四个十六进制字符。从值的最高有效位到最低有效位的每个半字节（4 位）都被格式化为 toLowHexDigit(nibble) 。不使用定界符、前缀和后缀。
  
  参数：
  
  value - 一个 char 值
  
  返回：
  
  char 值的四个十六进制字符
- toHexDigits
  
  public String toHexDigits(short value)
  
  返回 short 值的四个十六进制字符。从值的最高有效位到最低有效位的每个半字节（4 位）都被格式化为 toLowHexDigit(nibble) 。不使用定界符、前缀和后缀。
  
  参数：
  
  value - 一个 short 值
  
  返回：
  
  short 值的四个十六进制字符
- toHexDigits
  
  public String toHexDigits(int value)
  
  返回 int 值的八个十六进制字符。从值的最高有效位到最低有效位的每个半字节（4 位）都被格式化为 toLowHexDigit(nibble) 。不使用定界符、前缀和后缀。
  参数：
  
  value - 一个 int 值
  
  返回：
  
  int 值的八个十六进制字符
  
  参见：
  
  Integer.toHexString(int)
- toHexDigits
  
  public String toHexDigits(long value)
  
  返回 long 值的十六个十六进制字符。从值的最高有效位到最低有效位的每个半字节（4 位）都被格式化为 toLowHexDigit(nibble) 。不使用定界符、前缀和后缀。
  参数：
  
  value - 一个 long 值
  
  返回：
  
  long 值的十六个十六进制字符
  
  参见：
  
  Long.toHexString(long)
- toHexDigits
  
  public String toHexDigits(long value, int digits)
  
  为 long 值返回最多 16 个十六进制字符。从值的最高有效位到最低有效位的每个半字节（4 位）都被格式化为 toLowHexDigit(nibble) 。不使用定界符、前缀和后缀。
  
  参数：
  
  value - 一个 long 值
  
  digits - 要返回的十六进制数字的个数，0 到 16
  
  返回：
  
  long 值的十六进制字符
  
  抛出：
  
  IllegalArgumentException - 如果 digits 为负数或大于 16
- isHexDigit
  
  public static boolean isHexDigit(int ch)
  如果字符是有效的十六进制字符或代码点，则返回 true。有效的十六进制字符是：
  
  '0' ('\u0030') 到 '9' ('\u0039') 包括在内，
  
  'A' ('\u0041') 到 'F' ('\u0046') 包括在内，并且
  
  'a' ('\u0061') 到 'f' ('\u0066') 包括在内。
  参数：
  
  ch - 代码点
  
  返回：
  
  true 如果字符是有效的十六进制字符，否则 false
- fromHexDigit
  
  public static int fromHexDigit(int ch)
  返回十六进制字符或代码点的值。值为：
  
  (ch - '0') 用于 '0' 到 '9' 包括在内，
  
  (ch - 'A' + 10) 用于 'A' 到 'F' 包括在内，以及
  
  (ch - 'a' + 10) 用于 'a' 到 'f'（含）。
  参数：
  
  ch - 字符或代码点
  
  返回：
  
  值0-15
  
  抛出：
  
  NumberFormatException - 如果代码点不是十六进制字符
- fromHexDigits
  
  public static int fromHexDigits(CharSequence string)
  
  返回从最多八个十六进制字符的字符串解析的 int 值。使用 fromHexDigit(int) 从最高有效位到最低有效位解析十六进制字符以形成无符号值。该值被零扩展为 32 位，并作为 int 返回。
  
  API 注意：
  
  Integer.parseInt(s, 16) 和 Integer.parseUnsignedInt(s, 16) 相似，但允许 Character.digit(ch, 16) 定义的所有 Unicode 十六进制数字。 HexFormat 仅使用十六进制字符 "0-9"、"A-F" 和 "a-f"。可以使用 Integer.parseInt(String, int) 解析带符号的十六进制字符串。
  
  参数：
  
  string - 最多包含八个十六进制字符的 CharSequence
  
  返回：
  
  从字符串中解析出的值
  
  抛出：
  
  IllegalArgumentException - 如果字符串长度大于八 (8) 或任何字符不是十六进制字符
- fromHexDigits
  
  public static int fromHexDigits(CharSequence string, int fromIndex, int toIndex)
  
  返回从最多八个十六进制字符的字符串范围解析的 int 值。 fromIndex 到 toIndex 范围内的字符（不包括）使用 fromHexDigit(int) 从最高有效位到最低有效位进行解析以形成无符号值。该值被零扩展为 32 位，并作为 int 返回。
  
  API 注意：
  
  Integer.parseInt(s, 16) 和 Integer.parseUnsignedInt(s, 16) 相似，但允许 Character.digit(ch, 16) 定义的所有 Unicode 十六进制数字。 HexFormat 仅使用十六进制字符 "0-9"、"A-F" 和 "a-f"。可以使用 Integer.parseInt(String, int) 解析带符号的十六进制字符串。
  
  参数：
  
  string - 包含字符的 CharSequence
  
  fromIndex - 范围的初始索引，包括在内
  
  toIndex - 范围的最终索引，独占。
  
  返回：
  
  从字符串范围解析的值
  
  抛出：
  
  IndexOutOfBoundsException - 如果范围超出 CharSequence 的范围
  
  IllegalArgumentException - 如果范围的长度大于八 (8) 或任何字符不是十六进制字符
- fromHexDigitsToLong
  
  public static long fromHexDigitsToLong(CharSequence string)
  
  返回从最多 16 个十六进制字符的字符串解析的 long 值。使用 fromHexDigit(int) 从最高有效位到最低有效位解析十六进制字符以形成无符号值。该值被零扩展为 64 位，并作为 long 返回。
  
  API 注意：
  
  Long.parseLong(s, 16) 和 Long.parseUnsignedLong(s, 16) 相似，但允许 Character.digit(ch, 16) 定义的所有 Unicode 十六进制数字。 HexFormat 仅使用十六进制字符 "0-9"、"A-F" 和 "a-f"。可以使用 Long.parseLong(String, int) 解析带符号的十六进制字符串。
  
  参数：
  
  string - 最多包含 16 个十六进制字符的 CharSequence
  
  返回：
  
  从字符串中解析出的值
  
  抛出：
  
  IllegalArgumentException - 如果字符串长度大于十六 (16) 或任何字符不是十六进制字符
- fromHexDigitsToLong
  
  public static long fromHexDigitsToLong(CharSequence string, int fromIndex, int toIndex)
  
  返回从最多 16 个十六进制字符的字符串范围解析的 long 值。 fromIndex 到 toIndex 范围内的字符（不包括）使用 fromHexDigit(int) 从最高有效位到最低有效位进行解析以形成无符号值。该值被零扩展为 64 位，并作为 long 返回。
  
  API 注意：
  
  Long.parseLong(s, 16) 和 Long.parseUnsignedLong(s, 16) 相似，但允许 Character.digit(ch, 16) 定义的所有 Unicode 十六进制数字。 HexFormat 仅使用十六进制字符 "0-9"、"A-F" 和 "a-f"。可以使用 Long.parseLong(String, int) 解析带符号的十六进制字符串。
  
  参数：
  
  string - 包含字符的 CharSequence
  
  fromIndex - 范围的初始索引，包括在内
  
  toIndex - 范围的最终索引，独占。
  
  返回：
  
  从字符串范围解析的值
  
  抛出：
  
  IndexOutOfBoundsException - 如果范围超出 CharSequence 的范围
  
  IllegalArgumentException - 如果范围的长度大于十六 (16) 或任何字符不是十六进制字符
- equals
  
  public boolean equals(Object o)
  
  如果另一个对象是具有相同参数的 HexFormat，则返回 true。
  重写：
  
  equals 在类 Object 中
  
  参数：
  
  o - 一个对象，可能为空
  
  返回：
  
  true 如果另一个对象是 HexFormat 并且参数大写、定界符、前缀和后缀相等；否则false
  
  参见：
  
  Object.hashCode()
  
  HashMap
- hashCode
  
  public int hashCode()
  
  返回此 HexFormat 的哈希码。
  重写：
  
  hashCode 在类 Object 中
  
  返回：
  
  这个 HexFormat 的哈希码
  
  参见：
  
  Object.equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- toString
  
  public String toString()
  
  返回大写字母、定界符、前缀和后缀的格式化程序参数的说明。
  
  重写：
  
  toString 在类 Object 中
  
  返回：
  
  这个HexFormat的描述

类 HexFormat

方法总结

在类 java.lang.Object 中声明的方法

方法详情

of

ofDelimiter

withDelimiter

withPrefix

withSuffix

withUpperCase

withLowerCase

delimiter

prefix

suffix

isUpperCase

formatHex

formatHex

formatHex

formatHex

parseHex

parseHex

parseHex

toLowHexDigit

toHighHexDigit

toHexDigits

toHexDigits

toHexDigits

toHexDigits

toHexDigits

toHexDigits

toHexDigits

isHexDigit

fromHexDigit

fromHexDigits

fromHexDigits

fromHexDigitsToLong

fromHexDigitsToLong

equals

hashCode

toString