IPv4Address (IPAddress javadoc by seancfoley)

java.lang.Object
- inet.ipaddr.Address
- - inet.ipaddr.IPAddress
  - - inet.ipaddr.ipv4.IPv4Address

All Implemented Interfaces:

AddressComponent, AddressSegmentSeries, AddressComponentRange, AddressDivisionSeries, AddressItem, AddressItemRange, IPAddressDivisionSeries, IPAddressRange, AddressStringDivisionSeries, IPAddressStringDivisionSeries, IPAddressSegmentSeries, Serializable, Comparable<AddressItem>, Iterable<IPv4Address>
```
public class IPv4Address
extends IPAddress
implements Iterable<IPv4Address>
```
An IPv4 address, or a subnet of multiple IPv4 addresses. Each segment can represent a single value or a range of values.
You can construct an IPv4 address from a byte array, from an int, from a Address.SegmentValueProvider, from Inet4Address, from an IPv4AddressSection of 4 segments, or from an array of 4 IPv4AddressSegment 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 class IPv4Address.inet_aton_radix

static interface IPv4Address.IPv4AddressConverter
- Nested classes/interfaces inherited from class inet.ipaddr.IPAddress
  IPAddress.DualIPv4Pv6Arrays, IPAddress.IPAddressValueProvider, IPAddress.IPVersion
- Nested classes/interfaces inherited from class inet.ipaddr.Address
  Address.AddressValueProvider, Address.SegmentValueProvider

Nested Classes
Modifier and Type	Class and Description
`static class`	`IPv4Address.inet_aton_radix`
`static interface`	`IPv4Address.IPv4AddressConverter`

Field Summary

Fields
Modifier and Type	Field and Description
`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`
`static int`	`MAX_VALUE_PER_SEGMENT`
`static String`	`REVERSE_DNS_SUFFIX`
`static int`	`SEGMENT_COUNT`
`static char`	`SEGMENT_SEPARATOR`

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

Fields inherited from class inet.ipaddr.Address
ADDRESS_HIGH_VALUE_COMPARATOR, ADDRESS_LOW_VALUE_COMPARATOR, 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
`IPv4Address(Address.SegmentValueProvider valueProvider)` Constructs an IPv4 address.
`IPv4Address(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider)` Constructs an IPv4 address or subnet.
`IPv4Address(Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, Integer networkPrefixLength)` Constructs an IPv4 address or subnet.
`IPv4Address(Address.SegmentValueProvider valueProvider, Integer networkPrefixLength)` Constructs an IPv4 address.
`IPv4Address(byte[] bytes)` Constructs an IPv4 address.
`IPv4Address(byte[] bytes, Integer networkPrefixLength)` Constructs an IPv4 address or subnet.
`IPv4Address(byte[] bytes, int byteStartIndex, int byteEndIndex)` Constructs an IPv4 address or subnet.
`IPv4Address(byte[] bytes, int byteStartIndex, int byteEndIndex, Integer networkPrefixLength)` Constructs an IPv4 address or subnet.
`IPv4Address(Inet4Address inet4Address)` Constructs an IPv4 address.
`IPv4Address(Inet4Address inet4Address, Integer networkPrefixLength)` Constructs an IPv4 address.
`IPv4Address(int address)` Constructs an IPv4 address.
`IPv4Address(int address, Integer networkPrefixLength)` Constructs an IPv4 address or subnet.
`IPv4Address(IPv4AddressSection section)` Constructs an IPv4 address or subnet.
`IPv4Address(IPv4AddressSegment[] segments)` Constructs an IPv4 address or subnet.
`IPv4Address(IPv4AddressSegment[] segments, Integer networkPrefixLength)` Constructs an IPv4 address or subnet.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`IPv4Address`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`IPv4Address`	`adjustPrefixBySegment(boolean nextSegment, boolean zeroed)` Increases or decreases prefix length to the next segment boundary.
`IPv4Address`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`IPv4Address`	`adjustPrefixLength(int adjustment, boolean zeroed)` Increases or decreases prefix length by the given increment.
`IPv4Address`	`applyPrefixLength(int networkPrefixLength)` Deprecated.
`IPv4Address`	`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.
`IPv4Address`	`assignPrefixForSingleBlock()` Returns the equivalent CIDR address with a prefix length for which the address subnet block matches the range of values in this address.
`IPv4Address`	`bitwiseOr(IPAddress mask)` Equivalent to calling `IPAddress.bitwiseOr(IPAddress, boolean)` with the second argument as false.
`IPv4Address`	`bitwiseOr(IPAddress mask, boolean retainPrefix)` Does the bitwise disjunction with this address.
`IPv4Address`	`bitwiseOrNetwork(IPAddress mask, int networkPrefixLength)` Does the bitwise disjunction with this address.
`Iterator<IPv4Address>`	`blockIterator(int segmentCount)` Iterates through series that can be obtained by iterating through all the upper segments up to the given segment count.
`AddressComponentSpliterator<IPv4Address>`	`blockSpliterator(int segmentCount)` Partitions and traverses through the individual sequential blocks created from each of the individual values up to the given segment count.
`Stream<IPv4Address>`	`blockStream(int segmentCount)` Returns a sequential stream of the individual blocks created from each of the individual values up to the given segment count.
`IPv4Address`	`coverWithPrefixBlock()` Returns the minimal-size prefix block that covers all the values in this series.
`IPv4Address`	`coverWithPrefixBlock(IPAddress other)` Returns the minimal-size prefix block that covers all the addresses spanning from this subnet to the given subnet.
`BigInteger`	`enumerate(Address other)` Indicates where an address sits relative to the subnet ordering.
`BigInteger`	`enumerate(IPAddress other)` Indicates where an address sits relative to the subnet ordering.
`Long`	`enumerateIPv4(IPv4Address other)` Indicates where an address sits relative to the subnet ordering.
`int`	`getBitCount()` Provides the number of bits comprising this address item
`int`	`getByteCount()` Provides the number of bytes required for this address item, rounding up if the bit count is not a multiple of 8
`IPv4AddressSegment`	`getDivision(int index)`
`IPv4Address`	`getHostMask()` Returns the host mask associated with the CIDR network prefix length of this series.
`IPv4AddressSection`	`getHostSection()` Returns the host section of the series.
`IPv4AddressSection`	`getHostSection(int networkPrefixLength)` Returns the host section of the address as indicated by the network prefix length provided.
`IPv6Address`	`getIPv4MappedAddress()`
`IPv6Address`	`getIPv6Address(IPv6AddressSegment[] segs)` Create an IPv6 mixed address using the given ipv6 segments and using this address for the embedded IPv4 segments
`IPv6AddressNetwork`	`getIPv6Network()` Returns the IPv6 network used by `getIPv4MappedAddress()` and `getIPv6Address(IPv6AddressSegment[])`
`Iterable<IPv4Address>`	`getIterable()` Useful for using an instance in a "for-each loop".
`IPv4Address`	`getLower()` If this represents a series with ranging values, returns a series representing the lower values of the range.
`IPv4Address`	`getLowerNonZeroHost()` Similar to `IPAddressSegmentSeries.getLower()`, but will not return a series that has a prefix length and whose host value is zero.
`IPv4AddressNetwork`	`getNetwork()` Returns the network object for components of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`IPv4Address`	`getNetworkMask()` Returns the network mask associated with the CIDR network prefix length of this series.
`IPv4AddressSection`	`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.
`IPv4AddressSection`	`getNetworkSection(int networkPrefixLength)` Returns the network section of the series.
`IPv4AddressSection`	`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(IPv4AddressSection.IPv4StringBuilderOptions options)`
`IPv4AddressSection`	`getSection()` Returns the address as an address section comprising all segments in the address.
`IPv4AddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index The first segment is at index 0.
`IPv4AddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex The first segment is at index 0.
`IPv4AddressSegment`	`getSegment(int index)` Returns the segment from this series at the given index.
`int`	`getSegmentCount()` Returns the number of segments in this series.
`IPv4AddressSegment[]`	`getSegments()` Returns the segments of this series of segments as an array.
`IPv4Address`	`getUpper()` If this represents a series with ranging values, returns a series representing the upper values of the range.
`IPv4Address`	`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.
`IPv4Address`	`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.
`IPv4Address`	`intersect(IPAddress other)` Produces the subnet whose addresses are found in both this and the given subnet argument, or null if no such addresses.
`int`	`intValue()` Returns the address (or lowest value of the address if a subnet) as a signed integer
`boolean`	`isIPv4()`
`boolean`	`isIPv4Convertible()` Determines whether this address can be converted to IPv4, if not IPv4 already.
`boolean`	`isIPv6Convertible()` Override this method to convert in your own way.
`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`	`isPrivate()` Unicast addresses allocated for private use
`Iterator<IPv4Address>`	`iterator()` Iterates through the individual address components.
`long`	`longValue()` Returns the address (or lowest value of the address if a subnet) as a positive integer
`IPv4Address`	`mask(IPAddress mask)` Equivalent to calling `IPAddress.mask(IPAddress, boolean)` with the second argument as false.
`IPv4Address`	`mask(IPAddress mask, boolean retainPrefix)` Applies the given mask to all addresses represented by this IPAddress.
`IPv4Address`	`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.
`IPv4Address[]`	`mergeToPrefixBlocks(IPAddress... addresses)` Merges this with the list of addresses to produce the smallest list of prefix blocks.
`IPv4Address[]`	`mergeToSequentialBlocks(IPAddress... addresses)` Merges this with the list of subnets to produce the smallest list of block subnets that are sequential.
`Iterator<IPv4Address>`	`nonZeroHostIterator()` Similar to the iterator, but series with a host of zero are skipped.
`Iterator<IPv4Address>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`Iterator<IPv4Address>`	`prefixBlockIterator(int prefixLength)` Iterates through the range of prefix blocks in this range instance using the given prefix length.
`AddressComponentSpliterator<IPv4Address>`	`prefixBlockSpliterator()` Partitions and traverses through the individual prefix blocks for the prefix length of this series.
`AddressComponentSpliterator<IPv4Address>`	`prefixBlockSpliterator(int prefixLength)` Partitions and traverses through the individual prefix blocks for the given prefix length.
`Stream<IPv4Address>`	`prefixBlockStream()` Returns a sequential stream of the individual prefix blocks for the prefix length of this series.
`Stream<IPv4Address>`	`prefixBlockStream(int prefixLength)` Returns a sequential stream of the prefix blocks for the given prefix length.
`Iterator<IPv4Address>`	`prefixIterator()` Iterates through the individual prefixes.
`Iterator<IPv4Address>`	`prefixIterator(int prefixLength)` Iterates through the range of prefixes in this range instance using the given prefix length.
`AddressComponentSpliterator<IPv4Address>`	`prefixSpliterator()` Partitions and traverses through the individual prefixes for the prefix length of this series.
`AddressComponentSpliterator<IPv4Address>`	`prefixSpliterator(int prefixLength)` Partitions and traverses through the individual prefixes for the given prefix length.
`Stream<IPv4Address>`	`prefixStream()` Returns a sequential stream of the individual prefixes for the prefix length of this series.
`Stream<IPv4Address>`	`prefixStream(int prefixLength)` Returns a sequential stream of the individual prefixes for the given prefix length.
`IPv4Address`	`removePrefixLength()` Deprecated.
`IPv4Address`	`removePrefixLength(boolean zeroed)` Deprecated.
`IPv4Address`	`replace(int startIndex, int endIndex, IPv4Address 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
`IPv4Address`	`replace(int startIndex, IPv4AddressSection replacement)` Replaces segments starting from startIndex with as many segments as possible from the replacement section
`IPv4Address`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`IPv4Address`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`IPv4Address`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`IPv4Address`	`reverseSegments()` Returns a new segment series with the segments reversed.
`Iterator<IPv4AddressSegment[]>`	`segmentsIterator()` Iterates through the individual segments.
`Iterator<IPv4AddressSegment[]>`	`segmentsNonZeroHostIterator()` Similar to the segments iterator, but series with a host of zero are skipped.
`AddressComponentRangeSpliterator<IPv4Address,IPv4AddressSegment[]>`	`segmentsSpliterator()` Partitions and traverses through the individual segment arrays.
`Stream<IPv4AddressSegment[]>`	`segmentsStream()` Returns a sequential stream of the individual segment arrays.
`Iterator<IPv4Address>`	`sequentialBlockIterator()` Iterates through the sequential series that make up this series.
`AddressComponentSpliterator<IPv4Address>`	`sequentialBlockSpliterator()` Partitions and traverses through the individual sequential blocks.
`Stream<IPv4Address>`	`sequentialBlockStream()` Returns a sequential stream of the individual sequential blocks.
`IPv4Address`	`setPrefixLength(int prefixLength)` Sets the prefix length.
`IPv4Address`	`setPrefixLength(int prefixLength, boolean zeroed)` Sets the prefix length.
`IPv4Address`	`setPrefixLength(int prefixLength, boolean zeroed, boolean zeroHostIsBlock)` Sets the prefix length while allowing the caller to control whether bits moved in or out of the prefix become zero, and whether a zero host for the new prefix bits can be translated into a prefix block.
`IPv4Address[]`	`spanWithPrefixBlocks()` Produces an array of prefix blocks that cover the same set of addresses as this.
`IPv4Address[]`	`spanWithPrefixBlocks(IPAddress other)` Produces the list of prefix block subnets that span from this subnet to the given subnet.
`IPv4AddressSeqRange`	`spanWithRange(IPAddress other)` Produces an IPAddressRange instance that spans this subnet to the given subnet.
`IPv4Address[]`	`spanWithSequentialBlocks()` Produces an array of blocks that are sequential that cover the same set of addresses as this.
`IPv4Address[]`	`spanWithSequentialBlocks(IPAddress other)` Produces a list of sequential block subnets that span all values from this subnet to the given subnet.
`AddressComponentSpliterator<IPv4Address>`	`spliterator()` Partitions and traverses through the individual address components.
`Stream<IPv4Address>`	`stream()` Returns a sequential stream of the individual address components.
`IPv4Address[]`	`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()`
`IPv4Address`	`toBroadcastAddress()` The broadcast address has the same prefix but a host that is all 1 bits.
`Inet4Address`	`toInetAddress()` Converts the lowest value of this address to an InetAddress
`String`	`toInetAtonString(IPv4Address.inet_aton_radix radix)` Returns a string like the inet_aton style string
`String`	`toInetAtonString(IPv4Address.inet_aton_radix radix, int joinedCount)`
`IPv4Address`	`toIPv4()` If this address is IPv4, or can be converted to IPv4, returns that `IPv4Address`.
`IPv6Address`	`toIPv6()` Returns this address converted to IPv6.
`IPv4Address`	`toMaxHost()` Returns the segment series with a host of all ones.
`IPv4Address`	`toMaxHost(int prefixLength)` Produces the series with host values of all one bits for the given prefix length.
`IPv4Address`	`toNetworkAddress()` The network address has the same prefix but a zero host.
`static String`	`toNormalizedString(IPv4AddressNetwork network, Address.SegmentValueProvider lowerValueProvider, Address.SegmentValueProvider upperValueProvider, Integer prefixLength)` Creates the normalized string for an address without having to create the address objects first.
`IPv4Address`	`toPrefixBlock()` Returns the subnet associated with the prefix length of this address.
`IPv4Address`	`toPrefixBlock(int networkPrefixLength)` Returns the segment series of the same length that spans all hosts.
`String`	`toSegmentedBinaryString()` Writes this IP address segment series as a segments of binary values preceded by the "0b" prefix.
`IPv4AddressSeqRange`	`toSequentialRange()` Creates a sequential range instance from the lowest and highest addresses in this subnet
`IPv4AddressSeqRange`	`toSequentialRange(IPAddress other)` Deprecated.
`IPAddressPartStringCollection`	`toStandardStringCollection()`
`IPAddressPartStringCollection`	`toStringCollection(IPAddressSection.IPStringBuilderOptions opts)`
`IPAddressPartStringCollection`	`toStringCollection(IPv4AddressSection.IPv4StringBuilderOptions opts)`
`String`	`toUNCHostName()` Generates the Microsoft UNC path component for this address
`Inet4Address`	`toUpperInetAddress()` Converts the highest value of this address to an InetAddress.
`IPv4Address`	`toZeroHost()` Returns the segment series with a host of zero, the host being the bits following the prefix length.
`IPv4Address`	`toZeroHost(int prefixLength)` Produces the series with host values of 0 for the given prefix length.
`IPv4Address`	`toZeroNetwork()` Returns the segment series with a network of zero, the network being the bits within the prefix length.
`int`	`upperIntValue()` Returns the address (or highest value of the address if a subnet) as a signed integer
`long`	`upperLongValue()` Returns the address (or highest value of the address if a subnet) as a positive integer
`IPv4Address`	`withoutPrefixLength()` Provides the same address with no prefix.

Methods inherited from class inet.ipaddr.IPAddress
applyToBounds, contains, contains, containsNonZeroHosts, getBitCount, getBitsPerSegment, getBlockMaskPrefixLength, getByteCount, getBytesPerSegment, getIPVersion, getLeadingBitCount, getMatchesSQLClause, getMatchesSQLClause, getMaxSegmentValue, getNetworkPrefixLength, getNonZeroHostCount, getSegmentCount, getSequentialBlockCount, getTrailingBitCount, includesMaxHost, includesMaxHost, includesZeroHost, includesZeroHost, isAnyLocal, isIPAddress, isIPv6, isSingleNetwork, isUnspecified, isZeroHost, isZeroHost, matches, matchesWithMask, mergeToDualPrefixBlocks, mergeToDualSequentialBlocks, overlaps, overlaps, prefixContains, removeBitCountPrefixLength, toAddressString, toAllStrings, toBinaryString, toCanonicalHostName, toCanonicalWildcardString, toCompressedWildcardString, toConvertedString, toDelimitedSQLStrs, toFullString, toHostName, toIPAddress, toNormalizedString, toNormalizedString, toNormalizedString, toNormalizedWildcardString, toOctalString, toPrefixLengthString, toReverseDNSLookupString, toSQLWildcardString, toStandardStrings, toStrings, toSubnetString

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

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface inet.ipaddr.IPAddressSegmentSeries
getPrefixLenComparator

Methods inherited from interface inet.ipaddr.format.string.IPAddressStringDivisionSeries
getPrefixLength, isPrefixBlock, isPrefixed

Methods inherited from interface inet.ipaddr.AddressSegmentSeries
getSegments, getSegments, getSegmentStrings, isOneBit, testBit, toCanonicalString, toCompressedString

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getBlockCount, getCount, getDivisionStrings, getPrefixCount, getPrefixCount, getPrefixLength, getSequentialBlockIndex, isMore, isPrefixBlock, isPrefixed, isSequential, isSinglePrefixBlock

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

Methods inherited from interface inet.ipaddr.AddressComponent
toHexString, toNormalizedString

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

Methods inherited from interface inet.ipaddr.format.AddressItem
compareTo, containsPrefixBlock, containsSinglePrefixBlock, getBitsForCount, getBlockSize, getBytes, getBytes, getBytes, getMinPrefixLengthForBlock, getPrefixLengthForSingleBlock, getUpperBytes, getUpperBytes, getUpperBytes, getUpperValue, getValue, includesMax, includesZero, isFullRange, isMax, isMultiple, isZero

Methods inherited from interface inet.ipaddr.format.IPAddressRange
isSequential, toCanonicalString, toNormalizedString

- Field Detail
  - SEGMENT_SEPARATOR
```
public static final char SEGMENT_SEPARATOR
```
    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
  - 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
  - MAX_VALUE
```
public static final int MAX_VALUE
```
    See Also:
    
    Constant Field Values
  - REVERSE_DNS_SUFFIX
```
public static final String REVERSE_DNS_SUFFIX
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - IPv4Address
```
public IPv4Address(IPv4AddressSegment[] segments)
            throws AddressValueException
```
    Constructs an IPv4 address or subnet.
    
    Parameters:
    
    segments - the address segments
    
    Throws:
    
    AddressValueException - if segments is not length 4
  - IPv4Address
```
public IPv4Address(IPv4AddressSegment[] segments,
                   Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv4 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:
    
    segments - the address segments
    
    networkPrefixLength -
    
    Throws:
    
    AddressValueException - if segments is not length 4
  - IPv4Address
```
public IPv4Address(IPv4AddressSection section)
            throws AddressValueException
```
    Constructs an IPv4 address or subnet.
    
    Parameters:
    
    section - the address segments
    
    Throws:
    
    AddressValueException - if section does not have 4 segments
  - IPv4Address
```
public IPv4Address(int address)
```
    Constructs an IPv4 address.
    
    Parameters:
    
    address - the 4 byte IPv4 address
  - IPv4Address
```
public IPv4Address(int address,
                   Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv4 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:
    
    address - the 4 byte IPv4 address
    
    networkPrefixLength - the CIDR network prefix length, which can be null for no prefix
    
    Throws:
    
    AddressValueException
  - IPv4Address
```
public IPv4Address(Inet4Address inet4Address,
                   Integer networkPrefixLength)
```
    Constructs an IPv4 address.
    
    Parameters:
    
    inet4Address - the java.net address object
  - IPv4Address
```
public IPv4Address(Inet4Address inet4Address)
```
    Constructs an IPv4 address.
    
    Parameters:
    
    inet4Address - the java.net address object
  - IPv4Address
```
public IPv4Address(byte[] bytes)
            throws AddressValueException
```
    Constructs an IPv4 address.
    
    Parameters:
    
    bytes - the 4 byte IPv4 address in network byte order - if longer than 4 bytes the additional bytes must be zero, if shorter than 4 bytes then then the bytes are sign-extended to 4 bytes.
    
    Throws:
    
    AddressValueException - if bytes not equivalent to a 4 byte address
  - IPv4Address
```
public IPv4Address(byte[] bytes,
                   int byteStartIndex,
                   int byteEndIndex)
            throws AddressValueException
```
    Constructs an IPv4 address or subnet.
    Similar to IPv4Address(byte[]) except that you can specify the start and end of the address in the given byte array.
    
    Parameters:
    
    bytes -
    
    Throws:
    
    AddressValueException
  - IPv4Address
```
public IPv4Address(byte[] bytes,
                   Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv4 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:
    
    bytes - the 4 byte IPv4 address in network byte order - if longer than 4 bytes the additional bytes must be zero, if shorter than 4 bytes then the bytes are sign-extended to 4 bytes.
    
    networkPrefixLength - the CIDR network prefix length, which can be null for no prefix
    
    Throws:
    
    AddressValueException - if bytes not equivalent to a 4 byte address
  - IPv4Address
```
public IPv4Address(byte[] bytes,
                   int byteStartIndex,
                   int byteEndIndex,
                   Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv4 address or subnet.
    Similar to IPv4Address(byte[],Integer) except that you can specify the start and end of the address in the given byte array.
    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 4 byte IPv4 address - if longer than 4 bytes the additional bytes must be zero, if shorter than 4 bytes then the bytes are sign-extended to 4 bytes.
    
    networkPrefixLength - the CIDR network prefix length, which can be null for no prefix
    
    Throws:
    
    AddressValueException - if bytes not equivalent to a 4 byte address
  - IPv4Address
```
public IPv4Address(Address.SegmentValueProvider lowerValueProvider,
                   Address.SegmentValueProvider upperValueProvider,
                   Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv4 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 1 byte lower values for each segment
    
    upperValueProvider - supplies the 1 byte upper values for each segment
    
    networkPrefixLength - the CIDR network prefix length, which can be null for no prefix
    
    Throws:
    
    AddressValueException
  - IPv4Address
```
public IPv4Address(Address.SegmentValueProvider lowerValueProvider,
                   Address.SegmentValueProvider upperValueProvider)
```
    Constructs an IPv4 address or subnet.
    
    Parameters:
    
    lowerValueProvider - supplies the 1 byte lower values for each segment
    
    upperValueProvider - supplies the 1 byte upper values for each segment
  - IPv4Address
```
public IPv4Address(Address.SegmentValueProvider valueProvider,
                   Integer networkPrefixLength)
            throws AddressValueException
```
    Constructs an IPv4 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 1 byte value for each segment
    
    networkPrefixLength - the CIDR network prefix length, which can be null for no prefix
    
    Throws:
    
    AddressValueException
  - IPv4Address
```
public IPv4Address(Address.SegmentValueProvider valueProvider)
```
    Constructs an IPv4 address.
    
    Parameters:
    
    valueProvider - supplies the 1 byte value for each segment
- Method Detail
  - getSection
```
public IPv4AddressSection 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 IPv4AddressSection getSection(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index The first segment is at index 0.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Overrides:
    
    getSection in class IPAddress
    
    Returns:
  - getSection
```
public IPv4AddressSection 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 The first segment is at index 0.
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Specified by:
    
    getSection in interface IPAddressSegmentSeries
    
    Overrides:
    
    getSection in class IPAddress
    
    Returns:
  - getDivision
```
public IPv4AddressSegment getDivision(int index)
```
    Specified by:
    
    getDivision in interface AddressDivisionSeries
    
    Specified by:
    
    getDivision in interface IPAddressDivisionSeries
    
    Specified by:
    
    getDivision in interface AddressStringDivisionSeries
    
    Specified by:
    
    getDivision in interface IPAddressStringDivisionSeries
    
    Returns:
    
    the given division in this series. The first is at index 0.
  - getSegment
```
public IPv4AddressSegment getSegment(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Returns the segment from this series at the given index. The first segment is at index 0. A segment is an address division, see AddressDivisionSeries.getDivision(int), the difference being that all segments in a given series are the same bit count, while divisions can have variable length.
    
    Specified by:
    
    getSegment in interface AddressSegmentSeries
    
    Specified by:
    
    getSegment in interface IPAddressSegmentSeries
    
    Returns:
  - getSegments
```
public IPv4AddressSegment[] 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:
  - 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(IPv4AddressSection.IPv4StringBuilderOptions 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: 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
    
    Overrides:
    
    getByteCount in class IPAddress
    
    Returns:
    
    the number of bytes
  - 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
    
    Overrides:
    
    getBitCount in class Address
    
    Returns:
    
    the number of bits
  - isIPv4
```
public boolean isIPv4()
```
    Overrides:
    
    isIPv4 in class IPAddress
  - toIPv4
```
public IPv4Address toIPv4()
```
    Description copied from class: IPAddress
    
    If this address is IPv4, or can be converted to IPv4, returns that IPv4Address. Otherwise, returns null.
    
    Overrides:
    
    toIPv4 in class IPAddress
    
    Returns:
    
    the address
    
    See Also:
    
    IPAddress.isIPv4Convertible()
  - isIPv4Convertible
```
public boolean isIPv4Convertible()
```
    Description copied from class: IPAddress
    
    Determines whether this address can be converted to IPv4, if not IPv4 already. Override this method to convert in your own way. If IPv6, the default behaviour is to convert by IPv4 mapping, see IPv6Address.isIPv4Mapped() You should also override IPAddress.toIPv4() to match the conversion. This method returns true for all IPv4 addresses.
    
    Specified by:
    
    isIPv4Convertible in class IPAddress
    
    Returns:
  - getIPv6Address
```
public IPv6Address getIPv6Address(IPv6AddressSegment[] segs)
```
    Create an IPv6 mixed address using the given ipv6 segments and using this address for the embedded IPv4 segments
    
    Parameters:
    
    segs -
    
    Returns:
  - getIPv4MappedAddress
```
public IPv6Address getIPv4MappedAddress()
```
  - isIPv6Convertible
```
public boolean isIPv6Convertible()
```
    Override this method to convert in your own way. The default behaviour uses IPv4-mapped conversion. You should also override toIPv6() to match the conversion.
    
    Specified by:
    
    isIPv6Convertible in class IPAddress
    
    Returns:
    
    See Also:
    
    toIPv6()
  - toIPv6
```
public IPv6Address toIPv6()
```
    Returns this address converted to IPv6.
    You can also use isIPv6Convertible() to determine convertibility. Both use an instance of IPAddressConverter.DefaultAddressConverter which uses IPv4-mapped address mappings from rfc 4038.
    Override this method and IPv6Address.isIPv6Convertible() if you wish to map IPv4 to IPv6 according to the mappings defined by in IPv6Address.isIPv4Compatible(), IPv6Address.isIPv4Mapped(), IPv6Address.is6To4() or some other mapping.
    If you override this method, you should also override the isIPv6Convertible() method to match this behaviour, and potentially also override the reverse conversion IPv6Address.toIPv4() in your IPv6Address subclass.
    
    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()
  - toBroadcastAddress
```
public IPv4Address toBroadcastAddress()
```
    The broadcast address has the same prefix but a host that is all 1 bits. If this address or subnet is not prefixed, this returns the address of all 1 bits, the "max" address.
    
    Returns:
  - toNetworkAddress
```
public IPv4Address toNetworkAddress()
```
    The network address has the same prefix but a zero host. If this address or subnet is not prefixed, this returns the zero "any" address.
    
    Returns:
  - getLowerNonZeroHost
```
public IPv4Address 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 IPv4Address 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
    
    Specified by:
    
    getLower in interface IPAddressRange
    
    Specified by:
    
    getLower in interface IPAddressSegmentSeries
    
    Specified by:
    
    getLower in class IPAddress
    
    Returns:
  - getUpper
```
public IPv4Address 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
    
    Specified by:
    
    getUpper in interface IPAddressRange
    
    Specified by:
    
    getUpper in interface IPAddressSegmentSeries
    
    Specified by:
    
    getUpper in class IPAddress
    
    Returns:
  - intValue
```
public int intValue()
```
    Returns the address (or lowest value of the address if a subnet) as a signed integer
    
    Returns:
    
    the signed integer lower address value
  - upperIntValue
```
public int upperIntValue()
```
    Returns the address (or highest value of the address if a subnet) as a signed integer
    
    Returns:
    
    the signed integer upper address value
  - longValue
```
public long longValue()
```
    Returns the address (or lowest value of the address if a subnet) as a positive integer
    
    Returns:
    
    the positive integer lower address value
  - upperLongValue
```
public long upperLongValue()
```
    Returns the address (or highest value of the address if a subnet) as a positive integer
    
    Returns:
    
    the positive integer upper address value
  - replace
```
public IPv4Address replace(int startIndex,
                           int endIndex,
                           IPv4Address 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:
    
    IndexOutOfBoundsException
  - replace
```
public IPv4Address replace(int startIndex,
                           IPv4AddressSection replacement)
```
    Replaces segments starting from startIndex with as many segments as possible from the replacement section
    
    Parameters:
    
    startIndex -
    
    replacement -
    
    Returns:
    
    Throws:
    
    IndexOutOfBoundsException
  - reverseBits
```
public IPv4Address 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 IPv4Address 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 IPv4Address 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 IPv4Address 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:
  - adjustPrefixBySegment
```
public IPv4Address 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
    
    Specified by:
    
    adjustPrefixBySegment in interface IPAddressSegmentSeries
    
    Specified by:
    
    adjustPrefixBySegment in class IPAddress
    
    Parameters:
    
    nextSegment - whether to move prefix to previous or following segment boundary
    
    Returns:
  - adjustPrefixBySegment
```
public IPv4Address 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 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 IPv4Address 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 IPv4Address 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 IPv4Address 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
    
    Specified by:
    
    setPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    setPrefixLength in class IPAddress
    
    Returns:
  - setPrefixLength
```
public IPv4Address 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
    
    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:
  - setPrefixLength
```
public IPv4Address setPrefixLength(int prefixLength,
                                   boolean zeroed,
                                   boolean zeroHostIsBlock)
                            throws PrefixLenException
```
    Description copied from class: IPAddress
    
    Sets the prefix length while allowing the caller to control whether bits moved in or out of the prefix become zero, and whether a zero host for the new prefix bits can be translated into a prefix block. The latter behaviour only applies to the default prefix handling configuration, PREFIXED_ZERO_HOSTS_ARE_SUBNETS. The methods IPAddress.setPrefixLength(int, boolean) and IPAddress.setPrefixLength(int) use a value of true for zeroed and for zeroHostIsBlock.
    For example, when zeroHostIsBlock is true, applying to 1.2.0.0 the prefix length 16 results in 1.2.*.*/16
    Or if you start with 1.2.0.0/24, setting the prefix length to 16 results in a zero host followed by the existing prefix block, which is then converted to a full prefix block, 1.2.*.*/16
    When both zeroed and zeroHostIsBlock are true, applying the prefiix length of 16 to 1.2.4.0/24 also results in a zero host followed by the existing prefix block, which is then converted to a full prefix block, 1.2.*.*/16.
    When both zeroed and zeroHostIsBlock are false, the resulting address always encompasses the same set of addresses as the original, albeit with a different prefix length.
    
    Specified by:
    
    setPrefixLength in class IPAddress
    
    Returns:
    
    Throws:
    
    PrefixLenException
  - applyPrefixLength
```
@Deprecated
public IPv4Address applyPrefixLength(int networkPrefixLength)
                                          throws PrefixLenException
```
    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
    
    Specified by:
    
    applyPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    applyPrefixLength in class IPAddress
    
    Returns:
    
    Throws:
    
    PrefixLenException
    
    See Also:
    
    AddressSegmentSeries.setPrefixLength(int)
  - removePrefixLength
```
@Deprecated
public IPv4Address 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
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in class IPAddress
    
    Parameters:
    
    zeroed - whether the bits outside the prefix become zero
    
    Returns:
  - withoutPrefixLength
```
public IPv4Address 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
    
    Specified by:
    
    withoutPrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    withoutPrefixLength in class IPAddress
  - removePrefixLength
```
@Deprecated
public IPv4Address 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
    
    Specified by:
    
    removePrefixLength in interface IPAddressSegmentSeries
    
    Specified by:
    
    removePrefixLength in class IPAddress
    
    Returns:
    
    See Also:
    
    for an alternative which does not change the address series values.
  - segmentsNonZeroHostIterator
```
public Iterator<IPv4AddressSegment[]> segmentsNonZeroHostIterator()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Similar to the segments iterator, but series with a host of zero are skipped.
    
    Specified by:
    
    segmentsNonZeroHostIterator in interface IPAddressSegmentSeries
    
    Returns:
  - segmentsIterator
```
public Iterator<IPv4AddressSegment[]> segmentsIterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Iterates through the individual segments.
    
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
    
    Specified by:
    
    segmentsIterator in interface IPAddressSegmentSeries
  - segmentsSpliterator
```
public AddressComponentRangeSpliterator<IPv4Address,IPv4AddressSegment[]> segmentsSpliterator()
```
    Description copied from interface: AddressSegmentSeries
    
    Partitions and traverses through the individual segment arrays.
    
    Specified by:
    
    segmentsSpliterator in interface AddressSegmentSeries
    
    Specified by:
    
    segmentsSpliterator in interface IPAddressSegmentSeries
    
    Returns:
  - segmentsStream
```
public Stream<IPv4AddressSegment[]> segmentsStream()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a sequential stream of the individual segment arrays. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    segmentsStream in interface AddressSegmentSeries
    
    Specified by:
    
    segmentsStream in interface IPAddressSegmentSeries
    
    Returns:
  - iterator
```
public Iterator<IPv4Address> 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
    
    Specified by:
    
    iterator in interface IPAddressRange
    
    Specified by:
    
    iterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    iterator in interface Iterable<IPv4Address>
    
    Specified by:
    
    iterator in class IPAddress
    
    Returns:
  - spliterator
```
public AddressComponentSpliterator<IPv4Address> 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
    
    Specified by:
    
    spliterator in interface IPAddressRange
    
    Specified by:
    
    spliterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    spliterator in interface Iterable<IPv4Address>
    
    Specified by:
    
    spliterator in class IPAddress
    
    Returns:
  - stream
```
public Stream<IPv4Address> 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
    
    Specified by:
    
    stream in interface IPAddressSegmentSeries
    
    Specified by:
    
    stream in class IPAddress
    
    Returns:
  - nonZeroHostIterator
```
public Iterator<IPv4Address> nonZeroHostIterator()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Similar to the iterator, but series with a host of zero are skipped.
    
    Specified by:
    
    nonZeroHostIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    nonZeroHostIterator in class IPAddress
    
    Returns:
  - prefixBlockIterator
```
public Iterator<IPv4Address> 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
  - prefixBlockSpliterator
```
public AddressComponentSpliterator<IPv4Address> 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
    
    Specified by:
    
    prefixBlockSpliterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixBlockSpliterator in class IPAddress
    
    Returns:
  - prefixBlockStream
```
public Stream<IPv4Address> 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
    
    Specified by:
    
    prefixBlockStream in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixBlockStream in class IPAddress
    
    Returns:
  - prefixBlockIterator
```
public Iterator<IPv4Address> prefixBlockIterator(int prefixLength)
```
    Description copied from interface: IPAddressRange
    
    Iterates through the range of prefix blocks in this range instance using the given prefix length.
    
    Specified by:
    
    prefixBlockIterator in interface IPAddressRange
    
    Returns:
  - prefixBlockSpliterator
```
public AddressComponentSpliterator<IPv4Address> prefixBlockSpliterator(int prefixLength)
```
    Description copied from interface: IPAddressRange
    
    Partitions and traverses through the individual prefix blocks for the given prefix length.
    
    Specified by:
    
    prefixBlockSpliterator in interface IPAddressRange
    
    Returns:
  - prefixBlockStream
```
public Stream<IPv4Address> prefixBlockStream(int prefixLength)
```
    Description copied from interface: IPAddressRange
    
    Returns a sequential stream of the prefix blocks for the given prefix length. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixBlockStream in interface IPAddressRange
    
    Returns:
  - prefixIterator
```
public Iterator<IPv4Address> 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
    
    Specified by:
    
    prefixIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixIterator in class IPAddress
  - prefixSpliterator
```
public AddressComponentSpliterator<IPv4Address> 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
    
    Specified by:
    
    prefixSpliterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixSpliterator in class IPAddress
    
    Returns:
  - prefixStream
```
public Stream<IPv4Address> 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
    
    Specified by:
    
    prefixStream in interface IPAddressSegmentSeries
    
    Specified by:
    
    prefixStream in class IPAddress
    
    Returns:
  - prefixIterator
```
public Iterator<IPv4Address> prefixIterator(int prefixLength)
```
    Description copied from interface: IPAddressRange
    
    Iterates through the range of prefixes in this range instance using the given prefix length.
    
    Specified by:
    
    prefixIterator in interface IPAddressRange
    
    Returns:
  - prefixSpliterator
```
public AddressComponentSpliterator<IPv4Address> prefixSpliterator(int prefixLength)
```
    Description copied from interface: IPAddressRange
    
    Partitions and traverses through the individual prefixes for the given prefix length.
    
    Specified by:
    
    prefixSpliterator in interface IPAddressRange
    
    Returns:
  - prefixStream
```
public Stream<IPv4Address> prefixStream(int prefixLength)
```
    Description copied from interface: IPAddressRange
    
    Returns a sequential stream of the individual prefixes for the given prefix length. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    prefixStream in interface IPAddressRange
    
    Returns:
  - blockIterator
```
public Iterator<IPv4Address> blockIterator(int segmentCount)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Iterates through series that can be obtained by iterating through all the upper segments up to the given segment count. Segments following remain the same in all iterated series.
    For instance, given the IPv4 subnet 1-2.3-4.5-6.7, given the count argument 2, it will iterate through 1.3.5-6.7, 1.4.5-6.7, 2.3.5-6.7, 2.4.5-6.7
    
    Specified by:
    
    blockIterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    blockIterator in class IPAddress
    
    Returns:
  - blockSpliterator
```
public AddressComponentSpliterator<IPv4Address> blockSpliterator(int segmentCount)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Partitions and traverses through the individual sequential blocks created from each of the individual values up to the given segment count.
    
    Specified by:
    
    blockSpliterator in interface IPAddressSegmentSeries
    
    Specified by:
    
    blockSpliterator in class IPAddress
    
    Returns:
  - blockStream
```
public Stream<IPv4Address> blockStream(int segmentCount)
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns a sequential stream of the individual blocks created from each of the individual values up to the given segment count. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Specified by:
    
    blockStream in interface IPAddressSegmentSeries
    
    Specified by:
    
    blockStream in class IPAddress
    
    Returns:
  - sequentialBlockIterator
```
public Iterator<IPv4Address> sequentialBlockIterator()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Iterates through the sequential series that make up this series. Generally this means finding the count of segments for which the segments that follow are not full range, and then using IPAddressSegmentSeries.blockIterator(int) with that segment count.
    For instance, given the IPv4 subnet 1-2.3-4.5-6.7-8, it will iterate through 1.3.5.7-8, 1.3.6.7-8, 1.4.5.7-8, 1.4.6.7-8, 2.3.5.7-8, 2.3.6.7-8, 2.4.6.7-8, 2.4.6.7-8.
    Use IPAddressSegmentSeries.getSequentialBlockCount() to get the count of iterated elements.
    
    Specified by:
    
    sequentialBlockIterator in interface IPAddressSegmentSeries
    
    Overrides:
    
    sequentialBlockIterator in class IPAddress
    
    Returns:
  - sequentialBlockSpliterator
```
public AddressComponentSpliterator<IPv4Address> sequentialBlockSpliterator()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Partitions and traverses through the individual sequential blocks.
    
    Specified by:
    
    sequentialBlockSpliterator in interface IPAddressSegmentSeries
    
    Overrides:
    
    sequentialBlockSpliterator in class IPAddress
    
    Returns:
  - sequentialBlockStream
```
public Stream<IPv4Address> sequentialBlockStream()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns a sequential stream of the individual sequential blocks. For a parallel stream, call BaseStream.parallel() on the returned stream.
    Use IPAddressSegmentSeries.getSequentialBlockCount() to get the count of streamed elements.
    
    Specified by:
    
    sequentialBlockStream in interface IPAddressSegmentSeries
    
    Overrides:
    
    sequentialBlockStream in class IPAddress
    
    Returns:
  - getIterable
```
public Iterable<IPv4Address> 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
    
    Specified by:
    
    getIterable in interface IPAddressRange
    
    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 IPv4Address increment(long increment)
```
    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
    
    Specified by:
    
    increment in interface IPAddressSegmentSeries
    
    Specified by:
    
    increment in class IPAddress
    
    Returns:
  - incrementBoundary
```
public IPv4Address incrementBoundary(long increment)
```
    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
    
    Specified by:
    
    incrementBoundary in interface IPAddressSegmentSeries
    
    Specified by:
    
    incrementBoundary in class IPAddress
    
    Returns:
  - enumerateIPv4
```
public Long enumerateIPv4(IPv4Address other)
```
    Indicates where an address sits relative to the subnet ordering.
    Equivalent to enumerate(IPAddress) but returns a Long rather than a BigInteger.
  - enumerate
```
public BigInteger enumerate(Address other)
```
    Description copied from class: Address
    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.
    Specified by:
    
    enumerate in class Address
  - enumerate
```
public BigInteger enumerate(IPAddress other)
```
    Description copied from class: IPAddress
    
    Indicates where an address sits relative to the subnet ordering.
    For more details, see the equivalent method Address.enumerate(Address). This method satisfies the implementation of IPAddressRange.
    
    Specified by:
    
    enumerate in interface IPAddressRange
    
    Specified by:
    
    enumerate in class IPAddress
    
    Returns:
  - getNetwork
```
public IPv4AddressNetwork getNetwork()
```
    Description copied from interface: AddressComponent
    
    Returns the network object for components of the same version (eg IPv4, IPv6 and MAC each have their own network object)
    
    Specified by:
    
    getNetwork in interface AddressComponent
    
    Specified by:
    
    getNetwork in interface IPAddressStringDivisionSeries
    
    Specified by:
    
    getNetwork in interface IPAddressSegmentSeries
    
    Specified by:
    
    getNetwork in class IPAddress
  - getIPv6Network
```
public IPv6AddressNetwork getIPv6Network()
```
    Returns the IPv6 network used by getIPv4MappedAddress() and getIPv6Address(IPv6AddressSegment[])
    
    Returns:
  - intersect
```
public IPv4Address 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, or null if no such addresses.
    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 IPv4Address[] 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
  - toZeroHost
```
public IPv4Address toZeroHost()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the segment series with a host of zero, the host being the bits following the prefix length. If the series has no prefix length, then it returns an all-zero series.
    The default behaviour is that the resultant series will have the same prefix length. The resultant series will not have a prefix length if AddressNetwork.getPrefixConfiguration() is AddressNetwork.PrefixConfiguration.ALL_PREFIXED_ADDRESSES_ARE_SUBNETS.
    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:
    
    See Also:
    
    IPAddressSegmentSeries.toZeroNetwork()
  - toZeroHost
```
public IPv4Address 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:
  - toZeroNetwork
```
public IPv4Address toZeroNetwork()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the segment series with a network of zero, the network being the bits within the prefix length. If the series has no prefix length, then it returns an all-zero series.
    The default behaviour is that the resultant series will have the same prefix length. The resultant series will not have a prefix length if AddressNetwork.getPrefixConfiguration() is AddressNetwork.PrefixConfiguration.ALL_PREFIXED_ADDRESSES_ARE_SUBNETS.
    
    Specified by:
    
    toZeroNetwork in interface IPAddressSegmentSeries
    
    Specified by:
    
    toZeroNetwork in class IPAddress
    
    Returns:
    
    See Also:
    
    IPAddressSegmentSeries.toZeroHost()
  - toMaxHost
```
public IPv4Address 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 IPv4Address 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 IPv4Address 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 to the other address 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 IPv4Address 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 to the other address 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 IPv4Address 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 to the other address 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 IPv4Address 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 to the other address first using IPAddress.toIPv4() or IPAddress.toIPv6()
    If you wish to mask a section 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 IPv4Address 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 to the other address 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 IPv4Address 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 to the other address 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
  - getHostMask
```
public IPv4Address getHostMask()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the host mask associated with the CIDR network prefix length of this series. If this series has no prefix length, then the whole series is considered a host and the all ones host mask is returned.
    
    Specified by:
    
    getHostMask in interface IPAddressSegmentSeries
    
    Overrides:
    
    getHostMask in class IPAddress
    
    Returns:
  - getNetworkMask
```
public IPv4Address getNetworkMask()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the network mask associated with the CIDR network prefix length of this series. If this series has no prefix length, then the whole series is considered network and the all ones network mask is returned.
    
    Specified by:
    
    getNetworkMask in interface IPAddressSegmentSeries
    
    Overrides:
    
    getNetworkMask in class IPAddress
    
    Returns:
  - getNetworkSection
```
public IPv4AddressSection 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 IPv4AddressSection 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 IPv4AddressSection 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 IPv4AddressSection 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:
  - getHostSection
```
public IPv4AddressSection 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
  - toPrefixBlock
```
public IPv4Address 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 IPv4Address 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 IPv4Address 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 IPv4Address 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()
  - coverWithPrefixBlock
```
public IPv4Address coverWithPrefixBlock()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Returns the minimal-size prefix block that covers all the values in this series. The resulting block will have a larger series count than this, unless this series is already a prefix block.
    
    Specified by:
    
    coverWithPrefixBlock in interface IPAddressRange
    
    Specified by:
    
    coverWithPrefixBlock in interface IPAddressSegmentSeries
  - coverWithPrefixBlock
```
public IPv4Address coverWithPrefixBlock(IPAddress other)
                                 throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Returns the minimal-size prefix block that covers all the addresses spanning from this subnet to the given subnet.
    If the other address is a different version than this, then the default conversion is applied to the other address first using IPAddress.toIPv4() or IPAddress.toIPv6()
    When you have multiple subnets, cover with:
    IPAddress block = subnet0.applyToBounds(IPAddress::coverWithPrefixBlock, subnet1, subnet2, ...);
    See IPAddress.applyToBounds(java.util.function.BiFunction, IPAddress...)
    
    Specified by:
    
    coverWithPrefixBlock in class IPAddress
    
    Throws:
    
    AddressConversionException
  - spanWithPrefixBlocks
```
public IPv4Address[] spanWithPrefixBlocks()
```
    Produces an array of prefix blocks that cover the same set of addresses as this.
    Unlike spanWithPrefixBlocks(IPAddress) this method only includes addresses that are a part of this subnet.
    
    Specified by:
    
    spanWithPrefixBlocks in interface IPAddressRange
    
    Specified by:
    
    spanWithPrefixBlocks in interface IPAddressSegmentSeries
  - spanWithPrefixBlocks
```
public IPv4Address[] spanWithPrefixBlocks(IPAddress other)
                                   throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Produces the list of prefix block subnets that span from this subnet to the given subnet.
    If the other address is a different version than this, then the default conversion is applied to the other address 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.
    From the list of returned subnets you can recover the original range (this to other) by converting each to IPAddressRange with IPAddress.toSequentialRange() and them joining them into a single range with IPAddressSeqRange.join(IPAddressSeqRange...)
    When you have multiple subnets, span with:
    IPAddress blocks[] = subnet0.applyToBounds(IPAddress::spanWithPrefixBlocks, subnet1, subnet2, ...);
    See IPAddress.applyToBounds(java.util.function.BiFunction, IPAddress...)
    
    Specified by:
    
    spanWithPrefixBlocks in class IPAddress
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - spanWithSequentialBlocks
```
public IPv4Address[] spanWithSequentialBlocks()
                                       throws AddressConversionException
```
    Produces an array of blocks that are sequential that cover the same set of addresses as this.
    This array can be shorter than that produced by spanWithPrefixBlocks() and is never longer.
    Unlike spanWithSequentialBlocks(IPAddress) this method only includes addresses that are a part of this subnet.
    
    Specified by:
    
    spanWithSequentialBlocks in interface IPAddressRange
    
    Specified by:
    
    spanWithSequentialBlocks in interface IPAddressSegmentSeries
    
    Throws:
    
    AddressConversionException
  - spanWithSequentialBlocks
```
public IPv4Address[] spanWithSequentialBlocks(IPAddress other)
                                       throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Produces a list of sequential block subnets that span all values from this subnet to the given subnet. The span will cover the sequence of all addresses from the lowest address in both subnets to the highest address in both subnets.
    Individual block subnets come in the form 1-3.1-4.5.6-8, however that particular subnet is not sequential since address 1.1.5.8 is in the subnet, the next sequential address 1.1.5.9 is not in the subnet, and a higher address 1.2.5.6 is in the subnet. Blocks are sequential when the first segment with a range of values is followed by segments that span all values.
    If the other address is a different version than this, then the default conversion is applied to the other address 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.
    From the list of returned subnets you can recover the original range (this and other) by converting each to IPAddressRange with IPAddress.toSequentialRange() and them joining them into a single range with IPAddressSeqRange.join(IPAddressSeqRange...)
    When you have multiple subnets, span with:
    IPAddress blocks[] = subnet0.applyToBounds(IPAddress::spanWithSequentialBlocks, subnet1, subnet2, ...);
    See IPAddress.applyToBounds(java.util.function.BiFunction, IPAddress...)
    
    Specified by:
    
    spanWithSequentialBlocks in class IPAddress
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - spanWithRange
```
public IPv4AddressSeqRange spanWithRange(IPAddress other)
                                  throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Produces an IPAddressRange instance that spans this subnet to the given subnet.
    If the other address is a different version than this, then the default conversion is applied to the other address first using IPAddress.toIPv4() or IPAddress.toIPv6()
    When you have multiple subnets, span with:
    IPAddressSeqRange range = subnet0.applyToBounds(IPAddress::spanWithRange, subnet1, subnet2, ...);
    See IPAddress.applyToBounds(java.util.function.BiFunction, IPAddress...)
    
    Specified by:
    
    spanWithRange in class IPAddress
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - mergeToPrefixBlocks
```
public IPv4Address[] mergeToPrefixBlocks(IPAddress... addresses)
                                  throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Merges this with the list of addresses to produce the smallest list of prefix blocks.
    For the smallest list of subnets use IPAddress.mergeToSequentialBlocks(IPAddress...).
    If any other address in the list is a different version than this, then the default conversion is applied to the other address first using IPAddress.toIPv4() or IPAddress.toIPv6(), which can result in AddressConversionException
    The resulting array is sorted from lowest address value to highest, regardless of the size of each prefix block.
    In version 5.3.1 and earlier, the result was sorted from single address to smallest blocks to largest blocks. For that ordering, sort with IPAddressSegmentSeries.getPrefixLenComparator():
    Arrays.sort(result, IPAddressSegmentSeries.getPrefixLenComparator());
    The merging process works with sequential blocks. CIDR prefix subnets have just a single sequential block, as does individual addresses. So this method works efficiently for most conventionally-used subnets.
    For example, the subnet ::*:*:*:1-ffff has 281474976710656 sequential blocks. Just like you should avoid iterating through such a large number of blocks, you should avoid using this method to merge such a subnet, rather than a subnet like ::1-ffff:*:*:*:* which has 1 sequential block, or the subnet ::1-ffff:1-ffff:*:*:*:* which has 65535 sequential blocks. You can use IPAddress.getSequentialBlockCount() to get the sequential block count.
    There are alternatives ways to merge into prefix blocks available in this library. Typically this method is most efficient when merging CIDR prefix blocks and/or individual addresses, which is likely to be the case for most users most of the time. It converts to CIDR prefix blocks prior to merging, if not CIDR prefix blocks or individual addresses already.
    When merging a large number of blocks that are not prefix blocks nor individual addresses, it may be more efficient to merge first and then convert to CIDR prefix blocks afterwards. You can use IPAddress.mergeToSequentialBlocks(IPAddress...) to merge, and then span each merged element in the result with IPAddressSegmentSeries.spanWithPrefixBlocks(), giving the same result as this method.
    Sequential ranges provide another option. You can convert to sequential blocks first with IPAddress.sequentialBlockIterator(), then convert each sequential block to IPAddressSeqRange with IPAddress.toSequentialRange(), then join those sequential ranges with IPAddressSeqRange.join(IPAddressSeqRange...), then convert them to CIDR prefix blocks with IPAddressSeqRange.spanWithPrefixBlocks(), giving the same result as this method.
    
    Specified by:
    
    mergeToPrefixBlocks in class IPAddress
    
    Parameters:
    
    addresses - the addresses to merge with this
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - mergeToSequentialBlocks
```
public IPv4Address[] mergeToSequentialBlocks(IPAddress... addresses)
                                      throws AddressConversionException
```
    Description copied from class: IPAddress
    
    Merges this with the list of subnets to produce the smallest list of block subnets that are sequential.
    Block subnets come in the form 1-3.1-4.5.6-8, however that subnet is not sequential since address 1.1.5.8 is in the subnet, the next sequential address 1.1.5.9 is not in the subnet, and a higher address 1.2.5.6 is in the subnet. Blocks are sequential when the first segment with a range of values is followed by segments that span all values.
    This list will eliminate overlaps to produce the smallest list of sequential block subnets, which is the same size or smaller than the list of prefix blocks produced by IPAddress.mergeToPrefixBlocks(IPAddress...)
    If the incoming blocks are not sequential, the result could be a longer list, since the list is divided into sequential blocks before merging.
    If any other address in the list is a different version than this, then the default conversion is applied to the other address first using IPAddress.toIPv4() or IPAddress.toIPv6(), which can result in AddressConversionException
    The resulting array is sorted by lower address, regardless of the size of each prefix block.
    In version 5.3.1 and earlier, the result was sorted from single address to smallest blocks to largest blocks. For that ordering, sort with IPAddressSegmentSeries.getPrefixLenComparator():
    Arrays.sort(result, IPAddressSegmentSeries.getPrefixLenComparator());
    See the javadoc for IPAddress.mergeToPrefixBlocks(IPAddress...) for some alternatives for merging subnets.
    
    Specified by:
    
    mergeToSequentialBlocks in class IPAddress
    
    Parameters:
    
    addresses - the addresses to merge with this
    
    Returns:
    
    Throws:
    
    AddressConversionException
  - toUpperInetAddress
```
public Inet4Address 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
  - toInetAddress
```
public Inet4Address toInetAddress()
```
    Description copied from class: IPAddress
    
    Converts the lowest value of this address to an InetAddress
    
    Overrides:
    
    toInetAddress in class IPAddress
  - toSequentialRange
```
@Deprecated
public IPv4AddressSeqRange toSequentialRange(IPAddress other)
```
    Deprecated.
    
    Description copied from class: IPAddress
    
    Creates a sequential range instance from this and the given address, spanning from the lowest to the highest addresses in the two subnets
    If the other address is a different version than this, then the default conversion is applied to the other address first using IPAddress.toIPv4() or IPAddress.toIPv6()
    When you have multiple subnets, create a range from lowest to highest with:
    IPAddressSeqRange range = subnet0.applyToBounds(IPAddress::toSequentialRange, subnet1, subnet2, ...);
    See IPAddress.applyToBounds(java.util.function.BiFunction, IPAddress...)
    
    Specified by:
    
    toSequentialRange in class IPAddress
    
    Returns:
  - toSequentialRange
```
public IPv4AddressSeqRange toSequentialRange()
```
    Description copied from class: IPAddress
    
    Creates a sequential range instance from the lowest and highest addresses in this subnet
    The two will represent the same set of individual addresses if and only if Address.isSequential() is true. To get a series of ranges that represent the same set of individual addresses use the IPAddress.sequentialBlockIterator() (or IPAddress.prefixIterator()), and apply this method to each iterated subnet.
    If this represents just a single address then the returned instance covers just that single address as well.
    
    Specified by:
    
    toSequentialRange in interface IPAddressRange
    
    Specified by:
    
    toSequentialRange in class IPAddress
  - 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()
  - isPrivate
```
public boolean isPrivate()
```
    Unicast addresses allocated for private use
    
    See Also:
    
    InetAddress.isSiteLocalAddress()
  - 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()
  - toNormalizedString
```
public static String toNormalizedString(IPv4AddressNetwork network,
                                        Address.SegmentValueProvider lowerValueProvider,
                                        Address.SegmentValueProvider upperValueProvider,
                                        Integer prefixLength)
```
    Creates the normalized string for an address without having to create the address objects first.
    
    Parameters:
    
    lowerValueProvider -
    
    upperValueProvider -
    
    prefixLength -
    
    network - use Address.defaultIpv4Network() if there is no custom network in use
    
    Returns:
  - toInetAtonString
```
public String toInetAtonString(IPv4Address.inet_aton_radix radix)
```
    Returns a string like the inet_aton style string
    
    Returns:
  - toInetAtonString
```
public String toInetAtonString(IPv4Address.inet_aton_radix radix,
                               int joinedCount)
                        throws IncompatibleAddressException
```
    Throws:
    
    IncompatibleAddressException
  - toSegmentedBinaryString
```
public String toSegmentedBinaryString()
```
    Description copied from interface: IPAddressSegmentSeries
    
    Writes this IP address segment series as a segments of binary values preceded by the "0b" prefix.
    
    Specified by:
    
    toSegmentedBinaryString in interface IPAddressSegmentSeries
  - toUNCHostName
```
public 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(IPv4AddressSection.IPv4StringBuilderOptions opts)
```

Class IPv4Address

Nested Class Summary

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

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

Field Summary

Fields inherited from class inet.ipaddr.IPAddress

Fields inherited from class inet.ipaddr.Address

Constructor Summary

Method Summary

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.IPAddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.string.IPAddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.AddressSegmentSeries

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

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

Methods inherited from interface inet.ipaddr.AddressComponent

Methods inherited from interface inet.ipaddr.format.AddressComponentRange

Methods inherited from interface inet.ipaddr.format.AddressItem

Methods inherited from interface inet.ipaddr.format.IPAddressRange

Field Detail

SEGMENT_SEPARATOR

BITS_PER_SEGMENT

BYTES_PER_SEGMENT

SEGMENT_COUNT

BYTE_COUNT

BIT_COUNT

DEFAULT_TEXTUAL_RADIX

MAX_VALUE_PER_SEGMENT

MAX_VALUE

REVERSE_DNS_SUFFIX

Constructor Detail

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

IPv4Address

Method Detail

getSection

getSection

getSection

getDivision

getSegment

getSegments

getParts

getParts

getSegmentCount

getByteCount

getBitCount

isIPv4

toIPv4

isIPv4Convertible

getIPv6Address

getIPv4MappedAddress

isIPv6Convertible

toIPv6

toBroadcastAddress

toNetworkAddress

getLowerNonZeroHost

getLower

getUpper

intValue

upperIntValue

longValue

upperLongValue

replace

replace

reverseBits