IPv6Address

java.lang.Object
- inet.ipaddr.Address
- - inet.ipaddr.IPAddress
  - - inet.ipaddr.ipv6.IPv6Address

All Implemented Interfaces:

AddressComponent, AddressSegmentSeries, AddressDivisionSeries, AddressItem, AddressStringDivisionSeries, IPAddressSegmentSeries, java.io.Serializable, java.lang.Comparable<Address>, java.lang.Iterable<IPv6Address>
```
public class IPv6Address
extends IPAddress
implements java.lang.Iterable<IPv6Address>
```
An IPv6 address, or a subnet of multiple IPv6 addresses. Each segment can represent a single value or a range of values.
You can construct an IPv6 address from a byte array, from a BigInteger, from a Address.SegmentValueProvider, from Inet6Address, from MACAddress, from an IPv6AddressSection of 8 segments, or from an array of 8 IPv6AddressSegment objects.
To construct one from a String use IPAddressString.toAddress() or IPAddressString.getAddress(), IPAddressString.toHostAddress() or IPAddressString.getHostAddress()

See Also:

Serialized Form

Core

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface IPv6Address.IPv6AddressConverter
- Nested classes/interfaces inherited from class inet.ipaddr.IPAddress
  IPAddress.IPVersion
- Nested classes/interfaces inherited from class inet.ipaddr.Address
  Address.AddressProvider, Address.SegmentValueProvider

Nested Classes
Modifier and Type	Class and Description
`static interface`	`IPv6Address.IPv6AddressConverter`

Field Summary

Fields
Modifier and Type	Field and Description
`static char`	`ALTERNATIVE_ZONE_SEPARATOR`
`static int`	`BIT_COUNT`
`static int`	`BITS_PER_SEGMENT`
`static int`	`BYTE_COUNT`
`static int`	`BYTES_PER_SEGMENT`
`static int`	`DEFAULT_TEXTUAL_RADIX`
`static int`	`MAX_VALUE_PER_SEGMENT`
`static int`	`MIXED_ORIGINAL_SEGMENT_COUNT`
`static int`	`MIXED_REPLACED_SEGMENT_COUNT`
`static java.lang.String`	`REVERSE_DNS_SUFFIX`
`static java.lang.String`	`REVERSE_DNS_SUFFIX_DEPRECATED`
`static int`	`SEGMENT_COUNT`
`static char`	`SEGMENT_SEPARATOR`
`static char`	`UNC_RANGE_SEPARATOR`
`static java.lang.String`	`UNC_RANGE_SEPARATOR_STR`
`static char`	`UNC_SEGMENT_SEPARATOR`
`static java.lang.String`	`UNC_SUFFIX`
`static char`	`UNC_ZONE_SEPARATOR`
`static char`	`ZONE_SEPARATOR`

Fields inherited from class inet.ipaddr.IPAddress
DEFAULT_ADDRESS_CONVERTER, PREFIX_LEN_SEPARATOR

Fields inherited from class inet.ipaddr.Address
ALTERNATIVE_RANGE_SEPARATOR, ALTERNATIVE_RANGE_SEPARATOR_STR, ALTERNATIVE_SEGMENT_WILDCARD_STR, DEFAULT_ADDRESS_COMPARATOR, HEX_PREFIX, OCTAL_PREFIX, RANGE_SEPARATOR, RANGE_SEPARATOR_STR, SEGMENT_SQL_SINGLE_WILDCARD, SEGMENT_SQL_SINGLE_WILDCARD_STR, SEGMENT_SQL_WILDCARD, SEGMENT_SQL_WILDCARD_STR, SEGMENT_WILDCARD, SEGMENT_WILDCARD_STR

Constructor Summary

Constructors
Constructor and Description
`IPv6Address(Address.SegmentValueProvider valueProvider)` Constructs an IPv6 address.
`IPv6Address(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider)` Constructs an IPv6 address or subnet.
`IPv6Address(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, java.lang.CharSequence zone)` Constructs an IPv6 address.
`IPv6Address(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, java.lang.Integer networkPrefixLength)` Constructs an IPv6 address or subnet.
`IPv6Address(Address.SegmentValueProvider valueProvider, java.lang.Integer networkPrefixLength)` Constructs an IPv6 address.
`IPv6Address(java.math.BigInteger val)` Constructs an IPv6 address.
`IPv6Address(java.math.BigInteger val, java.lang.CharSequence zone)` Constructs an IPv6 address.
`IPv6Address(java.math.BigInteger val, java.lang.Integer networkPrefixLength)` Constructs an IPv6 address.
`IPv6Address(java.math.BigInteger val, java.lang.Integer networkPrefixLength, java.lang.CharSequence zone)` Constructs an IPv6 address or subnet.
`IPv6Address(byte[] bytes)` Constructs an IPv6 address.
`IPv6Address(byte[] bytes, java.lang.CharSequence zone)` Constructs an IPv6 address.
`IPv6Address(byte[] bytes, java.lang.Integer networkPrefixLength)` Constructs an IPv6 address or subnet.
`IPv6Address(byte[] bytes, int byteStartIndex, int byteEndIndex)` Constructs an IPv6 address or subnet.
`IPv6Address(byte[] bytes, int byteStartIndex, int byteEndIndex, java.lang.Integer networkPrefixLength)` Constructs an IPv6 address or subnet.
`IPv6Address(java.net.Inet6Address inet6Address)` Constructs an IPv6 address.
`IPv6Address(IPv6Address prefix, MACAddress eui)` Constructs an IPv6 address from a modified EUI-64 (Extended Unique Identifier) address section and an IPv6 address section network prefix.
`IPv6Address(IPv6AddressSection section)`
`IPv6Address(IPv6AddressSection section, java.lang.CharSequence zone)`
`IPv6Address(IPv6AddressSection section, MACAddress eui)` Constructs an IPv6 address from a modified EUI-64 (Extended Unique Identifier) address section and an IPv6 address section network prefix.
`IPv6Address(IPv6AddressSection section, MACAddressSection eui)` Constructs an IPv6 address from a modified EUI-64 (Extended Unique Identifier) address and an IPv6 address section network prefix.
`IPv6Address(IPv6AddressSection section, MACAddressSection eui, java.lang.CharSequence zone)`
`IPv6Address(IPv6AddressSegment[] segments)` Constructs an IPv6 address or subnet.
`IPv6Address(IPv6AddressSegment[] segments, java.lang.CharSequence zone)` Constructs an IPv6 address or a set of addresses.
`IPv6Address(IPv6AddressSegment[] segments, java.lang.Integer networkPrefixLength)` Constructs an IPv6 address or a set of addresses.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`IPv6Address`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`IPv6Address`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`IPv6Address`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`IPv6Address`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`IPv6Address`	`applyPrefixLength(int networkPrefixLength)` Applies the given prefix length to create a new segment series.
`IPv6Address`	`assignMinPrefixForBlock()` Constructs an equivalent address with the smallest CIDR prefix possible (largest network), such that the range of values are a set of subnet blocks for that prefix.
`IPv6Address`	`assignPrefixForSingleBlock()` Returns the equivalent CIDR address with a prefix length for which the address subnet block matches the range of values in this address.
`IPv6Address`	`bitwiseOr(IPAddress mask)` Equivalent to calling `IPAddress.bitwiseOr(IPAddress, boolean)` with the second argument as false.
`IPv6Address`	`bitwiseOr(IPAddress mask, boolean retainPrefix)` Does the bitwise disjunction with this address.
`IPv6Address`	`bitwiseOrNetwork(IPAddress mask, int networkPrefixLength)` Does the bitwise disjunction with this address.
`boolean`	`contains(Address other)`
`IPv4Address`	`get6to4IPv4Address()` Returns the second and third bytes as an `IPv4Address`.
`int`	`getBitCount()`
`int`	`getByteCount()` returns the number of bytes in each of the address components represented by this instance
`IPv6AddressSegment`	`getDivision(int index)`
`IPv4Address`	`getEmbeddedIPv4Address()` Returns the embedded `IPv4Address` in the lowest (least-significant) two segments.
`IPv4Address`	`getEmbeddedIPv4Address(int byteIndex)` Produces an IPv4 address from any sequence of 4 bytes in this IPv6 address.
`IPv6AddressSection`	`getHostSection()` Returns the host section of the series.
`IPv6AddressSection`	`getHostSection(int networkPrefixLength)` Returns the host section of the address as indicated by the network prefix length provided.
`IPv4AddressNetwork`	`getIPv4Network()`
`java.lang.Iterable<IPv6Address>`	`getIterable()` Useful for using an instance in a "for-each loop".
`IPv6Address`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`IPv6Address`	`getLowerNonZeroHost()` Similar to `IPAddressSegmentSeries.getLower()`, but will not return a series that has a prefix length and whose host value is zero.
`MACAddressNetwork`	`getMACNetwork()`
`IPv6AddressNetwork`	`getNetwork()` Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`IPv6AddressSection`	`getNetworkSection()` Returns the network section of the series if the series has a CIDR network prefix length, otherwise it returns the entire series as a prefixed series with prefix matching the address bit length.
`IPv6AddressSection`	`getNetworkSection(int networkPrefixLength)` Returns the network section of the series.
`IPv6AddressSection`	`getNetworkSection(int networkPrefixLength, boolean withPrefixLength)` Returns the network section of the series.
`IPAddressStringDivisionSeries[]`	`getParts(IPAddressSection.IPStringBuilderOptions options)` Returns all the ways of breaking this address down into segments, as selected.
`IPAddressStringDivisionSeries[]`	`getParts(IPv6AddressSection.IPv6StringBuilderOptions options)`
`IPv6AddressSection`	`getSection()` Returns the address as an address section comprising all segments in the address.
`IPv6AddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index
`IPv6AddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex
`IPv6AddressSegment`	`getSegment(int index)` Returns the segment from this series at the given index.
`int`	`getSegmentCount()` Returns the number of segments in this series.
`IPv6AddressSegment[]`	`getSegments()` Returns the segments of this series of segments as an array.
`IPv6Address`	`getUpper()` If this represents a series with ranging values, returns a series representing the upper values of the range If this represents a series with a single value in each segment, returns this.
`java.lang.String`	`getZone()` The zone or scope id, which is typically appended to an address with a '%', eg fe80::71a3:2b00:ddd3:753f%16 If there is no zone or scope id, returns null
`int`	`hashCode()`
`boolean`	`hasZone()`
`IPv6Address`	`increment(long increment)` Returns the series from the subnet that is the given increment upwards into the subnet range, or if the given increment is negative the given increment downwards into the subnet range, or if this is just an individual series, it simply adds the increment to this.
`IPv6Address`	`intersect(IPAddress other)` Produces the subnet whose addresses are found in both this and the given subnet argument.
`boolean`	`is6Over4()` Whether the address is 6over4
`boolean`	`is6To4()` Whether the address is IPv6 to IPv4 relay
`boolean`	`isEUI64()`
`boolean`	`isIPv4Compatible()` Whether the address is IPv4-compatible
`boolean`	`isIPv4Convertible()` Determines whether this address can be converted to IPv4.
`boolean`	`isIPv4Mapped()` Whether the address is IPv4-mapped ::ffff:x:x/96 indicates IPv6 address mapped to IPv4
`boolean`	`isIPv4Translatable()`
`boolean`	`isIPv6Convertible()` Determines whether an address can be converted to IPv6, if not IPv6 already.
`boolean`	`isIsatap()` Whether the address is ISATAP
`boolean`	`isLinkLocal()` Returns whether the address is link local, whether unicast or multicast.
`boolean`	`isLocal()` Returns true if the address is link local, site local, organization local, administered locally, or unspecified.
`boolean`	`isLoopback()`
`boolean`	`isMulticast()` Whether the MAC address or IP address or other form of address is multicast.
`boolean`	`isSameAddress(Address other)`
`boolean`	`isSameAddress(IPAddress other)`
`boolean`	`isSiteLocal()`
`boolean`	`isTeredo()` Whether the address is Teredo
`boolean`	`isUniqueLocal()`
`boolean`	`isWellKnownIPv4Translatable()` Whether the address has the well-known prefix for IPv4 translatable addresses as in rfc 6052 and 6144
`java.util.Iterator<IPv6Address>`	`iterator()` Iterates through the individual segment series.
`IPv6Address`	`mask(IPAddress mask)` Equivalent to calling `IPAddress.mask(IPAddress, boolean)` with the second argument as false.
`IPv6Address`	`mask(IPAddress mask, boolean retainPrefix)` Applies the given mask to all addresses represented by this IPAddress.
`IPv6Address`	`maskNetwork(IPAddress mask, int networkPrefixLength)` Applies the given mask to all addresses represented by this IPAddress while also applying the given prefix length at the same time.
`IPv6Address[]`	`mergePrefixBlocks(IPAddress... addresses)` Merges this with the list of addresses to produce the smallest list of prefix blocks
`java.util.Iterator<IPv6Address>`	`nonZeroHostIterator()`
`java.util.Iterator<IPv6Address>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`IPv6Address`	`removePrefixLength()` Removes the prefix length.
`IPv6Address`	`removePrefixLength(boolean zeroed)` Removes the prefix length.
`IPv6Address`	`removeZone()`
`IPv6Address`	`replace(int startIndex, int endIndex, IPv6Address replacement, int replacementIndex)` Replaces segments starting from startIndex and ending before endIndex with the same number of segments starting at replacementStartIndex from the replacement section
`IPv6Address`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`IPv6Address`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`IPv6Address`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`IPv6Address`	`reverseSegments()` Returns a new segment series with the segments reversed.
`java.util.Iterator<IPv6AddressSegment[]>`	`segmentsIterator()` Iterates through the individual segments.
`java.util.Iterator<IPv6AddressSegment[]>`	`segmentsNonZeroHostIterator()`
`IPv6Address`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`IPv6Address`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`IPv6Address[]`	`spanWithPrefixBlocks(IPAddress other)` Produces the list of prefix block subnets that span from this series to the given series.
`IPv6Address[]`	`subtract(IPAddress other)` Subtract the given subnet from this subnet, returning an array of subnets for the result (the subnets will not be contiguous so an array is required).
`IPAddressPartStringCollection`	`toAllStringCollection()`
`java.lang.String`	`toBase85String()` The base 85 string is described by RFC 1924
`java.lang.String`	`toBinaryString()` Writes this address as a single binary value with always the exact same number of characters
`java.lang.String`	`toCanonicalString()` This produces a canonical string.
`java.lang.String`	`toCanonicalWildcardString()` This produces a string similar to the canonical string but avoids the CIDR prefix.
`java.lang.String`	`toCompressedString()` This compresses the maximum number of zeros and/or host segments with the IPv6 compression notation '::'
`java.lang.String`	`toCompressedWildcardString()` This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
`java.lang.String`	`toConvertedString()` Returns a mixed string if it represents a convertible IPv4 address, returns the normalized string otherwise.
`MACAddress`	`toEUI(boolean extended)`
`java.lang.String`	`toFullString()` This produces a string with no compressed segments and all segments of full length, which is 4 characters for IPv6 segments and 3 characters for IPv4 segments.
`java.lang.String`	`toHexString(boolean with0xPrefix)` Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`java.net.Inet6Address`	`toInetAddress()` Converts the lowest value of this address to an InetAddress
`IPv4Address`	`toIPv4()` If this address is IPv4 convertible, returns that address.
`IPv6Address`	`toIPv6()`
`IPv4AddressSection`	`toMappedIPv4Segments()` ::ffff:x:x/96 indicates IPv6 address mapped to IPv4
`IPv6Address`	`toMaxHost()` Returns the segment series with a host of all ones.
`IPv6Address`	`toMaxHost(int prefixLength)` Produces the series with host values of all one bits for the given prefix length.
`java.lang.String`	`toMixedString()`
`java.lang.String`	`toNormalizedString()` The normalized string returned by this method is consistent with java.net.Inet6address.
`java.lang.String`	`toNormalizedString(boolean keepMixed, IPv6AddressSection.IPv6StringOptions params)` Constructs a string representing this address according to the given parameters
`java.lang.String`	`toNormalizedString(IPAddressSection.IPStringOptions params)` Constructs a string representing this address according to the given parameters
`static java.lang.String`	`toNormalizedString(IPv6AddressNetwork network, Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, java.lang.Integer prefixLength, java.lang.CharSequence zone)` Creates the normalized string for an address without having to create the address objects first.
`java.lang.String`	`toNormalizedString(IPv6AddressSection.IPv6StringOptions params)`
`java.lang.String`	`toNormalizedWildcardString()` This produces a string similar to the normalized string but avoids the CIDR prefix.
`java.lang.String`	`toOctalString(boolean with0Prefix)` Writes this address as a single octal value with always the exact same number of characters, with or without a preceding 0 prefix.
`IPv6Address`	`toPrefixBlock()` Returns the subnet associated with the prefix length of this address.
`IPv6Address`	`toPrefixBlock(int networkPrefixLength)` Returns the segment series of the same length that spans all hosts.
`java.lang.String`	`toPrefixLengthString()` Returns a string with a CIDR network prefix length if this address has a network prefix length.
`java.lang.String`	`toSQLWildcardString()` This is the same as the string from toNormalizedWildcardString except that it uses `Address.SEGMENT_SQL_WILDCARD` instead of `Address.SEGMENT_WILDCARD` and also uses `Address.SEGMENT_SQL_SINGLE_WILDCARD`
`IPAddressPartStringCollection`	`toStandardStringCollection()`
`IPAddressPartStringCollection`	`toStringCollection(IPAddressSection.IPStringBuilderOptions opts)`
`IPAddressPartStringCollection`	`toStringCollection(IPv6AddressSection.IPv6StringBuilderOptions opts)`
`java.lang.String`	`toSubnetString()` Produces a consistent subnet string that looks like 1.2.. or 1:2::/16 In the case of IPv4, this means that wildcards are used instead of a network prefix when a network prefix has been supplied.
`java.lang.String`	`toUNCHostName()` Generates the Microsoft UNC path component for this address
`java.net.Inet6Address`	`toUpperInetAddress()` Converts the highest value of this address to an InetAddress.
`IPv6Address`	`toZeroHost()` Returns the segment series with a host of zero.
`IPv6Address`	`toZeroHost(int prefixLength)` Produces the series with host values of 0 for the given prefix length.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface inet.ipaddr.AddressSegmentSeries
getSegments, getSegments, getSegmentStrings

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
containsPrefixBlock, containsSinglePrefixBlock, getDivisionStrings, getMinPrefixLengthForBlock, getPrefixCount, getPrefixLength, getPrefixLengthForSingleBlock, getUpperValue, getValue, isMore, isPrefixBlock, isPrefixed, isSinglePrefixBlock

Methods inherited from interface inet.ipaddr.format.AddressStringDivisionSeries
getDivisionCount

Methods inherited from interface inet.ipaddr.format.AddressItem
getBytes, getBytes, getCount, getUpperBytes, getUpperBytes, includesMax, includesZero, isFullRange, isMax, isMultiple, isZero

- Field Detail
  - SEGMENT_SEPARATOR
```
public static final char SEGMENT_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - ZONE_SEPARATOR
```
public static final char ZONE_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - ALTERNATIVE_ZONE_SEPARATOR
```
public static final char ALTERNATIVE_ZONE_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - UNC_SEGMENT_SEPARATOR
```
public static final char UNC_SEGMENT_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - UNC_ZONE_SEPARATOR
```
public static final char UNC_ZONE_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - UNC_RANGE_SEPARATOR
```
public static final char UNC_RANGE_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - UNC_RANGE_SEPARATOR_STR
```
public static final java.lang.String UNC_RANGE_SEPARATOR_STR
```
  - UNC_SUFFIX
```
public static final java.lang.String UNC_SUFFIX
```
    See Also:
    
    Constant Field Values
  - REVERSE_DNS_SUFFIX
```
public static final java.lang.String REVERSE_DNS_SUFFIX
```
    See Also:
    
    Constant Field Values
  - REVERSE_DNS_SUFFIX_DEPRECATED
```
public static final java.lang.String REVERSE_DNS_SUFFIX_DEPRECATED
```
    See Also:
    
    Constant Field Values
  - BITS_PER_SEGMENT
```
public static final int BITS_PER_SEGMENT
```
    See Also:
    
    Constant Field Values
  - BYTES_PER_SEGMENT
```
public static final int BYTES_PER_SEGMENT
```
    See Also:
    
    Constant Field Values
  - SEGMENT_COUNT
```
public static final int SEGMENT_COUNT
```
    See Also:
    
    Constant Field Values
  - MIXED_REPLACED_SEGMENT_COUNT
```
public static final int MIXED_REPLACED_SEGMENT_COUNT
```
    See Also:
    
    Constant Field Values
  - MIXED_ORIGINAL_SEGMENT_COUNT
```
public static final int MIXED_ORIGINAL_SEGMENT_COUNT
```
    See Also:
    
    Constant Field Values
  - BYTE_COUNT
```
public static final int BYTE_COUNT
```
    See Also:
    
    Constant Field Values
  - BIT_COUNT
```
public static final int BIT_COUNT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_TEXTUAL_RADIX
```
public static final int DEFAULT_TEXTUAL_RADIX
```
    See Also:
    
    Constant Field Values
  - MAX_VALUE_PER_SEGMENT
```
public static final int MAX_VALUE_PER_SEGMENT
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - IPv6Address
```
public IPv6Address(IPv6AddressSection section,
                   java.lang.CharSequence zone)
            throws AddressValueException
```
    Parameters:
    
    section -
    
    zone -
    
    Throws:
    
    AddressValueException - if segment count is not 8 or zone is invalid
  - IPv6Address
```
public IPv6Address(IPv6AddressSection section)
            throws AddressValueException
```
    Throws:
    
    AddressValueException
  - IPv6Address
```
public IPv6Address(IPv6AddressSegment[] segments)
            throws AddressValueException
```
    Constructs an IPv6 address or subnet.
    
    Parameters:
    
    segments - the address segments
    
    Throws:
    
    AddressValueException - if segment count is not 8
  - IPv6Address
```
public IPv6Address(IPv6AddressSegment[] segments,
                   java.lang.Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv6 address or a set of addresses.
    
    Parameters:
    
    segments - the address segments
    
    networkPrefixLength -
    
    Throws:
    
    AddressValueException - if segment count is not 8
    
    AddressValueException - if network prefix length invalid
  - IPv6Address
```
public IPv6Address(IPv6AddressSegment[] segments,
                   java.lang.CharSequence zone)
            throws AddressValueException
```
    Constructs an IPv6 address or a set of addresses.
    
    Parameters:
    
    segments - the address segments
    
    zone - the zone or scope id
    
    Throws:
    
    AddressValueException - if segment count is not 8 or the zone invalid
  - IPv6Address
```
public IPv6Address(java.net.Inet6Address inet6Address)
```
    Constructs an IPv6 address.
    
    Parameters:
    
    inet6Address - the java.net address object
  - IPv6Address
```
public IPv6Address(byte[] bytes,
                   java.lang.CharSequence zone)
            throws AddressValueException
```
    Constructs an IPv6 address.
    The byte array can be a 16 byte IPv6 address, but may have additional zero-valued bytes, or it may be fewer than 16 bytes.
    
    Parameters:
    
    bytes - the 16 byte IPv6 address in network byte order - if longer than 16 bytes the additional bytes must be zero (and are ignored), if shorter than 16 bytes then the bytes are sign-extended to 16 bytes.
    
    Throws:
    
    AddressValueException - if bytes not equivalent to a 16 byte address
    
    AddressValueException - if byte range invalid or zone invalid
  - IPv6Address
```
public IPv6Address(byte[] bytes)
            throws AddressValueException
```
    Constructs an IPv6 address.
    The byte array can be a 16 byte IPv6 address, but may have additional zero-valued bytes, or it may be fewer than 16 bytes.
    
    Parameters:
    
    bytes - the 16 byte IPv6 address in network byte order - if longer than 16 bytes the additional bytes must be zero (and are ignored), if shorter than 16 bytes then the bytes are sign-extended to 16 bytes.
    
    Throws:
    
    AddressValueException - if bytes not equivalent to a 16 byte address
  - IPv6Address
```
public IPv6Address(byte[] bytes,
                   int byteStartIndex,
                   int byteEndIndex)
            throws AddressValueException
```
    Constructs an IPv6 address or subnet.
    Similar to IPv6Address(byte[]) except that you can specify the start and end of the address in the given byte array.
    
    Throws:
    
    AddressValueException - if byte range invalid
  - IPv6Address
```
public IPv6Address(byte[] bytes,
                   java.lang.Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv6 address or subnet.
    The byte array can be a 16 byte IPv6 address, but may have additional zero-valued bytes, or it may be fewer than 16 bytes.
    When networkPrefixLength is non-null, depending on the prefix configuration (see AddressNetwork.getPrefixConfiguration(), this object may represent either a single address with that network prefix length, or the prefix subnet block containing all addresses with the same network prefix.
    
    Parameters:
    
    bytes - the 16 byte IPv6 address in network byte order - if longer than 16 bytes the additional bytes must be zero (and are ignored), if shorter than 16 bytes then the bytes are sign-extended to 16 bytes.
    
    networkPrefixLength - the CIDR prefix, which can be null for no prefix length
    
    Throws:
    
    AddressValueException - if bytes not equivalent to a 16 byte address
  - IPv6Address
```
public IPv6Address(byte[] bytes,
                   int byteStartIndex,
                   int byteEndIndex,
                   java.lang.Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv6 address or subnet.
    Similar to IPv6Address(byte[], Integer) except that you can specify the start and end of the address in the given byte array.
    
    Throws:
    
    AddressValueException
  - IPv6Address
```
public IPv6Address(java.math.BigInteger val)
            throws AddressValueException
```
    Constructs an IPv6 address.
    The byte representation from BigInteger.toByteArray() is used, and the byte array follows the rules according to IPv6Address(byte[]). Either it must be exactly 16 bytes, or if larger then any extra bytes must be significant leading zeros, or if smaller it is sign-extended to the required 16 byte length.
    This means that you can end up with the same address from two different values of BigInteger, one positive and one negative. For instance, -1 and ffffffffffffffffffffffffffffffff are represented by the two's complement byte arrays [ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff] and [0,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff] respectively. Both create the address ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
    In fact, the two's complement byte array [ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff,ff] can be shortened to [ff], the former being the sign-extension of the latter. So the byte array [ff] also creates the address ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff.
    When using positive integers you end up with the results you expect, the magnitude of the big integer becomes the address.
    When ranging over all 16-byte arrays and constructing BigInteger from those arrays, you range over all possible addresses.
    
    Parameters:
    
    val - must be an IPv6 address value.
    
    Throws:
    
    AddressValueException - if value is outside the range of potential values
    
    AddressValueException - if val is invalid
  - IPv6Address
```
public IPv6Address(java.math.BigInteger val,
                   java.lang.Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv6 address.
    The byte representation from BigInteger.toByteArray() is used, and the byte array follows the rules according to IPv6Address(byte[]). Either it must be exactly 16 bytes, or if larger then any extra bytes must be significant leading zeros, or if smaller it is sign-extended to the required 16 byte length.
    When networkPrefixLength is non-null, depending on the prefix configuration (see AddressNetwork.getPrefixConfiguration(), this object may represent either a single address with that network prefix length, or the prefix subnet block containing all addresses with the same network prefix.
    
    Parameters:
    
    val -
    
    networkPrefixLength -
    
    Throws:
    
    AddressValueException - if val is invalid
  - IPv6Address
```
public IPv6Address(java.math.BigInteger val,
                   java.lang.CharSequence zone)
            throws AddressValueException
```
    Constructs an IPv6 address.
    The byte representation from BigInteger.toByteArray() is used, and the byte array follows the rules according to IPv6Address(byte[]). Either it must be exactly 16 bytes, or if larger then any extra bytes must be significant leading zeros, or if smaller it is sign-extended to the required 16 byte length.
    
    Parameters:
    
    val -
    
    zone -
    
    Throws:
    
    AddressValueException - if val is invalid or if zone is invalid
  - IPv6Address
```
public IPv6Address(java.math.BigInteger val,
                   java.lang.Integer networkPrefixLength,
                   java.lang.CharSequence zone)
            throws AddressValueException
```
    Constructs an IPv6 address or subnet.
    When networkPrefixLength is non-null, depending on the prefix configuration (see AddressNetwork.getPrefixConfiguration(), this object may represent either a single address with that network prefix length, or the prefix subnet block containing all addresses with the same network prefix.
    
    Parameters:
    
    val - must be an IPv6 address value
    
    networkPrefixLength - the CIDR prefix length, which can be null for no prefix length
    
    zone - the zone or scope id
    
    Throws:
    
    AddressValueException - if value is outside the range of potential values, or if zone is invalid
  - IPv6Address
```
public IPv6Address(Address.SegmentValueProvider lowerValueProvider,
                   Address.SegmentValueProvider upperValueProvider,
                   java.lang.Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv6 address or subnet.
    When networkPrefixLength is non-null, depending on the prefix configuration (see AddressNetwork.getPrefixConfiguration(), this object may represent either a single address with that network prefix length, or the prefix subnet block containing all addresses with the same network prefix.
    
    Parameters:
    
    lowerValueProvider - supplies the 2 byte lower values for each segment
    
    upperValueProvider - supplies the 2 byte upper values for each segment
    
    networkPrefixLength - the CIDR network prefix length, which can be null for no prefix
    
    Throws:
    
    AddressValueException
  - IPv6Address
```
public IPv6Address(Address.SegmentValueProvider lowerValueProvider,
                   Address.SegmentValueProvider upperValueProvider)
```
    Constructs an IPv6 address or subnet.
    
    Parameters:
    
    lowerValueProvider - supplies the 2 byte lower values for each segment
    
    upperValueProvider - supplies the 2 byte upper values for each segment
  - IPv6Address
```
public IPv6Address(Address.SegmentValueProvider valueProvider,
                   java.lang.Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv6 address.
    When networkPrefixLength is non-null, depending on the prefix configuration (see AddressNetwork.getPrefixConfiguration(), this object may represent either a single address with that network prefix length, or the prefix subnet block containing all addresses with the same network prefix.
    
    Parameters:
    
    valueProvider - supplies the 2 byte value for each segment
    
    networkPrefixLength - the CIDR network prefix length, which can be null for no prefix
    
    Throws:
    
    AddressValueException
  - IPv6Address
```
public IPv6Address(Address.SegmentValueProvider valueProvider)
```
    Constructs an IPv6 address.
    
    Parameters:
    
    valueProvider - supplies the 2 byte value for each segment
  - IPv6Address
```
public IPv6Address(Address.SegmentValueProvider lowerValueProvider,
                   Address.SegmentValueProvider upperValueProvider,
                   java.lang.CharSequence zone)
            throws AddressValueException
```
    Constructs an IPv6 address.
    
    Parameters:
    
    lowerValueProvider - supplies the 2 byte lower values for each segment
    
    upperValueProvider - supplies the 2 byte upper values for each segment
    
    Throws:
    
    AddressValueException - if zone is invalid
  - IPv6Address
```
public IPv6Address(IPv6Address prefix,
                   MACAddress eui)
            throws IncompatibleAddressException
```
    Constructs an IPv6 address from a modified EUI-64 (Extended Unique Identifier) address section and an IPv6 address section network prefix.
    If the supplied MAC section is an 8 byte EUI-64, then it must match the required EUI-64 format of xx-xx-ff-fe-xx-xx with the ff-fe section in the middle. If the supplied section is a 6 byte MAC-48 or EUI-48, then the ff-fe pattern will be inserted.
    If the supplied section neither 6 nor 8 bytes, or if the 8-byte section does not have required EUI-64 format of xx-xx-ff-fe-xx-xx, IncompatibleAddressException will be thrown.
    The constructor will toggle the MAC U/L (universal/local) bit as required with EUI-64.
    Only the first 8 bytes (4 segments) of the IPv6Address are used to construct the address.
    Any prefix length in the MAC address is ignored, while a prefix length in the IPv6 address is preserved but only up to the first 4 segments.
    
    Parameters:
    
    prefix - an address from which the first four segments will be used as the same initial segments in the returned address
    
    eui -
    
    Throws:
    
    IncompatibleAddressException - if the MACAddress is an 8 byte MAC address incompatible with EUI-64 IPv6 format
  - IPv6Address
```
public IPv6Address(IPv6AddressSection section,
                   MACAddress eui)
            throws IncompatibleAddressException,
                   AddressValueException
```
    Constructs an IPv6 address from a modified EUI-64 (Extended Unique Identifier) address section and an IPv6 address section network prefix.
    If the supplied MAC section is an 8 byte EUI-64, then it must match the required EUI-64 format of xx-xx-ff-fe-xx-xx with the ff-fe section in the middle. If the supplied section is a 6 byte MAC-48 or EUI-48, then the ff-fe pattern will be inserted.
    If the supplied section neither 6 nor 8 bytes, or if the 8-byte section does not have required EUI-64 format of xx-xx-ff-fe-xx-xx, IncompatibleAddressException will be thrown.
    The constructor will toggle the MAC U/L (universal/local) bit as required with EUI-64.
    The IPv6 address section must be 8 bytes.
    Any prefix length in the MAC address is ignored, while a prefix length in the IPv6 address is preserved but only up to the first 4 segments.
    
    Parameters:
    
    section -
    
    eui -
    
    Throws:
    
    IncompatibleAddressException - if the MACAddress is an 8 byte MAC address incompatible with EUI-64 IPv6 format
    
    AddressValueException - if the IPv6 section is the wrong size or structure
  - IPv6Address
```
public IPv6Address(IPv6AddressSection section,
                   MACAddressSection eui)
            throws IncompatibleAddressException,
                   AddressValueException
```
    Constructs an IPv6 address from a modified EUI-64 (Extended Unique Identifier) address and an IPv6 address section network prefix.
    If the supplied address is an 8 byte EUI-64, then it must match the required EUI-64 format of xx-xx-ff-fe-xx-xx with the ff-fe section in the middle. If the supplied address is a 6 byte MAC-48 or EUI-48, then the ff-fe pattern will be inserted.
    The constructor will toggle the MAC U/L (universal/local) bit as required with EUI-64.
    The IPv6 address section must be 8 bytes.
    Any prefix length in the MAC address is ignored, while a prefix length in the IPv6 address is preserved but only up to the first 4 segments.
    
    Parameters:
    
    section -
    
    eui -
    
    Throws:
    
    IncompatibleAddressException - if the MACAddress is an 8 byte MAC address incompatible with EUI-64 IPv6 format
    
    AddressValueException - if the MACAddress or IPv6 sections are the wrong size or structure
  - IPv6Address
```
public IPv6Address(IPv6AddressSection section,
                   MACAddressSection eui,
                   java.lang.CharSequence zone)
            throws IncompatibleAddressException,
                   AddressValueException
```
    Parameters:
    
    section -
    
    eui -
    
    zone -
    
    Throws:
    
    IncompatibleAddressException - if the MACAddress is an 8 byte MAC address incompatible with EUI-64 IPv6 format
    
    AddressValueException - if the MACAddress or IPv6 sections are the wrong size or structure, or if zone is invalid
- Method Detail
  - getNetwork
```
public IPv6AddressNetwork getNetwork()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the network object for series of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Specified by:
    
    getNetwork in interface AddressSegmentSeries
    
    Specified by:
    
    getNetwork in interface IPAddressSegmentSeries
    
    Specified by:
    
    getNetwork in class IPAddress
    
    Returns:
  - getMACNetwork
```
public MACAddressNetwork getMACNetwork()
```
  - getIPv4Network
```
public IPv4AddressNetwork getIPv4Network()
```
  - getSection
```
public IPv6AddressSection getSection()
```
    Description copied from class: IPAddress
    
    Returns the address as an address section comprising all segments in the address.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Overrides:
    
    getSection in class IPAddress
    
    Returns:
  - getSection
```
public IPv6AddressSection getSection(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Overrides:
    
    getSection in class IPAddress
    
    Returns:
  - getSection
```
public IPv6AddressSection getSection(int index,
                                     int endIndex)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index and ending just before the give endIndex
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Overrides:
    
    getSection in class IPAddress
    
    Returns:
  - getDivision
```
public IPv6AddressSegment getDivision(int index)
```
    Specified by:
    
    getDivision in interface AddressDivisionSeries
    
    Specified by:
    
    getDivision in interface AddressStringDivisionSeries
    
    Returns:
    
    the given division in this series. The first is at index 0.
  - getSegment
```
public IPv6AddressSegment getSegment(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segment from this series at the given index.
    
    Specified by:
    
    getSegment in interface AddressSegmentSeries
    
    Specified by:
    
    getSegment in interface IPAddressSegmentSeries
    
    Returns:
  - getSegments
```
public IPv6AddressSegment[] getSegments()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segments of this series of segments as an array. This must create a new array, so for efficiency use AddressSegmentSeries.getSegment(int) and AddressSegmentSeries.getSegmentCount() instead when feasible.
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
    
    Specified by:
    
    getSegments in interface IPAddressSegmentSeries
    
    Returns:
  - isEUI64
```
public boolean isEUI64()
```
  - toEUI
```
public MACAddress toEUI(boolean extended)
```
  - getParts
```
public IPAddressStringDivisionSeries[] getParts(IPAddressSection.IPStringBuilderOptions options)
```
    Description copied from class: IPAddress
    
    Returns all the ways of breaking this address down into segments, as selected.
    
    Overrides:
    
    getParts in class IPAddress
    
    Returns:
  - getParts
```
public IPAddressStringDivisionSeries[] getParts(IPv6AddressSection.IPv6StringBuilderOptions options)
```
  - getSegmentCount
```
public int getSegmentCount()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of segments in this series.
    
    Specified by:
    
    getSegmentCount in interface AddressSegmentSeries
    
    Overrides:
    
    getSegmentCount in class Address
    
    Returns:
  - getByteCount
```
public int getByteCount()
```
    Description copied from interface: AddressComponent
    
    returns the number of bytes in each of the address components represented by this instance
    
    Specified by:
    
    getByteCount in interface AddressComponent
    
    Overrides:
    
    getByteCount in class IPAddress
    
    Returns:
  - getBitCount
```
public int getBitCount()
```
    Specified by:
    
    getBitCount in interface AddressItem
    
    Overrides:
    
    getBitCount in class Address
    
    Returns:
    
    the number of bits comprising this address item
  - getLowerNonZeroHost
```
public IPv6Address getLowerNonZeroHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Similar to IPAddressSegmentSeries.getLower(), but will not return a series that has a prefix length and whose host value is zero. If this series has no prefix length, returns the same series as IPAddressSegmentSeries.getLower().
    
    Specified by:
    
    getLowerNonZeroHost in interface IPAddressSegmentSeries
    
    Specified by:
    
    getLowerNonZeroHost in class IPAddress
    
    Returns:
    
    the lowest IP address series whose host is non-zero, or null if no such address section exists.
  - getLower
```
public IPv6Address getLower()
```
    Description copied from interface: AddressSegmentSeries
    
    If this represents a series with ranging values, returns a series representing the lower values of the range. If this represents an series with a single value in each segment, returns this.
    
    Specified by:
    
    getLower in interface AddressComponent
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Specified by:
    
    getLower in interface IPAddressSegmentSeries
    
    Specified by:
    
    getLower in class IPAddress
    
    Returns:
  - getUpper
```
public IPv6Address getUpper()
```
    Description copied from interface: AddressSegmentSeries
    
    If this represents a series with ranging values, returns a series representing the upper values of the range If this represents a series with a single value in each segment, returns this.
    
    Specified by:
    
    getUpper in interface AddressComponent
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Specified by:
    
    getUpper in interface IPAddressSegmentSeries
    
    Specified by:
    
    getUpper in class IPAddress
    
    Returns:
  - replace
```
public IPv6Address replace(int startIndex,
                           int endIndex,
                           IPv6Address replacement,
                           int replacementIndex)
```
    Replaces segments starting from startIndex and ending before endIndex with the same number of segments starting at replacementStartIndex from the replacement section
    
    Parameters:
    
    startIndex -
    
    endIndex -
    
    replacement -
    
    replacementIndex -
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - reverseBits
```
public IPv6Address reverseBits(boolean perByte)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bits reversed.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    Specified by:
    
    reverseBits in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseBits in class IPAddress
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the component are reversed
    
    Returns:
  - reverseBytes
```
public IPv6Address reverseBytes()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed.
    
    Specified by:
    
    reverseBytes in interface AddressComponent
    
    Specified by:
    
    reverseBytes in interface AddressSegmentSeries
    
    Specified by:
    
    reverseBytes in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseBytes in class IPAddress
    
    Returns:
  - reverseBytesPerSegment
```
public IPv6Address reverseBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed within each segment.
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSegmentSeries
    
    Specified by:
    
    reverseBytesPerSegment in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseBytesPerSegment in class IPAddress
    
    Returns:
  - reverseSegments
```
public IPv6Address reverseSegments()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the segments reversed. This does not throw IncompatibleAddressException since all address series can reverse their segments.
    
    Specified by:
    
    reverseSegments in interface AddressSegmentSeries
    
    Specified by:
    
    reverseSegments in interface IPAddressSegmentSeries
    
    Specified by:
    
    reverseSegments in class IPAddress
    
    Returns:
  - segmentsNonZeroHostIterator
```
public java.util.Iterator<IPv6AddressSegment[]> segmentsNonZeroHostIterator()
```
    Specified by:
    
    segmentsNonZeroHostIterator in interface IPAddressSegmentSeries
  - segmentsIterator
```
public java.util.Iterator<IPv6AddressSegment[]> segmentsIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segments.
    
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
    
    Specified by:
    
    segmentsIterator in interface IPAddressSegmentSeries
  - prefixBlockIterator
```
public java.util.Iterator<IPv6Address> prefixBlockIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual prefix blocks. If the series has no prefix length, then this is equivalent to AddressSegmentSeries.iterator()
    
    Specified by:
    
    prefixBlockIterator in interface AddressSegmentSeries
    
    Specified by:
    
    prefixBlockIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixBlockIterator in class IPAddress
  - iterator
```
public java.util.Iterator<IPv6Address> iterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segment series. The resulting elements will not have an assigned prefix.
    
    Specified by:
    
    iterator in interface AddressComponent
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    iterator in interface java.lang.Iterable<IPv6Address>
    
    Specified by:
    
    iterator in class IPAddress
    
    Returns:
  - nonZeroHostIterator
```
public java.util.Iterator<IPv6Address> nonZeroHostIterator()
```
    Specified by:
    
    nonZeroHostIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    nonZeroHostIterator in class IPAddress
  - getIterable
```
public java.lang.Iterable<IPv6Address> getIterable()
```
    Description copied from interface: AddressComponent
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressComponent.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressComponent
    
    Specified by:
    
    getIterable in interface AddressSegmentSeries
    
    Specified by:
    
    getIterable in interface IPAddressSegmentSeries
    
    Specified by:
    
    getIterable in class IPAddress
    
    Returns:
    
    an object to iterate over the individual addresses represented by this object.
  - increment
```
public IPv6Address increment(long increment)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the series from the subnet that is the given increment upwards into the subnet range, or if the given increment is negative the given increment downwards into the subnet range, or if this is just an individual series, it simply adds the increment to this. If the increment is 0, then this series is returned.
    If the subnet has multiple values and the increment exceeds the subnet size, then the amount by which is exceeds the size is added to the upper series of the range (the final iterator value) or is subtracted from the lower series of the range (the first iterator value) if negative.
    If the subnet is just a single address values, the series is simply incremented by the given value, positive or negative.
    If a subnet has multiple values, a positive increment value is equivalent to the same number of values from the iterator. For instance, a increment of 1 is value 1 from the iterator, an increment of 2 is the second value from the iterator, and so on. A negative increment is equivalent to the same number of values preceding the upper bound of the iterator. For instance, an increment of -1 is the last value from the iterator, and increment of -2 is the second last value, and so on.
    Therefore, to get the series just above the highest series of the subnet, use an increment of size:count > 1 ? count + 1 : 1 where count is the subnet size. To get the series just below the lowest series of the subnet, use an increment of size:-(count > 1 ? count + 1 : 1) where count is the subnet size.
    
    Specified by:
    
    increment in interface AddressSegmentSeries
    
    Specified by:
    
    increment in interface IPAddressSegmentSeries
    
    Specified by:
    
    increment in class IPAddress
    
    Returns:
  - toIPv4
```
public IPv4Address toIPv4()
```
    If this address is IPv4 convertible, returns that address. Otherwise, returns null.
    This uses isIPv4Convertible() to determine convertibility, and that uses an instance of IPAddressConverter.DefaultAddressConverter which uses IPv4-mapped address mappings from rfc 4038.
    Override this method and isIPv4Convertible() if you wish to map IPv6 to IPv4 according to the mappings defined by in isIPv4Compatible(), isIPv4Mapped(), is6To4() or by some other mapping.
    For the reverse mapping, see IPv4Address.toIPv6()
    
    Overrides:
    
    toIPv4 in class IPAddress
    
    Returns:
    
    the address
    
    See Also:
    
    IPAddress.isIPv4Convertible()
  - toIPv6
```
public IPv6Address toIPv6()
```
    Overrides:
    
    toIPv6 in class IPAddress
    
    Returns:
    
    If this address is IPv6, or can be converted to IPv6, returns that IPv6Address. Otherwise, returns null.
    
    See Also:
    
    IPAddress.isIPv6Convertible()
  - isIPv4Convertible
```
public boolean isIPv4Convertible()
```
    Determines whether this address can be converted to IPv4. Override this method to convert in your own way. The default behaviour is to use isIPv4Mapped() You should also override toIPv4() to match the conversion.
    
    Specified by:
    
    isIPv4Convertible in class IPAddress
    
    Returns:
  - isIPv6Convertible
```
public boolean isIPv6Convertible()
```
    Description copied from class: IPAddress
    
    Determines whether an address can be converted to IPv6, if not IPv6 already. Override this method to convert in your own way. The default behaviour is to convert by IPv4 mapping, see IPv4Address.getIPv4MappedAddress() You should also override IPAddress.toIPv6() to match the conversion. This method returns true for all IPv6 addresses.
    
    Specified by:
    
    isIPv6Convertible in class IPAddress
    
    Returns:
  - toMappedIPv4Segments
```
public IPv4AddressSection toMappedIPv4Segments()
```
    ::ffff:x:x/96 indicates IPv6 address mapped to IPv4
  - get6to4IPv4Address
```
public IPv4Address get6to4IPv4Address()
```
    Returns the second and third bytes as an IPv4Address. This can be used for IPv4 or for IPv6 6to4 addresses convertible to IPv4.
    
    Returns:
    
    the address
  - getEmbeddedIPv4Address
```
public IPv4Address getEmbeddedIPv4Address()
```
    Returns the embedded IPv4Address in the lowest (least-significant) two segments. This is used by IPv4-mapped, IPv4-compatible, ISATAP addresses and 6over4 addresses
    
    Returns:
    
    the embedded IPv4Address
  - getEmbeddedIPv4Address
```
public IPv4Address getEmbeddedIPv4Address(int byteIndex)
```
    Produces an IPv4 address from any sequence of 4 bytes in this IPv6 address.
    
    Parameters:
    
    byteIndex - the byte index to start
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the index is less than zero or bigger than 7
  - isLocal
```
public boolean isLocal()
```
    Description copied from class: IPAddress
    
    Returns true if the address is link local, site local, organization local, administered locally, or unspecified. This includes both unicast and multicast.
    
    Specified by:
    
    isLocal in class IPAddress
    
    Returns:
  - isLinkLocal
```
public boolean isLinkLocal()
```
    Description copied from class: IPAddress
    
    Returns whether the address is link local, whether unicast or multicast.
    
    Specified by:
    
    isLinkLocal in class IPAddress
    
    See Also:
    
    InetAddress.isLinkLocalAddress()
  - isSiteLocal
```
public boolean isSiteLocal()
```
    See Also:
    
    InetAddress.isSiteLocalAddress()
  - isUniqueLocal
```
public boolean isUniqueLocal()
```
  - isIPv4Mapped
```
public boolean isIPv4Mapped()
```
    Whether the address is IPv4-mapped ::ffff:x:x/96 indicates IPv6 address mapped to IPv4
  - isIPv4Compatible
```
public boolean isIPv4Compatible()
```
    Whether the address is IPv4-compatible
    
    See Also:
    
    Inet6Address.isIPv4CompatibleAddress()
  - is6To4
```
public boolean is6To4()
```
    Whether the address is IPv6 to IPv4 relay
    
    See Also:
    
    get6to4IPv4Address()
  - is6Over4
```
public boolean is6Over4()
```
    Whether the address is 6over4
  - isTeredo
```
public boolean isTeredo()
```
    Whether the address is Teredo
  - isIsatap
```
public boolean isIsatap()
```
    Whether the address is ISATAP
  - isIPv4Translatable
```
public boolean isIPv4Translatable()
```
    Returns:
    
    Whether the address is IPv4 translatable as in rfc 2765
  - isWellKnownIPv4Translatable
```
public boolean isWellKnownIPv4Translatable()
```
    Whether the address has the well-known prefix for IPv4 translatable addresses as in rfc 6052 and 6144
    
    Returns:
  - isMulticast
```
public boolean isMulticast()
```
    Description copied from class: Address
    
    Whether the MAC address or IP address or other form of address is multicast.
    
    Specified by:
    
    isMulticast in class Address
    
    See Also:
    
    InetAddress.isMulticastAddress()
  - isLoopback
```
public boolean isLoopback()
```
    Specified by:
    
    isLoopback in class IPAddress
    
    See Also:
    
    InetAddress.isLoopbackAddress()
  - intersect
```
public IPv6Address intersect(IPAddress other)
                      throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Produces the subnet whose addresses are found in both this and the given subnet argument.
    This is also known as the conjunction of the two sets of addresses.
    If the address is not the same version, the default conversion will be applied using IPAddress.toIPv4() or IPAddress.toIPv6(), and it that fails, AddressConversionException will be thrown.
    
    Specified by:
    
    intersect in class IPAddress
    
    Returns:
    
    the subnet containing the addresses found in both this and the given subnet
    
    Throws:
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - subtract
```
public IPv6Address[] subtract(IPAddress other)
                       throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Subtract the given subnet from this subnet, returning an array of subnets for the result (the subnets will not be contiguous so an array is required).
    Computes the subnet difference, the set of addresses in this address subnet but not in the provided subnet. This is also known as the relative complement of the given argument in this subnet.
    If the address is not the same version, the default conversion will be applied using IPAddress.toIPv4() or IPAddress.toIPv6(), and it that fails, AddressConversionException will be thrown.
    
    Specified by:
    
    subtract in class IPAddress
    
    Returns:
    
    the difference
    
    Throws:
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - adjustPrefixBySegment
```
public IPv6Address adjustPrefixBySegment(boolean nextSegment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length to the next segment boundary.
    Follows the same rules as AddressSegmentSeries.adjustPrefixLength(int):
    When prefix length is increased, the bits moved within the prefix become zero. When a prefix length is decreased, the bits moved outside the prefix become zero.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in class IPAddress
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    Returns:
  - adjustPrefixBySegment
```
public IPv6Address adjustPrefixBySegment(boolean nextSegment,
                                         boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length to the next segment boundary.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in class IPAddress
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment coundary
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    Returns:
  - adjustPrefixLength
```
public IPv6Address adjustPrefixLength(int adjustment)
```
    Description copied from class: IPAddress
    
    Increases or decreases prefix length by the given increment.
    When prefix length is increased, the bits moved within the prefix become zero. When the prefix is extended beyond the segment series boundary, it is removed. When a prefix length is decreased, the bits moved outside the prefix become zero, and if the entire host address contains the zero address, then the resulting address is determined AddressNetwork.getPrefixConfiguration().
    For example, 1.2.0.0/16 adjusted by -8 becomes 1.0.0.0/8.
    1.2.0.0/16 adjusted by 8 becomes 1.2.0.0/24
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in class IPAddress
    
    Returns:
  - adjustPrefixLength
```
public IPv6Address adjustPrefixLength(int adjustment,
                                      boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length by the given increment.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixLength in class IPAddress
    
    Parameters:
    
    adjustment - the increment
    
    zeroed - whether the bits that move from one side of the prefix to the other become zero or retain their original values
    
    Returns:
  - setPrefixLength
```
public IPv6Address setPrefixLength(int prefixLength)
                            throws PrefixLenException
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length.
    If this series has a prefix length, and the prefix length is increased, the bits moved within the prefix become zero.
    When the prefix is extended beyond the segment series boundary, it is removed.
    The bits that move from one side of the prefix length to the other (ie bits moved into the prefix or outside the prefix) are zeroed.
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in class IPAddress
    
    Returns:
    
    Throws:
    
    PrefixLenException
    
    See Also:
    
    AddressSegmentSeries.applyPrefixLength(int)
  - setPrefixLength
```
public IPv6Address setPrefixLength(int prefixLength,
                                   boolean zeroed)
                            throws PrefixLenException
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length.
    When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in class IPAddress
    
    zeroed - whether the bits that move from one side of the prefix length to the other (ie bits moved into the prefix or outside the prefix) are zeroed.
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - applyPrefixLength
```
public IPv6Address applyPrefixLength(int networkPrefixLength)
                              throws PrefixLenException
```
    Description copied from interface: AddressSegmentSeries
    
    Applies the given prefix length to create a new segment series.
    Similar to AddressSegmentSeries.setPrefixLength(int) except that prefix lengths are never increased. When this series already has a prefix length that is less than or equal to the requested prefix length, this series is returned.
    Otherwise the returned series has the given prefix length.
    The bits moved outside the prefix will become zero in the returned series.
    
    Specified by:
    
    applyPrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    applyPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    applyPrefixLength in class IPAddress
    
    Returns:
    
    Throws:
    
    PrefixLenException
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)
  - removePrefixLength
```
public IPv6Address removePrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length.
    If the series already has a prefix length, the bits outside the prefix become zero.
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in class IPAddress
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.removePrefixLength(boolean)
  - removePrefixLength
```
public IPv6Address removePrefixLength(boolean zeroed)
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length.
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in class IPAddress
    
    Parameters:
    
    zeroed - whether the bits outside the prefix become zero
    
    Returns:
  - toZeroHost
```
public IPv6Address toZeroHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the segment series with a host of zero. If the series has no prefix length, then it returns an all-zero series.
    The resultant series will have the same prefix length if AddressNetwork.getPrefixConfiguration() is not AddressNetwork.PrefixConfiguration.ALL_PREFIXED_ADDRESSES_ARE_SUBNETS, otherwise it will no longer have a prefix length.
    For instance, you can get the network address for a subnet as follows: String addrStr = "1.2.3.4/16"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress networkAddress = address.toZeroHost(); //1.2.0.0
    
    Specified by:
    
    toZeroHost in interface IPAddressSegmentSeries
    
    Specified by:
    
    toZeroHost in class IPAddress
    
    Returns:
  - toZeroHost
```
public IPv6Address toZeroHost(int prefixLength)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Produces the series with host values of 0 for the given prefix length.
    If this series has the same prefix length, then the resulting series will too, otherwise the resulting series will have no prefix length.
    This is nearly equivalent to doing the mask (bitwise conjunction) of this address series with the network mask for the given prefix length, but without the possibility of IncompatibleAddressException that can occur when applying a mask to a range of values. Instead, in this case, if the resulting series has a range of values, then the resulting series range boundaries will have host values of 0, but not necessarily the intervening values.
    For instance, you can get the network address for a subnet of prefix length 16 as follows: String addrStr = "1.2.3.4"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress networkAddress = address.toZeroHost(16); //1.2.0.0
    
    Specified by:
    
    toZeroHost in interface IPAddressSegmentSeries
    
    Specified by:
    
    toZeroHost in class IPAddress
    
    Returns:
  - toMaxHost
```
public IPv6Address toMaxHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the segment series with a host of all ones. If the series has no prefix length, then it returns an all-ones series.
    The resultant series will have the same prefix length if AddressNetwork.getPrefixConfiguration() is not AddressNetwork.PrefixConfiguration.ALL_PREFIXED_ADDRESSES_ARE_SUBNETS, otherwise it will no longer have a prefix length.
    For instance, you can get the broadcast address for a subnet as follows: String addrStr = "1.2.3.4/16"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress broadcastAddress = address.toMaxHost(); //1.2.255.255
    
    Specified by:
    
    toMaxHost in interface IPAddressSegmentSeries
    
    Specified by:
    
    toMaxHost in class IPAddress
    
    Returns:
  - toMaxHost
```
public IPv6Address toMaxHost(int prefixLength)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Produces the series with host values of all one bits for the given prefix length.
    If this series has the same prefix length, then the resulting series will too, otherwise the resulting series will have no prefix length.
    This is nearly equivalent to doing the bitwise or (bitwise disjunction) of this address series with the network mask for the given prefix length, but without the possibility of IncompatibleAddressException that can occur when applying a mask to a range of values. Instead, in this case, if the resulting series has a range of values, then the resulting series range boundaries will have host values of all ones, but not necessarily the intervening values.
    For instance, you can get the broadcast address for a subnet of prefix length 16 as follows: String addrStr = "1.2.3.4"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress broadcastAddress = address.toMaxHost(16); //1.2.255.255
    
    Specified by:
    
    toMaxHost in interface IPAddressSegmentSeries
    
    Specified by:
    
    toMaxHost in class IPAddress
    
    Returns:
  - mask
```
public IPv6Address mask(IPAddress mask,
                        boolean retainPrefix)
                 throws IncompatibleAddressException,
                        AddressConversionException
```
    Description copied from class: IPAddress
    
    Applies the given mask to all addresses represented by this IPAddress. The mask is applied to all individual addresses. Any existing prefix length is removed beforehand. If the retainPrefix argument is true, then the existing prefix length will be applied to the result.
    If the mask is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6()
    If this represents multiple addresses, and applying the mask to all addresses creates a set of addresses that cannot be represented as a contiguous range within each segment, then IncompatibleAddressException is thrown.
    
    Specified by:
    
    mask in class IPAddress
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - mask
```
public IPv6Address mask(IPAddress mask)
                 throws IncompatibleAddressException,
                        AddressConversionException
```
    Description copied from class: IPAddress
    
    Equivalent to calling IPAddress.mask(IPAddress, boolean) with the second argument as false.
    If the mask is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6()
    
    Specified by:
    
    mask in class IPAddress
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - maskNetwork
```
public IPv6Address maskNetwork(IPAddress mask,
                               int networkPrefixLength)
                        throws IncompatibleAddressException,
                               PrefixLenException,
                               AddressConversionException
```
    Description copied from class: IPAddress
    
    Applies the given mask to all addresses represented by this IPAddress while also applying the given prefix length at the same time.
    Any existing prefix length is removed as the mask and new prefix length is applied to all individual addresses.
    If the mask is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6()
    If this represents multiple addresses, and applying the mask to all addresses creates a set of addresses that cannot be represented as a contiguous range within each segment, then IncompatibleAddressException is thrown.
    
    Specified by:
    
    maskNetwork in class IPAddress
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
    
    PrefixLenException
  - bitwiseOr
```
public IPv6Address bitwiseOr(IPAddress mask,
                             boolean retainPrefix)
                      throws IncompatibleAddressException,
                             AddressConversionException
```
    Description copied from class: IPAddress
    
    Does the bitwise disjunction with this address. Useful when subnetting.
    The mask is applied to all individual addresses, similar to how the method IPAddress.mask(IPAddress, boolean) applies the bitwise conjunction. Any existing prefix length is removed beforehand. If the retainPrefix argument is true, then the existing prefix length will be applied to the result.
    If the mask is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6()
    If you wish to mask a portion of the network, use IPAddress.bitwiseOrNetwork(IPAddress, int)
    For instance, you can get the broadcast address for a subnet as follows: String addrStr = "1.2.3.4/16"; IPAddress address = new IPAddressString(addrStr).getAddress(); IPAddress hostMask = address.getNetwork().getHostMask(address.getNetworkPrefixLength());//0.0.255.255 IPAddress broadcastAddress = address.bitwiseOr(hostMask); //1.2.255.255
    
    Specified by:
    
    bitwiseOr in class IPAddress
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - bitwiseOr
```
public IPv6Address bitwiseOr(IPAddress mask)
                      throws IncompatibleAddressException,
                             AddressConversionException
```
    Description copied from class: IPAddress
    
    Equivalent to calling IPAddress.bitwiseOr(IPAddress, boolean) with the second argument as false.
    If the mask is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6()
    
    Specified by:
    
    bitwiseOr in class IPAddress
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
  - bitwiseOrNetwork
```
public IPv6Address bitwiseOrNetwork(IPAddress mask,
                                    int networkPrefixLength)
                             throws IncompatibleAddressException,
                                    PrefixLenException,
                                    AddressConversionException
```
    Description copied from class: IPAddress
    
    Does the bitwise disjunction with this address. Useful when subnetting.
    If the mask is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6()
    Any existing prefix length is dropped for the new prefix length and the mask is applied up to the end the new prefix length. It is similar to how the IPAddress.maskNetwork(IPAddress, int) method does the bitwise conjunction.
    
    Specified by:
    
    bitwiseOrNetwork in class IPAddress
    
    networkPrefixLength - the new prefix length for the address
    
    Returns:
    
    Throws:
    
    IncompatibleAddressException - if this is a range of addresses and applying the mask results in an address that cannot be represented as a contiguous range within each segment
    
    AddressConversionException - if the address argument could not be converted to the same address version as this
    
    PrefixLenException
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the network section of the series if the series has a CIDR network prefix length, otherwise it returns the entire series as a prefixed series with prefix matching the address bit length.
    
    Specified by:
    
    getNetworkSection in interface IPAddressSegmentSeries
    
    Returns:
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection(int networkPrefixLength)
                                     throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the network section of the series. The returned section will have only as many segments as needed as indicated by networkPrefixLength. It will have networkPrefixLength as its associated prefix length, unless this address already has a smaller prefix length, in which case the existing prefix length is retained.
    
    Specified by:
    
    getNetworkSection in interface IPAddressSegmentSeries
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - getNetworkSection
```
public IPv6AddressSection getNetworkSection(int networkPrefixLength,
                                            boolean withPrefixLength)
                                     throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the network section of the series. The returned section will have only as many segments as needed as indicated by networkPrefixLength. If withPrefixLength is true, it will have networkPrefixLength as its associated prefix length, unless this series already has a smaller prefix length, in which case the existing prefix length is retained.
    
    Specified by:
    
    getNetworkSection in interface IPAddressSegmentSeries
    
    withPrefixLength - whether the resulting section will have networkPrefixLength as the associated prefix length or not
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - getHostSection
```
public IPv6AddressSection getHostSection(int networkPrefixLength)
                                  throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the host section of the address as indicated by the network prefix length provided. The returned section will have only as many segments as needed to hold the host as indicated by the provided network prefix length.
    
    Specified by:
    
    getHostSection in interface IPAddressSegmentSeries
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - getHostSection
```
public IPv6AddressSection getHostSection()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the host section of the series. The returned section will have only as many segments as needed as determined by the existing CIDR network prefix length. If this series has no CIDR prefix length, the returned host section will be the full section associated with a prefix length of 0.
    
    Specified by:
    
    getHostSection in interface IPAddressSegmentSeries
    
    Returns:
  - toPrefixBlock
```
public IPv6Address toPrefixBlock()
```
    Description copied from class: IPAddress
    
    Returns the subnet associated with the prefix length of this address. If this address has no prefix length, this address is returned.
    For example, if the address is 1.2.3.4/16 it returns the subnet 1.2.*.* /16
    
    Specified by:
    
    toPrefixBlock in interface AddressSegmentSeries
    
    Specified by:
    
    toPrefixBlock in interface IPAddressSegmentSeries
    
    Specified by:
    
    toPrefixBlock in class IPAddress
    
    Returns:
    
    the block of address series for the prefix length
  - toPrefixBlock
```
public IPv6Address toPrefixBlock(int networkPrefixLength)
                          throws PrefixLenException
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the segment series of the same length that spans all hosts. The network prefix length will be the one provided, and the network values will match the same of this series.
    
    Specified by:
    
    toPrefixBlock in interface IPAddressSegmentSeries
    
    Specified by:
    
    toPrefixBlock in class IPAddress
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - assignPrefixForSingleBlock
```
public IPv6Address assignPrefixForSingleBlock()
```
    Description copied from class: IPAddress
    
    Returns the equivalent CIDR address with a prefix length for which the address subnet block matches the range of values in this address.
    If no such prefix length exists, returns null.
    Examples:
    1.2.3.4 returns 1.2.3.4/32
    1.2.*.* returns 1.2.0.0/16
    1.2.*.0/24 returns 1.2.0.0/16
    1.2.*.4 returns null
    1.2.252-255.* returns 1.2.252.0/22
    1.2.3.4/x returns the same address
    
    Specified by:
    
    assignPrefixForSingleBlock in interface IPAddressSegmentSeries
    
    Overrides:
    
    assignPrefixForSingleBlock in class IPAddress
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toPrefixBlock(), IPAddressSegmentSeries.assignMinPrefixForBlock()
  - assignMinPrefixForBlock
```
public IPv6Address assignMinPrefixForBlock()
```
    Description copied from class: IPAddress
    
    Constructs an equivalent address with the smallest CIDR prefix possible (largest network), such that the range of values are a set of subnet blocks for that prefix.
    
    Specified by:
    
    assignMinPrefixForBlock in interface IPAddressSegmentSeries
    
    Overrides:
    
    assignMinPrefixForBlock in class IPAddress
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toPrefixBlock(), IPAddressSegmentSeries.assignPrefixForSingleBlock()
  - spanWithPrefixBlocks
```
public IPv6Address[] spanWithPrefixBlocks(IPAddress other)
                                   throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Produces the list of prefix block subnets that span from this series to the given series.
    If the other address is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6()
    The resulting array is sorted from lowest address value to highest, regardless of the size of each prefix block.
    
    Specified by:
    
    spanWithPrefixBlocks in class IPAddress
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - mergePrefixBlocks
```
public IPv6Address[] mergePrefixBlocks(IPAddress... addresses)
                                throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Merges this with the list of addresses to produce the smallest list of prefix blocks
    If any other address in the list is a different version than this, then the default conversion is applied first using IPAddress.toIPv4() or IPAddress.toIPv6(), which can result in AddressConversionException
    The result is sorted from single address to smallest blocks to largest blocks.
    
    Specified by:
    
    mergePrefixBlocks in class IPAddress
    
    Parameters:
    
    addresses - the addresses to merge with this
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - hasZone
```
public boolean hasZone()
```
  - getZone
```
public java.lang.String getZone()
```
    The zone or scope id, which is typically appended to an address with a '%', eg fe80::71a3:2b00:ddd3:753f%16 If there is no zone or scope id, returns null
    
    Returns:
  - removeZone
```
public IPv6Address removeZone()
```
  - toInetAddress
```
public java.net.Inet6Address toInetAddress()
```
    Description copied from class: IPAddress
    
    Converts the lowest value of this address to an InetAddress
    
    Overrides:
    
    toInetAddress in class IPAddress
  - toUpperInetAddress
```
public java.net.Inet6Address toUpperInetAddress()
```
    Description copied from class: IPAddress
    
    Converts the highest value of this address to an InetAddress. If this consists of just a single address and not a subnet, this is equivalent to IPAddress.toInetAddress()
    
    Overrides:
    
    toUpperInetAddress in class IPAddress
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Address
  - isSameAddress
```
public boolean isSameAddress(Address other)
```
    Overrides:
    
    isSameAddress in class Address
  - isSameAddress
```
public boolean isSameAddress(IPAddress other)
```
    Overrides:
    
    isSameAddress in class IPAddress
  - contains
```
public boolean contains(Address other)
```
    Overrides:
    
    contains in class IPAddress
    
    Parameters:
    
    other -
    
    Returns:
    
    whether this subnet contains the given address
  - toMixedString
```
public java.lang.String toMixedString()
```
  - toCanonicalString
```
public java.lang.String toCanonicalString()
```
    This produces a canonical string. RFC 5952 describes canonical representations. http://en.wikipedia.org/wiki/IPv6_address#Recommended_representation_as_text http://tools.ietf.org/html/rfc5952 If this has a prefix length, that will be included in the string.
    
    Specified by:
    
    toCanonicalString in interface AddressSegmentSeries
    
    Overrides:
    
    toCanonicalString in class Address
    
    Returns:
  - toFullString
```
public java.lang.String toFullString()
```
    Description copied from class: IPAddress
    
    This produces a string with no compressed segments and all segments of full length, which is 4 characters for IPv6 segments and 3 characters for IPv4 segments. Each address has a unique full string, not counting CIDR the prefix, which can give two equal addresses different strings.
    
    Specified by:
    
    toFullString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toFullString in class IPAddress
  - toNormalizedString
```
public static java.lang.String toNormalizedString(IPv6AddressNetwork network,
                                                  Address.SegmentValueProvider lowerValueProvider,
                                                  Address.SegmentValueProvider upperValueProvider,
                                                  java.lang.Integer prefixLength,
                                                  java.lang.CharSequence zone)
```
    Creates the normalized string for an address without having to create the address objects first.
    
    Parameters:
    
    lowerValueProvider -
    
    upperValueProvider -
    
    prefixLength -
    
    zone -
    
    Returns:
  - toNormalizedString
```
public java.lang.String toNormalizedString()
```
    The normalized string returned by this method is consistent with java.net.Inet6address. IPs are not compressed nor mixed in this representation. If this has a prefix length, that will be included in the string.
    
    Specified by:
    
    toNormalizedString in interface AddressComponent
    
    Overrides:
    
    toNormalizedString in class Address
    
    Returns:
  - toCompressedString
```
public java.lang.String toCompressedString()
```
    This compresses the maximum number of zeros and/or host segments with the IPv6 compression notation '::'
    
    Specified by:
    
    toCompressedString in interface AddressSegmentSeries
    
    Overrides:
    
    toCompressedString in class Address
    
    Returns:
  - toSubnetString
```
public java.lang.String toSubnetString()
```
    Description copied from class: IPAddress
    
    Produces a consistent subnet string that looks like 1.2.*.* or 1:2::/16 In the case of IPv4, this means that wildcards are used instead of a network prefix when a network prefix has been supplied. In the case of IPv6, when a network prefix has been supplied, the prefix will be shown and the host section will be compressed with ::.
    
    Specified by:
    
    toSubnetString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toSubnetString in class IPAddress
  - toNormalizedWildcardString
```
public java.lang.String toNormalizedWildcardString()
```
    Description copied from class: IPAddress
    
    This produces a string similar to the normalized string but avoids the CIDR prefix. CIDR addresses will be shown with wildcards and ranges instead of using the CIDR prefix notation.
    
    Specified by:
    
    toNormalizedWildcardString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toNormalizedWildcardString in class IPAddress
  - toBase85String
```
public java.lang.String toBase85String()
```
    The base 85 string is described by RFC 1924
    
    Returns:
  - toCanonicalWildcardString
```
public java.lang.String toCanonicalWildcardString()
```
    Description copied from class: IPAddress
    
    This produces a string similar to the canonical string but avoids the CIDR prefix. Addresses with a network prefix length will be shown with wildcards and ranges instead of using the CIDR prefix length notation. IPv6 addresses will be compressed according to the canonical representation.
    
    Specified by:
    
    toCanonicalWildcardString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toCanonicalWildcardString in class IPAddress
  - toCompressedWildcardString
```
public java.lang.String toCompressedWildcardString()
```
    Description copied from class: IPAddress
    
    This is similar to toNormalizedWildcardString, avoiding the CIDR prefix, but with compression as well.
    
    Specified by:
    
    toCompressedWildcardString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toCompressedWildcardString in class IPAddress
  - toSQLWildcardString
```
public java.lang.String toSQLWildcardString()
```
    Description copied from class: IPAddress
    
    This is the same as the string from toNormalizedWildcardString except that it uses Address.SEGMENT_SQL_WILDCARD instead of Address.SEGMENT_WILDCARD and also uses Address.SEGMENT_SQL_SINGLE_WILDCARD
    
    Specified by:
    
    toSQLWildcardString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toSQLWildcardString in class IPAddress
  - toHexString
```
public java.lang.String toHexString(boolean with0xPrefix)
```
    Description copied from class: Address
    
    Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix. If this section represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    
    Specified by:
    
    toHexString in interface AddressComponent
    
    Overrides:
    
    toHexString in class Address
  - toBinaryString
```
public java.lang.String toBinaryString()
```
    Description copied from class: IPAddress
    
    Writes this address as a single binary value with always the exact same number of characters
    If this section represents a range of values not corresponding to a prefix, then this is printed as a range of two hex values.
    
    Specified by:
    
    toBinaryString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toBinaryString in class IPAddress
  - toOctalString
```
public java.lang.String toOctalString(boolean with0Prefix)
```
    Description copied from class: IPAddress
    
    Writes this address as a single octal value with always the exact same number of characters, with or without a preceding 0 prefix.
    If this section represents a range of values not corresponding to a prefix, then this is printed as a range of two hex values.
    
    Specified by:
    
    toOctalString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toOctalString in class IPAddress
  - toPrefixLengthString
```
public java.lang.String toPrefixLengthString()
```
    Description copied from class: IPAddress
    
    Returns a string with a CIDR network prefix length if this address has a network prefix length. For IPv6, the host section will be compressed with ::, for IPv4 the host section will be zeros.
    
    Specified by:
    
    toPrefixLengthString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toPrefixLengthString in class IPAddress
    
    Returns:
  - toConvertedString
```
public java.lang.String toConvertedString()
```
    Description copied from class: IPAddress
    
    Returns a mixed string if it represents a convertible IPv4 address, returns the normalized string otherwise.
    
    Overrides:
    
    toConvertedString in class IPAddress
    
    Returns:
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPAddressSection.IPStringOptions params)
```
    Description copied from class: IPAddress
    
    Constructs a string representing this address according to the given parameters
    
    Specified by:
    
    toNormalizedString in interface IPAddressSegmentSeries
    
    Overrides:
    
    toNormalizedString in class IPAddress
    
    Parameters:
    
    params - the parameters for the address string
    
    Returns:
  - toNormalizedString
```
public java.lang.String toNormalizedString(IPv6AddressSection.IPv6StringOptions params)
```
  - toNormalizedString
```
public java.lang.String toNormalizedString(boolean keepMixed,
                                           IPv6AddressSection.IPv6StringOptions params)
```
    Constructs a string representing this address according to the given parameters
    
    Parameters:
    
    keepMixed - if this address was constructed from a string with mixed representation (a:b:c:d:e:f:1.2.3.4), whether to keep it that way (ignored if makeMixed is true in the params argument)
    
    params - the parameters for the address string
  - toUNCHostName
```
public java.lang.String toUNCHostName()
```
    Description copied from class: IPAddress
    
    Generates the Microsoft UNC path component for this address
    
    Specified by:
    
    toUNCHostName in class IPAddress
    
    Returns:
  - toStandardStringCollection
```
public IPAddressPartStringCollection toStandardStringCollection()
```
    Overrides:
    
    toStandardStringCollection in class IPAddress
  - toAllStringCollection
```
public IPAddressPartStringCollection toAllStringCollection()
```
    Overrides:
    
    toAllStringCollection in class IPAddress
  - toStringCollection
```
public IPAddressPartStringCollection toStringCollection(IPAddressSection.IPStringBuilderOptions opts)
```
    Specified by:
    
    toStringCollection in interface IPAddressSegmentSeries
    
    Overrides:
    
    toStringCollection in class IPAddress
  - toStringCollection
```
public IPAddressPartStringCollection toStringCollection(IPv6AddressSection.IPv6StringBuilderOptions opts)
```

Nested classes/interfaces inherited from class inet.ipaddr.IPAddress

Nested classes/interfaces inherited from class inet.ipaddr.Address

Fields inherited from class inet.ipaddr.IPAddress

Fields inherited from class inet.ipaddr.Address

Methods inherited from class inet.ipaddr.IPAddress

Methods inherited from class inet.ipaddr.Address

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Methods inherited from interface inet.ipaddr.AddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressItem

SEGMENT_SEPARATOR

ZONE_SEPARATOR

ALTERNATIVE_ZONE_SEPARATOR

UNC_SEGMENT_SEPARATOR

UNC_ZONE_SEPARATOR

UNC_RANGE_SEPARATOR

UNC_RANGE_SEPARATOR_STR

UNC_SUFFIX

REVERSE_DNS_SUFFIX

REVERSE_DNS_SUFFIX_DEPRECATED

BITS_PER_SEGMENT

BYTES_PER_SEGMENT

SEGMENT_COUNT

MIXED_REPLACED_SEGMENT_COUNT

MIXED_ORIGINAL_SEGMENT_COUNT

BYTE_COUNT

BIT_COUNT

DEFAULT_TEXTUAL_RADIX

MAX_VALUE_PER_SEGMENT

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

IPv6Address

getNetwork

getMACNetwork

getIPv4Network

getSection

getSection

getSection

getDivision

getSegment

getSegments

isEUI64

toEUI

getParts

getParts

getSegmentCount

getByteCount

getBitCount

getLowerNonZeroHost

getLower

getUpper

replace

reverseBits

reverseBytes

reverseBytesPerSegment

reverseSegments

segmentsNonZeroHostIterator