Address (IPAddress javadoc by seancfoley)

java.lang.Object
- inet.ipaddr.Address

All Implemented Interfaces:

AddressComponent, AddressSegmentSeries, AddressComponentRange, AddressDivisionSeries, AddressItem, AddressItemRange, AddressStringDivisionSeries, Serializable, Comparable<AddressItem>

Direct Known Subclasses:

IPAddress, MACAddress
```
public abstract class Address
extends Object
implements AddressSegmentSeries
```
An address, or a collection of multiple addresses. Each segment can represent a single value or a range of values.
To construct one from a String use IPAddressString or MACAddressString

See Also:

Serialized Form

Core

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface Address.AddressValueProvider

static interface Address.SegmentValueProvider

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Address.AddressValueProvider`
`static interface`	`Address.SegmentValueProvider`

Field Summary

Fields
Modifier and Type	Field and Description
`static AddressComparator`	`ADDRESS_HIGH_VALUE_COMPARATOR`
`static AddressComparator`	`ADDRESS_LOW_VALUE_COMPARATOR`
`static char`	`ALTERNATIVE_RANGE_SEPARATOR`
`static String`	`ALTERNATIVE_RANGE_SEPARATOR_STR`
`static String`	`ALTERNATIVE_SEGMENT_WILDCARD_STR`
`static AddressComparator`	`DEFAULT_ADDRESS_COMPARATOR`
`static String`	`HEX_PREFIX`
`static String`	`OCTAL_PREFIX`
`static char`	`RANGE_SEPARATOR`
`static String`	`RANGE_SEPARATOR_STR`
`static char`	`SEGMENT_SQL_SINGLE_WILDCARD`
`static String`	`SEGMENT_SQL_SINGLE_WILDCARD_STR`
`static char`	`SEGMENT_SQL_WILDCARD`
`static String`	`SEGMENT_SQL_WILDCARD_STR`
`static char`	`SEGMENT_WILDCARD`
`static String`	`SEGMENT_WILDCARD_STR`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`abstract Address`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`abstract Address`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`abstract Address`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`abstract Address`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`abstract Address`	`applyPrefixLength(int networkPrefixLength)` Deprecated.
`boolean`	`contains(Address other)` Returns whether this is same type and version of the given address and whether it contains all individual addresses in the given address or subnet
`boolean`	`containsPrefixBlock(int prefixLength)` Returns whether the values of this series contains the prefix block for the given prefix length.
`boolean`	`containsSinglePrefixBlock(int prefixLength)` Returns whether the values of this series contains a single prefix block for the given prefix length.
`static IPv4AddressNetwork`	`defaultIpv4Network()`
`static IPv6AddressNetwork`	`defaultIpv6Network()`
`static MACAddressNetwork`	`defaultMACNetwork()`
`abstract BigInteger`	`enumerate(Address other)` Indicates where an address sits relative to the subnet ordering.
`boolean`	`equals(Object o)` Two Address objects are equal if they represent the same set of addresses.
`int`	`getBitCount()` Provides the number of bits comprising this address item
`BigInteger`	`getBlockCount(int segmentCount)` Returns the count of values in the initial (higher) count of divisions.
`int`	`getByteCount()` Provides the number of bytes required for this address item, rounding up if the bit count is not a multiple of 8
`byte[]`	`getBytes()`
`byte[]`	`getBytes(byte[] bytes)` Copies the bytes of the lowest address item represented by this address item into the supplied array, and returns that array.
`byte[]`	`getBytes(byte[] bytes, int index)` Copies the bytes of the lowest address item represented by this address item into the supplied array starting at the given index, and returns that array.
`BigInteger`	`getCount()` Gets the count of addresses that this address may represent.
`int`	`getDivisionCount()`
`String[]`	`getDivisionStrings()` Get standard-format strings for each of the divisions in the series.
`abstract Iterable<? extends Address>`	`getIterable()` Useful for using an instance in a "for-each loop".
`abstract Address`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`int`	`getMinPrefixLengthForBlock()` Returns the smallest prefix length possible such that this includes the block of addresses for that prefix.
`BigInteger`	`getPrefixCount()` If this has a prefix length, the count of the range of values in the prefix.
`BigInteger`	`getPrefixCount(int prefixLength)` Gets the count of prefixes in this address for the given prefix length.
`Integer`	`getPrefixLength()` the largest number of high bits for which this address represents all addresses with the same set of high bits
`Integer`	`getPrefixLengthForSingleBlock()` Returns a prefix length for which the range of this address subnet matches the block of addresses for that prefix.
`AddressSection`	`getSection()` Gets the subsection from the series that comprises all segments
`int`	`getSegmentCount()` Returns the number of segments in this series.
`void`	`getSegments(AddressSegment[] segs)` Copies the existing segments into the given array.
`void`	`getSegments(int start, int end, AddressSegment[] segs, int index)` get the segments from start to end and insert into the segs array at the given index
`String[]`	`getSegmentStrings()` Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
`abstract Address`	`getUpper()` If this represents a series with ranging values, returns a series representing the upper values of the range.
`byte[]`	`getUpperBytes()` Gets the bytes for the highest address in the range of addresses represented by this address instance.
`byte[]`	`getUpperBytes(byte[] bytes)` Copies the bytes of the largest address item represented by this address item into the supplied array, and returns that array.
`byte[]`	`getUpperBytes(byte[] bytes, int index)` Copies the bytes of the largest address item represented by this address item into the supplied array at the given index, and returns that array.
`BigInteger`	`getUpperValue()` Returns the highest value represented by this address item, the highest value included in the range of values
`BigInteger`	`getValue()` Returns the lowest value represented by this address item, the lowest value included in the range of values
`int`	`hashCode()`
`boolean`	`includesMax()` Returns whether this item includes the maximum possible value for the address type or version within its range
`boolean`	`includesZero()` Returns whether this item includes the value of zero within its range
`abstract Address`	`increment(long increment)` Returns the series from the subnet that is the given increment upwards into the subnet range, with the increment of 0 returning the first address in the range.
`abstract Address`	`incrementBoundary(long increment)` If the given increment is positive, adds the value to the upper series (`AddressSegmentSeries.getUpper()`) in the subnet range to produce a new series.
`boolean`	`isFullRange()` whether this address item represents all possible values attainable by an address item of this type
`boolean`	`isIPAddress()` Returns whether this address is an IP address
`abstract boolean`	`isLocal()` Whether the address can be considered a local address (as opposed to a global one)
`boolean`	`isMACAddress()` Returns whether this address is a MAC address
`boolean`	`isMax()` Returns whether this item matches the maximum possible value for the address type or version
`abstract boolean`	`isMulticast()` Whether the MAC address or IP address or other form of address is multicast.
`boolean`	`isMultiple()` Returns whether this address represents more than a single individual address, whether it is a subnet.
`boolean`	`isPrefixBlock()` Returns whether the address range has a prefix length and includes the block of values for its prefix length.
`boolean`	`isPrefixed()` Returns whether this address has an associated prefix length
`boolean`	`isSameAddress(Address other)`
`boolean`	`isSequential()` Returns whether the series represents a range of values that are sequential.
`boolean`	`isSinglePrefixBlock()` Returns whether the address range the block of values for a single prefix identified by its prefix length.
`boolean`	`isZero()` Returns whether this item matches the value of zero
`abstract Iterator<? extends Address>`	`iterator()` Iterates through the individual address components.
`static boolean`	`matchOrdered(Address[] addrs1, Address[] addrs2)` Checks if the two arrays share the same ordered list of addresses, subnets, or address collections, using address equality.
`static boolean`	`matchUnordered(Address[] addrs1, Address[] addrs2)` Checks if the two arrays share the same list of addresses, subnets, or address collections, in any order, using address equality.
`boolean`	`overlaps(Address other)` Returns whether this is same type and version of the given address and whether it overlaps with the individual addresses in the given address or subnet, containing at least one individual address common to both.
`abstract Iterator<? extends Address>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`abstract AddressComponentSpliterator<? extends Address>`	`prefixBlockSpliterator()` Partitions and traverses through the individual prefix blocks for the prefix length of this series.
`abstract Stream<? extends Address>`	`prefixBlockStream()` Returns a sequential stream of the individual prefix blocks for the prefix length of this series.
`boolean`	`prefixEquals(Address other)`
`abstract Iterator<? extends Address>`	`prefixIterator()` Iterates through the individual prefixes.
`abstract AddressComponentSpliterator<? extends Address>`	`prefixSpliterator()` Partitions and traverses through the individual prefixes for the prefix length of this series.
`abstract Stream<? extends Address>`	`prefixStream()` Returns a sequential stream of the individual prefixes for the prefix length of this series.
`abstract Address`	`removePrefixLength()` Deprecated.
`abstract Address`	`removePrefixLength(boolean zeroed)` Deprecated.
`abstract Address`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`abstract Address`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`abstract Address`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`abstract Address`	`reverseSegments()` Returns a new segment series with the segments reversed.
`abstract Address`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`abstract Address`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`abstract AddressComponentSpliterator<? extends Address>`	`spliterator()` Partitions and traverses through the individual address components.
`abstract Stream<? extends Address>`	`stream()` Returns a sequential stream of the individual address components.
`HostIdentifierString`	`toAddressString()` Returns a host identifier string representation for this address, which will be already validated.
`String`	`toCanonicalString()` This produces a canonical string.
`String`	`toCompressedString()` Produce short strings for the address in the usual address format.
`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.
`IPAddress`	`toIPAddress()` If this address is an IP address, returns that `IPAddress`.
`MACAddress`	`toMACAddress()` If this address is a MAC address, returns that `MACAddress`.
`String`	`toNormalizedString()` The normalized string returned by this method is a common and consistent representation of the address.
`abstract Address`	`toPrefixBlock()` If this series has a prefix length, returns the block for that prefix.
`String`	`toString()`
`abstract Address`	`withoutPrefixLength()` Provides the same address with no prefix.

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

Methods inherited from interface inet.ipaddr.AddressSegmentSeries
getBitsPerSegment, getBytesPerSegment, getMaxSegmentValue, getSection, getSection, getSegment, getSegments, isOneBit, segmentsIterator, segmentsSpliterator, segmentsStream, testBit

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getDivision, getSequentialBlockIndex, isMore

Methods inherited from interface inet.ipaddr.AddressComponent
getNetwork

Methods inherited from interface inet.ipaddr.format.AddressComponentRange
stream, stream

Methods inherited from interface inet.ipaddr.format.AddressItem
compareTo, getBitsForCount, getBlockSize

- Field Detail
  - HEX_PREFIX
```
public static final String HEX_PREFIX
```
    See Also:
    
    Constant Field Values
  - OCTAL_PREFIX
```
public static final String OCTAL_PREFIX
```
    See Also:
    
    Constant Field Values
  - RANGE_SEPARATOR
```
public static final char RANGE_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - RANGE_SEPARATOR_STR
```
public static final String RANGE_SEPARATOR_STR
```
  - ALTERNATIVE_RANGE_SEPARATOR
```
public static final char ALTERNATIVE_RANGE_SEPARATOR
```
    See Also:
    
    Constant Field Values
  - ALTERNATIVE_RANGE_SEPARATOR_STR
```
public static final String ALTERNATIVE_RANGE_SEPARATOR_STR
```
  - SEGMENT_WILDCARD
```
public static final char SEGMENT_WILDCARD
```
    See Also:
    
    Constant Field Values
  - SEGMENT_WILDCARD_STR
```
public static final String SEGMENT_WILDCARD_STR
```
  - ALTERNATIVE_SEGMENT_WILDCARD_STR
```
public static final String ALTERNATIVE_SEGMENT_WILDCARD_STR
```
    See Also:
    
    Constant Field Values
  - SEGMENT_SQL_WILDCARD
```
public static final char SEGMENT_SQL_WILDCARD
```
    See Also:
    
    Constant Field Values
  - SEGMENT_SQL_WILDCARD_STR
```
public static final String SEGMENT_SQL_WILDCARD_STR
```
  - SEGMENT_SQL_SINGLE_WILDCARD
```
public static final char SEGMENT_SQL_SINGLE_WILDCARD
```
    See Also:
    
    Constant Field Values
  - SEGMENT_SQL_SINGLE_WILDCARD_STR
```
public static final String SEGMENT_SQL_SINGLE_WILDCARD_STR
```
  - DEFAULT_ADDRESS_COMPARATOR
```
public static final AddressComparator DEFAULT_ADDRESS_COMPARATOR
```
  - ADDRESS_LOW_VALUE_COMPARATOR
```
public static final AddressComparator ADDRESS_LOW_VALUE_COMPARATOR
```
  - ADDRESS_HIGH_VALUE_COMPARATOR
```
public static final AddressComparator ADDRESS_HIGH_VALUE_COMPARATOR
```
- Method Detail
  - defaultIpv6Network
```
public static IPv6AddressNetwork defaultIpv6Network()
```
  - defaultIpv4Network
```
public static IPv4AddressNetwork defaultIpv4Network()
```
  - defaultMACNetwork
```
public static MACAddressNetwork defaultMACNetwork()
```
  - getSegmentCount
```
public int getSegmentCount()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the number of segments in this series.
    
    Specified by:
    
    getSegmentCount in interface AddressSegmentSeries
    
    Returns:
  - getDivisionCount
```
public int getDivisionCount()
```
    Specified by:
    
    getDivisionCount in interface AddressStringDivisionSeries
  - getBitCount
```
public int getBitCount()
```
    Description copied from interface: AddressItem
    
    Provides the number of bits comprising this address item
    
    Specified by:
    
    getBitCount in interface AddressDivisionSeries
    
    Specified by:
    
    getBitCount in interface AddressItem
    
    Returns:
    
    the number of bits
  - getByteCount
```
public int getByteCount()
```
    Description copied from interface: AddressItem
    
    Provides the number of bytes required for this address item, rounding up if the bit count is not a multiple of 8
    
    Specified by:
    
    getByteCount in interface AddressItem
    
    Returns:
    
    the number of bytes
  - getSection
```
public AddressSection getSection()
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series that comprises all segments
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSegments
```
public void getSegments(AddressSegment[] segs)
```
    Description copied from interface: AddressSegmentSeries
    
    Copies the existing segments into the given array. The array size should be at least as large as AddressSegmentSeries.getSegmentCount()
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
  - getSegments
```
public void getSegments(int start,
                        int end,
                        AddressSegment[] segs,
                        int index)
```
    Description copied from interface: AddressSegmentSeries
    
    get the segments from start to end and insert into the segs array at the given index
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
    
    Parameters:
    
    start - the first segment index from this series to be included
    
    end - the first segment index to be excluded
    
    segs - the target array
    
    index - where to insert the segments in the segs array
  - getIterable
```
public abstract Iterable<? extends Address> getIterable()
```
    Description copied from interface: AddressComponentRange
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressComponentRange.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressSegmentSeries
    
    Specified by:
    
    getIterable in interface AddressComponentRange
    
    Returns:
  - iterator
```
public abstract Iterator<? extends Address> iterator()
```
    Description copied from interface: AddressComponentRange
    
    Iterates through the individual address components.
    An address component can represent an individual segment, address, or section, or it can represent multiple, typically a subnet of addresses or a range of segment or section values.
    Call AddressItem.isMultiple() to determine if this instance represents multiple, or AddressItem.getCount() for the count.
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface AddressComponentRange
    
    Returns:
  - spliterator
```
public abstract AddressComponentSpliterator<? extends Address> spliterator()
```
    Description copied from interface: AddressComponentRange
    
    Partitions and traverses through the individual address components.
    
    Specified by:
    
    spliterator in interface AddressComponent
    
    Specified by:
    
    spliterator in interface AddressSegmentSeries
    
    Specified by:
    
    spliterator in interface AddressComponentRange
    
    Returns:
  - stream
```
public abstract Stream<? extends Address> stream()
```
    Description copied from interface: AddressComponentRange
    
    Returns a sequential stream of the individual address components. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    stream in interface AddressSegmentSeries
    
    Specified by:
    
    stream in interface AddressComponentRange
    
    Returns:
  - prefixIterator
```
public abstract Iterator<? extends Address> prefixIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual prefixes.
    If the series has no prefix length, then this is equivalent to AddressSegmentSeries.iterator()
    
    Specified by:
    
    prefixIterator in interface AddressSegmentSeries
  - prefixSpliterator
```
public abstract AddressComponentSpliterator<? extends Address> prefixSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual prefixes for the prefix length of this series.
    
    Specified by:
    
    prefixSpliterator in interface AddressSegmentSeries
    
    Returns:
  - prefixStream
```
public abstract Stream<? extends Address> prefixStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual prefixes for the prefix length of this series. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixStream in interface AddressSegmentSeries
    
    Returns:
  - prefixBlockIterator
```
public abstract Iterator<? extends Address> 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
  - prefixBlockSpliterator
```
public abstract AddressComponentSpliterator<? extends Address> prefixBlockSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual prefix blocks for the prefix length of this series.
    
    Specified by:
    
    prefixBlockSpliterator in interface AddressSegmentSeries
    
    Returns:
  - prefixBlockStream
```
public abstract Stream<? extends Address> prefixBlockStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual prefix blocks for the prefix length of this series. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixBlockStream in interface AddressSegmentSeries
    
    Returns:
  - increment
```
public abstract Address increment(long increment)
                           throws AddressValueException
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the series from the subnet that is the given increment upwards into the subnet range, with the increment of 0 returning the first address in the range.
    If the subnet has multiple values and the increment exceeds the subnet size, then the amount by which it exceeds the size - 1 is added to the upper series of the range (the final iterator value).
    If the increment is negative, it is added to the lower series of the range (the first iterator value).
    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 AddressSegmentSeries.iterator() For instance, a increment of 0 is the first value from the iterator, an increment of 1 is the second value from the iterator, and so on. A negative increment added to the subnet count is equivalent to the same number of values preceding the upper bound of the iterator. For instance, an increment of count - 1 is the last value from the iterator, an increment of count - 2 is the second last value, and so on.
    An increment of size count gives you the series just above the highest series of the subnet. To get the series just below the lowest series of the subnet, use the increment -1.
    
    Specified by:
    
    increment in interface AddressSegmentSeries
    
    Returns:
    
    Throws:
    
    AddressValueException - in case of underflow or overflow
  - incrementBoundary
```
public abstract Address incrementBoundary(long increment)
                                   throws AddressValueException
```
    Description copied from interface: AddressSegmentSeries
    
    If the given increment is positive, adds the value to the upper series (AddressSegmentSeries.getUpper()) in the subnet range to produce a new series. If the given increment is negative, adds the value to the lower series (AddressSegmentSeries.getLower()) in the subnet range to produce a new series. If the increment is zero, returns this.
    In the case where the series is a single value, this simply returns the address produced by adding the given increment to this address series.
    
    Specified by:
    
    incrementBoundary in interface AddressSegmentSeries
    
    Returns:
    
    Throws:
    
    AddressValueException - in case of underflow or overflow
  - getLower
```
public abstract Address 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 AddressSegmentSeries
    
    Specified by:
    
    getLower in interface AddressComponentRange
    
    Returns:
  - getUpper
```
public abstract Address 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 AddressSegmentSeries
    
    Specified by:
    
    getUpper in interface AddressComponentRange
    
    Returns:
  - isMultiple
```
public boolean isMultiple()
```
    Returns whether this address represents more than a single individual address, whether it is a subnet. Such addresses include CIDR/IP addresses (eg 1.2.3.0/25) or wildcard addresses (eg 1.2.*.4) or range addresses (eg 1.2.3-4.5)
    
    Specified by:
    
    isMultiple in interface AddressItem
    
    Returns:
    
    whether this address represents more than one address.
  - isPrefixed
```
public boolean isPrefixed()
```
    Returns whether this address has an associated prefix length
    
    Specified by:
    
    isPrefixed in interface AddressDivisionSeries
    
    Returns:
    
    whether this address has an associated prefix length
  - isIPAddress
```
public boolean isIPAddress()
```
    Returns whether this address is an IP address
    
    Returns:
    
    whether this address is an IP address
  - isMACAddress
```
public boolean isMACAddress()
```
    Returns whether this address is a MAC address
    
    Returns:
    
    whether this address is a MAC address
  - toIPAddress
```
public IPAddress toIPAddress()
```
    If this address is an IP address, returns that IPAddress. Otherwise, returns null.
    
    Returns:
    
    the IP address
  - toMACAddress
```
public MACAddress toMACAddress()
```
    If this address is a MAC address, returns that MACAddress. Otherwise, returns null.
    
    Returns:
    
    the MAC address
  - getPrefixLength
```
public Integer getPrefixLength()
```
    the largest number of high bits for which this address represents all addresses with the same set of high bits
    
    Specified by:
    
    getPrefixLength in interface AddressDivisionSeries
  - getMinPrefixLengthForBlock
```
public int getMinPrefixLengthForBlock()
```
    Returns the smallest prefix length possible such that this includes the block of addresses for that prefix.
    If the entire range can be dictated this way, then this method returns the same value as getPrefixLengthForSingleBlock(). Otherwise, this method will return the minimal possible prefix that can be paired with this address, while getPrefixLengthForSingleBlock() will return null.
    In cases where the final bit in this address division series is constant, this returns the bit length of this address division series.
    
    Specified by:
    
    getMinPrefixLengthForBlock in interface AddressItem
    
    Returns:
    
    the prefix length
  - getPrefixLengthForSingleBlock
```
public Integer getPrefixLengthForSingleBlock()
```
    Returns a prefix length for which the range of this address subnet matches the block of addresses for that prefix.
    If the range can be dictated this way, then this method returns the same value as getMinPrefixLengthForBlock().
    If no such prefix exists, returns null.
    If this segment grouping represents a single value, returns the bit length of this address division series.
    IP address examples: 1.2.3.4 returns 32 1.2.*.* returns 16 1.2.*.0/24 returns 16 in the case of PrefixConfiguration == ALL_PREFIXES_ARE_SUBNETS, 32 otherwise 1.2.*.4 returns null 1.2.252-255.* returns 22 1.2.3.4/x returns x in the case of PrefixConfiguration == ALL_PREFIXES_ARE_SUBNETS, 32 otherwise 1.2.0.0/16 returns 16 in the case of PrefixConfiguration == ALL_PREFIXES_ARE_SUBNETS or PREFIXED_ZERO_HOSTS_ARE_SUBNETS, 32 otherwise
    
    Specified by:
    
    getPrefixLengthForSingleBlock in interface AddressItem
    
    Returns:
    
    the prefix length or null if it does not exist
  - isMulticast
```
public abstract boolean isMulticast()
```
    Whether the MAC address or IP address or other form of address is multicast.
    
    See Also:
    
    InetAddress.isMulticastAddress()
  - getCount
```
public BigInteger getCount()
```
    Gets the count of addresses that this address may represent. If this address is not a subnet block of multiple addresses or has no range of values, then there is only one such address.
    
    Specified by:
    
    getCount in interface AddressDivisionSeries
    
    Specified by:
    
    getCount in interface AddressItem
    
    Returns:
  - getPrefixCount
```
public BigInteger getPrefixCount(int prefixLength)
```
    Gets the count of prefixes in this address for the given prefix length. If this address is not a subnet block of multiple addresses or has no range of values, then there is only one.
    
    Specified by:
    
    getPrefixCount in interface AddressDivisionSeries
    
    Specified by:
    
    getPrefixCount in interface AddressItem
    
    Returns:
  - getPrefixCount
```
public BigInteger getPrefixCount()
```
    If this has a prefix length, the count of the range of values in the prefix. If this has no prefix, returns the same value as getCount()
    
    Specified by:
    
    getPrefixCount in interface AddressDivisionSeries
    
    Returns:
  - getBlockCount
```
public BigInteger getBlockCount(int segmentCount)
```
    Description copied from interface: AddressDivisionSeries
    
    Returns the count of values in the initial (higher) count of divisions.
    
    Specified by:
    
    getBlockCount in interface AddressDivisionSeries
    
    Returns:
  - getBytes
```
public byte[] getBytes()
```
    Specified by:
    
    getBytes in interface AddressItem
    
    Returns:
    
    the bytes of the lowest address item represented by this address item
  - getBytes
```
public byte[] getBytes(byte[] bytes)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the lowest address item represented by this address item into the supplied array, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned.
    
    Specified by:
    
    getBytes in interface AddressItem
    
    Returns:
    
    the bytes of the lowest address represented by this address item.
  - getBytes
```
public byte[] getBytes(byte[] bytes,
                       int index)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the lowest address item represented by this address item into the supplied array starting at the given index, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned, with the rest of the array contents the same as the original.
    
    Specified by:
    
    getBytes in interface AddressItem
    
    Returns:
    
    the bytes of the lowest address represented by this address item.
  - getUpperBytes
```
public byte[] getUpperBytes()
```
    Gets the bytes for the highest address in the range of addresses represented by this address instance.
    
    Specified by:
    
    getUpperBytes in interface AddressItem
    
    Returns:
  - getUpperBytes
```
public byte[] getUpperBytes(byte[] bytes)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the largest address item represented by this address item into the supplied array, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned, with the rest of the array contents the same as the original.
    
    Specified by:
    
    getUpperBytes in interface AddressItem
    
    Returns:
    
    the bytes of the largest address represented by this address item.
  - getUpperBytes
```
public byte[] getUpperBytes(byte[] bytes,
                            int index)
```
    Description copied from interface: AddressItem
    
    Copies the bytes of the largest address item represented by this address item into the supplied array at the given index, and returns that array. If the supplied array is null or of insufficient size, a new array is created and returned.
    
    Specified by:
    
    getUpperBytes in interface AddressItem
    
    Returns:
    
    the bytes of the largest address represented by this address item.
  - getValue
```
public BigInteger getValue()
```
    Description copied from interface: AddressItem
    
    Returns the lowest value represented by this address item, the lowest value included in the range of values
    
    Specified by:
    
    getValue in interface AddressItem
    
    Returns:
    
    the lowest value represented by this address item
  - getUpperValue
```
public BigInteger getUpperValue()
```
    Description copied from interface: AddressItem
    
    Returns the highest value represented by this address item, the highest value included in the range of values
    
    Specified by:
    
    getUpperValue in interface AddressItem
    
    Returns:
    
    the highest value represented by this address item
  - isZero
```
public boolean isZero()
```
    Description copied from interface: AddressItem
    
    Returns whether this item matches the value of zero
    
    Specified by:
    
    isZero in interface AddressItem
    
    Returns:
    
    whether this item matches the value of zero
  - includesZero
```
public boolean includesZero()
```
    Description copied from interface: AddressItem
    
    Returns whether this item includes the value of zero within its range
    
    Specified by:
    
    includesZero in interface AddressItem
    
    Returns:
    
    whether this item includes the value of zero within its range
  - isMax
```
public boolean isMax()
```
    Description copied from interface: AddressItem
    
    Returns whether this item matches the maximum possible value for the address type or version
    
    Specified by:
    
    isMax in interface AddressItem
    
    Returns:
    
    whether this item matches the maximum possible value
  - includesMax
```
public boolean includesMax()
```
    Description copied from interface: AddressItem
    
    Returns whether this item includes the maximum possible value for the address type or version within its range
    
    Specified by:
    
    includesMax in interface AddressItem
    
    Returns:
    
    whether this item includes the maximum possible value within its range
  - isFullRange
```
public boolean isFullRange()
```
    Description copied from interface: AddressItem
    
    whether this address item represents all possible values attainable by an address item of this type
    
    Specified by:
    
    isFullRange in interface AddressItem
    
    Returns:
    
    whether this address item represents all possible values attainable by an address item of this type, or in other words, both includesZero() and includesMax() return true
  - isLocal
```
public abstract boolean isLocal()
```
    Whether the address can be considered a local address (as opposed to a global one)
    
    Returns:
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - isSameAddress
```
public boolean isSameAddress(Address other)
```
  - equals
```
public boolean equals(Object o)
```
    Two Address objects are equal if they represent the same set of addresses.
    
    Overrides:
    
    equals in class Object
  - prefixEquals
```
public boolean prefixEquals(Address other)
```
  - overlaps
```
public boolean overlaps(Address other)
```
    Returns whether this is same type and version of the given address and whether it overlaps with the individual addresses in the given address or subnet, containing at least one individual address common to both.
    
    Parameters:
    
    other -
    
    Returns:
  - contains
```
public boolean contains(Address other)
```
    Returns whether this is same type and version of the given address and whether it contains all individual addresses in the given address or subnet
    
    Parameters:
    
    other -
    
    Returns:
  - enumerate
```
public abstract BigInteger enumerate(Address other)
```
    Indicates where an address sits relative to the subnet ordering.
    Determines how many address elements of a subnet precede the given address element, if the address is in the subnet. If above the subnet range, it is the distance to the upper boundary added to the subnet address count less one, and if below the subnet range, the distance to the lower boundary.
    In other words, if the given address is not in the subnet but above it, returns the number of addresses preceding the address from the upper subnet boundary, added to one less than the total number of subnet addresses. If the given address is not in the subnet but below it, returns the number of addresses following the address to the lower subnet boundary.
    enumerate returns null when the argument is a multi-valued subnet. The argument must be an individual address.
    When this address is also single-valued, the returned value is the distance (difference) between this address and the argument address.
    enumerate is the inverse of the increment method:
    - subnet.enumerate(subnet.increment(inc)) = inc
    - subnet.increment(subnet.enumerate(newAddr)) = newAddr
    If the given address does not have the same version or type as this subnet or address, then null is returned.
  - isSequential
```
public boolean isSequential()
```
    Description copied from interface: AddressDivisionSeries
    
    Returns whether the series represents a range of values that are sequential.
    Generally, this means that any division covering a range of values must be followed by divisions that are full range, covering all values.
    
    Specified by:
    
    isSequential in interface AddressDivisionSeries
    
    Returns:
  - toAddressString
```
public HostIdentifierString toAddressString()
```
    Returns a host identifier string representation for this address, which will be already validated.
    
    Returns:
  - toHexString
```
public String toHexString(boolean with0xPrefix)
                   throws IncompatibleAddressException
```
    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
    
    Throws:
    
    IncompatibleAddressException
  - toNormalizedString
```
public String toNormalizedString()
```
    The normalized string returned by this method is a common and consistent representation of the address.
    The string returned by this method is unique for each address.
    
    Specified by:
    
    toNormalizedString in interface AddressComponent
    
    Returns:
  - toCanonicalString
```
public String toCanonicalString()
```
    This produces a canonical string.
    RFC 5952 describes canonical representations for Ipv6 http://en.wikipedia.org/wiki/IPv6_address#Recommended_representation_as_text http://tools.ietf.org/html/rfc5952
    Each address has a unique canonical string, not counting the prefix. The prefix can cause two equal addresses to have different strings.
    
    Specified by:
    
    toCanonicalString in interface AddressSegmentSeries
    
    Returns:
  - toCompressedString
```
public String toCompressedString()
```
    Produce short strings for the address in the usual address format. Each address has a unique compressed string.
    
    Specified by:
    
    toCompressedString in interface AddressSegmentSeries
    
    Returns:
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getDivisionStrings
```
public String[] getDivisionStrings()
```
    Description copied from interface: AddressDivisionSeries
    
    Get standard-format strings for each of the divisions in the series.
    
    Specified by:
    
    getDivisionStrings in interface AddressDivisionSeries
    
    Returns:
  - getSegmentStrings
```
public String[] getSegmentStrings()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the an array with the values of each segment as they would appear in the normalized with wildcards string.
    
    Specified by:
    
    getSegmentStrings in interface AddressSegmentSeries
    
    Returns:
  - reverseSegments
```
public abstract Address 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
    
    Returns:
  - reverseBits
```
public abstract Address 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
    
    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 abstract Address 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
    
    Returns:
  - reverseBytesPerSegment
```
public abstract Address reverseBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed within each segment.
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSegmentSeries
    
    Returns:
  - isPrefixBlock
```
public boolean isPrefixBlock()
```
    Returns whether the address range has a prefix length and includes the block of values for its prefix length.
    
    Specified by:
    
    isPrefixBlock in interface AddressDivisionSeries
    
    Returns:
  - containsPrefixBlock
```
public boolean containsPrefixBlock(int prefixLength)
```
    Description copied from interface: AddressItem
    
    Returns whether the values of this series contains the prefix block for the given prefix length.
    Use AddressItem.getMinPrefixLengthForBlock() to determine the smallest prefix length for which this method returns true.
    
    Specified by:
    
    containsPrefixBlock in interface AddressItem
    
    Returns:
  - isSinglePrefixBlock
```
public boolean isSinglePrefixBlock()
```
    Returns whether the address range the block of values for a single prefix identified by its prefix length. This is similar to isPrefixBlock() except that it returns false when the subnet has multiple prefixes. For instance, 1.*.*.* /16 return false for this method and returns true for isPrefixBlock()
    
    Specified by:
    
    isSinglePrefixBlock in interface AddressDivisionSeries
    
    Returns:
  - containsSinglePrefixBlock
```
public boolean containsSinglePrefixBlock(int prefixLength)
```
    Description copied from interface: AddressItem
    
    Returns whether the values of this series contains a single prefix block for the given prefix length.
    Use AddressItem.getPrefixLengthForSingleBlock() to determine whether there is a prefix length for which this method returns true.
    
    Specified by:
    
    containsSinglePrefixBlock in interface AddressItem
    
    Returns:
  - toPrefixBlock
```
public abstract Address toPrefixBlock()
```
    Description copied from interface: AddressSegmentSeries
    
    If this series has a prefix length, returns the block for that prefix. Otherwise, this address series is returned.
    
    Specified by:
    
    toPrefixBlock in interface AddressSegmentSeries
    
    Returns:
    
    the block of address series for the prefix length
  - removePrefixLength
```
@Deprecated
public abstract Address removePrefixLength()
```
    Deprecated.
    
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length while zeroing out the bits beyond the prefix.
    If the series already has a prefix length, the bits outside the prefix become zero. Use AddressSegmentSeries.withoutPrefixLength() to remove the prefix length without changing the series values.
    Equivalent to calling removePrefixLength(true)
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Returns:
    
    See Also:
    
    for an alternative which does not change the address series values.
  - withoutPrefixLength
```
public abstract Address withoutPrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Provides the same address with no prefix. The values remain unchanged.
    Use AddressSegmentSeries.removePrefixLength() as an alternative that deletes the host at the same time by zeroing the host values.
    
    Specified by:
    
    withoutPrefixLength in interface AddressSegmentSeries
  - removePrefixLength
```
@Deprecated
public abstract Address removePrefixLength(boolean zeroed)
```
    Deprecated.
    
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix length. If zeroed is false, the bits that were host bits do not become zero, unlike AddressSegmentSeries.removePrefixLength()
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Parameters:
    
    zeroed - whether the bits outside the prefix become zero
    
    Returns:
  - adjustPrefixBySegment
```
public abstract Address 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. To avoid the zeroing behaviour, use AddressSegmentSeries.adjustPrefixBySegment(boolean, boolean) with second arg false.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment boundary
    
    Returns:
  - adjustPrefixBySegment
```
public abstract Address 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
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment boundary
    
    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 abstract Address adjustPrefixLength(int adjustment)
```
    Description copied from interface: AddressSegmentSeries
    
    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. To avoid the zeroing behaviour, use AddressSegmentSeries.adjustPrefixLength(int, boolean) with second arg false.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - adjustPrefixLength
```
public abstract Address 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
    
    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 abstract Address setPrefixLength(int prefixLength)
```
    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. For an alternative that does not set bits to zero, use AddressSegmentSeries.setPrefixLength(int, boolean) with the second argument as false.
    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
    
    Returns:
  - setPrefixLength
```
public abstract Address setPrefixLength(int prefixLength,
                                        boolean zeroed)
```
    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
    
    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:
  - applyPrefixLength
```
@Deprecated
public abstract Address applyPrefixLength(int networkPrefixLength)
```
    Deprecated.
    
    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
    
    Returns:
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)
  - matchUnordered
```
public static boolean matchUnordered(Address[] addrs1,
                                     Address[] addrs2)
```
    Checks if the two arrays share the same list of addresses, subnets, or address collections, in any order, using address equality. The function can handle duplicates, ignoring them.
    
    Parameters:
    
    addrs1 -
    
    addrs2 -
    
    Returns:
  - matchOrdered
```
public static boolean matchOrdered(Address[] addrs1,
                                   Address[] addrs2)
```
    Checks if the two arrays share the same ordered list of addresses, subnets, or address collections, using address equality. Duplicates are allowed, but must match their counterpart in the other array with each occurrence.
    
    Parameters:
    
    addrs1 -
    
    addrs2 -
    
    Returns:

Class Address

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.AddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.AddressComponent

Methods inherited from interface inet.ipaddr.format.AddressComponentRange

Methods inherited from interface inet.ipaddr.format.AddressItem

Field Detail

HEX_PREFIX

OCTAL_PREFIX

RANGE_SEPARATOR

RANGE_SEPARATOR_STR

ALTERNATIVE_RANGE_SEPARATOR

ALTERNATIVE_RANGE_SEPARATOR_STR

SEGMENT_WILDCARD

SEGMENT_WILDCARD_STR

ALTERNATIVE_SEGMENT_WILDCARD_STR

SEGMENT_SQL_WILDCARD

SEGMENT_SQL_WILDCARD_STR

SEGMENT_SQL_SINGLE_WILDCARD

SEGMENT_SQL_SINGLE_WILDCARD_STR

DEFAULT_ADDRESS_COMPARATOR

ADDRESS_LOW_VALUE_COMPARATOR

ADDRESS_HIGH_VALUE_COMPARATOR

Method Detail

defaultIpv6Network

defaultIpv4Network

defaultMACNetwork

getSegmentCount

getDivisionCount

getBitCount

getByteCount

getSection

getSegments

getSegments

getIterable

iterator

spliterator

stream

prefixIterator

prefixSpliterator

prefixStream

prefixBlockIterator

prefixBlockSpliterator

prefixBlockStream

increment

incrementBoundary

getLower

getUpper

isMultiple

isPrefixed

isIPAddress

isMACAddress

toIPAddress

toMACAddress

getPrefixLength

getMinPrefixLengthForBlock

getPrefixLengthForSingleBlock

isMulticast

getCount

getPrefixCount

getPrefixCount

getBlockCount

getBytes

getBytes

getBytes

getUpperBytes

getUpperBytes

getUpperBytes

getValue

getUpperValue

isZero

includesZero

isMax

includesMax

isFullRange

isLocal