IPAddressSegment (IPAddress javadoc by seancfoley)

java.lang.Object
- inet.ipaddr.format.AddressDivisionBase
- - inet.ipaddr.format.standard.AddressDivision
  - - inet.ipaddr.format.standard.IPAddressDivision
    - - inet.ipaddr.IPAddressSegment

All Implemented Interfaces:

AddressComponent, AddressSegment, AddressComponentRange, AddressGenericDivision, AddressItem, AddressItemRange, IPAddressGenericDivision, AddressStringDivision, IPAddressStringDivision, Serializable, Comparable<AddressItem>

Direct Known Subclasses:

IPv4AddressSegment, IPv6AddressSegment
```
public abstract class IPAddressSegment
extends IPAddressDivision
implements AddressSegment
```
This represents a single segment of an IP address. For IPv4, segments are 1 byte. For IPv6, they are two bytes. IPAddressSegment objects are immutable and thus also thread-safe.

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class inet.ipaddr.format.standard.AddressDivision
  AddressDivision.BitwiseOrResult, AddressDivision.MaskResult

Field Summary
- Fields inherited from class inet.ipaddr.format.AddressDivisionBase
  EXTENDED_DIGITS

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`AddressDivision.BitwiseOrResult`	`bitwiseOrRange(int maskValue)`
`static int`	`getBitCount(IPAddress.IPVersion version)`
`static int`	`getByteCount(IPAddress.IPVersion version)`
`BigInteger`	`getCount()` The count of possible distinct values for this AddressComponent.
`static int`	`getDefaultTextualRadix(IPAddress.IPVersion version)`
`long`	`getDivisionValue()` returns the lower value as a long, although for individual segments `getSegmentValue()` provides the same value as an int
`abstract IPAddress.IPVersion`	`getIPVersion()`
`abstract Iterable<? extends IPAddressSegment>`	`getIterable()` Useful for using an instance in a "for-each loop".
`abstract IPAddressSegment`	`getLower()` If this segment represents a range of values, returns a segment representing just the lowest value in the range, otherwise returns this.
`static int`	`getMaxSegmentValue(IPAddress.IPVersion version)`
`long`	`getMaxValue()`
`int`	`getMinPrefixLengthForBlock()` Returns the smallest prefix length possible such that this item includes the block of all values for that prefix length.
`abstract IPAddressNetwork<?,?,?,?,?>`	`getNetwork()` Returns the network object for components of the same version (eg IPv4, IPv6 and MAC each have their own network object)
`BigInteger`	`getPrefixCount(int segmentPrefixLength)` The count of the number of distinct values within the prefix part of the address item, the bits that appear within the prefix length.
`int`	`getPrefixValueCount()` Counts the number of prefixes in this address segment.
`int`	`getPrefixValueCount(int segmentPrefixLength)` Returns the count of prefix values in this address segment for the given prefix bit count.
`Integer`	`getSegmentPrefixLength()`
`int`	`getSegmentValue()` returns the lower value
`abstract IPAddressSegment`	`getUpper()` If this segment represents a range of values, returns a segment representing just the highest value in the range, otherwise returns this.
`long`	`getUpperDivisionValue()` returns the lower upper value as a long, although for individual segments `getUpperSegmentValue()` provides the same value as an int
`int`	`getUpperSegmentValue()` returns the upper value
`int`	`getValueCount()` Returns the count of values in this address segment.
`int`	`hashCode()`
`boolean`	`includesMax()` Returns whether this item includes the maximum possible value for the address type or version within its range
`boolean`	`includesZero()` Returns whether this item includes the value of zero within its range
`boolean`	`isBoundedBy(int value)` Returns true if the possible values of this division fall below the given value.
`boolean`	`isIPv4()`
`boolean`	`isIPv6()`
`boolean`	`isMultiple()` Whether this represents multiple potential values (eg a prefixed address or a segment representing a range of values)
`boolean`	`isPrefixBlock()` Returns whether the division range includes the block of values for its prefix length
`abstract Iterator<? extends IPAddressSegment>`	`iterator()` Iterates through the individual address components.
`AddressDivision.MaskResult`	`maskRange(int maskValue)`
`boolean`	`matches(int value)`
`boolean`	`matchesWithMask(int value, int mask)`
`boolean`	`matchesWithMask(int lowerValue, int upperValue, int mask)`
`boolean`	`matchesWithPrefixMask(int value, Integer segmentPrefixLength)`
`abstract Iterator<? extends IPAddressSegment>`	`prefixBlockIterator()` Iterates through the individual prefix blocks.
`abstract Iterator<? extends IPAddressSegment>`	`prefixBlockIterator(int prefixLength)` Iterates through the individual prefix blocks according to the given segment prefix length.
`abstract AddressComponentSpliterator<? extends IPAddressSegment>`	`prefixBlockSpliterator()` Partitions and traverses through the individual prefix blocks of this segment for its prefix length.
`abstract AddressComponentSpliterator<? extends IPAddressSegment>`	`prefixBlockSpliterator(int prefixLength)` Partitions and traverses through the individual prefix blocks for the given prefix length.
`abstract Stream<? extends IPAddressSegment>`	`prefixBlockStream()` Returns a sequential stream of the individual prefix blocks of this segment.
`abstract Stream<? extends IPAddressSegment>`	`prefixBlockStream(int prefixLength)` Returns a sequential stream of the individual prefix blocks for the given prefix length.
`boolean`	`prefixContains(IPAddressSegment other)` Using the prefix length of this segment, or the whole segment if it has no prefix length, returns whether the prefix bit value ranges contain the same bits of the given segment.
`boolean`	`prefixContains(IPAddressSegment other, int prefixLength)` Returns whether the given prefix bit value ranges contain the same bits of the given segment.
`boolean`	`prefixEquals(AddressSegment other, int prefixLength)` Returns whether the given prefix bits match the same bits of the given segment.
`boolean`	`prefixEquals(IPAddressSegment other)`
`abstract Iterator<? extends IPAddressSegment>`	`prefixIterator()` Iterates through the individual prefixes.
`abstract AddressComponentSpliterator<? extends IPAddressSegment>`	`prefixSpliterator()` Partitions and traverses through the individual prefixes of this segment for its prefix length.
`abstract Stream<? extends IPAddressSegment>`	`prefixStream()` Returns a sequential stream of the individual prefixes of this segment.
`abstract IPAddressSegment`	`removePrefixLength()` Deprecated. use `withoutPrefixLength()` and `toZeroHost()`
`abstract IPAddressSegment`	`removePrefixLength(boolean zeroed)` Deprecated. use `toZeroHost()` and `withoutPrefixLength()`
`abstract IPAddressSegment`	`reverseBits(boolean perByte)` Returns a new AddressComponent with the bits reversed.
`abstract IPAddressSegment`	`reverseBytes()` Returns an AddressComponent with the bytes reversed.
`abstract AddressComponentSpliterator<? extends IPAddressSegment>`	`spliterator()` Partitions and traverses through the individual address components.
`abstract Stream<? extends IPAddressSegment>`	`stream()` Returns a sequential stream of the individual address components.
`String`	`toHexString(boolean with0xPrefix)` Writes this address component as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`abstract IPAddressSegment`	`toHostSegment(Integer segmentPrefixLength)` used by getHostSection, see `IPAddressSegmentSeries.getHostSection(int)`
`IPAddressSegment`	`toNetworkSegment(Integer segmentPrefixLength)` used by constructors of IPAddressSection, see `IPAddressSegmentSeries.getNetworkSection(int, boolean)`
`abstract IPAddressSegment`	`toNetworkSegment(Integer segmentPrefixLength, boolean withPrefixLength)` used by getNetworkSection and by constructors of IPAddressSection, see `IPAddressSegmentSeries.getNetworkSection(int, boolean)`
`String`	`toNormalizedString()` Produces a string that is consistent for all address components of the same type and version, and is also similar to the canonical string `AddressSegmentSeries.toCanonicalString()` in `AddressComponent` instances that are also `AddressSegmentSeries` instances.
`String`	`toNormalizedString(IPAddressSection.IPStringOptions options)`
`abstract IPAddressSegment`	`toZeroHost()` Returns a segment with the same network bits as this segment, but with the host bits changed to 0.
`abstract IPAddressSegment`	`withoutPrefixLength()` Returns a segment with the same values but without a prefix length.

Methods inherited from class inet.ipaddr.format.standard.IPAddressDivision
containsPrefixBlock, containsSinglePrefixBlock, getBlockMaskPrefixLength, getDivisionPrefixLength, getLeadingBitCount, getPrefixAdjustedRangeString, getString, getTrailingBitCount, getWildcardString, isPrefixed, isSinglePrefixBlock, matchesWithPrefixMask

Methods inherited from class inet.ipaddr.format.standard.AddressDivision
bitwiseOrRange, equals, getDigitCount, getMaxDigitCount, getPrefixLengthForSingleBlock, getUpperValue, getValue, hasUppercaseVariations, isBitwiseOrCompatibleWithRange, isMaskCompatibleWithRange, isMax, isZero, maskRange, matches, matchesWithMask, matchesWithMask

Methods inherited from class inet.ipaddr.format.AddressDivisionBase
getBytes, getBytes, getBytes, getDigitCount, getDigitCount, getLowerStandardString, getStandardString, getUpperBytes, getUpperBytes, getUpperBytes, toString

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

Methods inherited from interface inet.ipaddr.AddressSegment
contains, equals, getMaxSegmentValue, isOneBit, overlaps, testBit

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

Methods inherited from interface inet.ipaddr.format.AddressItem
compareTo, containsPrefixBlock, containsSinglePrefixBlock, getBitCount, getBitsForCount, getBlockSize, getByteCount, getBytes, getBytes, getBytes, getPrefixLengthForSingleBlock, getUpperBytes, getUpperBytes, getUpperBytes, getUpperValue, getValue, isFullRange, isMax, isZero

Methods inherited from interface inet.ipaddr.format.string.AddressStringDivision
getDigitCount, getLowerStandardString, getMaxDigitCount, getStandardString

Methods inherited from interface inet.ipaddr.format.IPAddressGenericDivision
isFullRange

Methods inherited from interface inet.ipaddr.format.string.IPAddressStringDivision
getBitCount

- Method Detail
  - getNetwork
```
public abstract IPAddressNetwork<?,?,?,?,?> 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
    
    Returns:
  - isIPv4
```
public boolean isIPv4()
```
  - isIPv6
```
public boolean isIPv6()
```
  - getIPVersion
```
public abstract IPAddress.IPVersion getIPVersion()
```
  - getMinPrefixLengthForBlock
```
public int getMinPrefixLengthForBlock()
```
    Description copied from interface: AddressItem
    
    Returns the smallest prefix length possible such that this item includes the block of all values for that prefix length.
    If the entire range can be dictated this way, then this method returns the same value as AddressItem.getPrefixLengthForSingleBlock(). Otherwise, this method will return the minimal possible prefix that can be paired with this address, while AddressItem.getPrefixLengthForSingleBlock() will return null.
    In cases where the final bit is constant so there is no such block, this returns the bit count.
    
    Specified by:
    
    getMinPrefixLengthForBlock in interface AddressItem
    
    Overrides:
    
    getMinPrefixLengthForBlock in class AddressDivision
    
    Returns:
    
    the prefix length
  - getMaxSegmentValue
```
public static int getMaxSegmentValue(IPAddress.IPVersion version)
```
  - isPrefixBlock
```
public boolean isPrefixBlock()
```
    Description copied from interface: IPAddressStringDivision
    
    Returns whether the division range includes the block of values for its prefix length
    
    Specified by:
    
    isPrefixBlock in interface IPAddressStringDivision
    
    Overrides:
    
    isPrefixBlock in class IPAddressDivision
    
    Returns:
    
    whether the division range includes the block of values for the division prefix length, or false if the division has no prefix length
  - toNetworkSegment
```
public IPAddressSegment toNetworkSegment(Integer segmentPrefixLength)
```
    used by constructors of IPAddressSection, see IPAddressSegmentSeries.getNetworkSection(int, boolean)
  - toNetworkSegment
```
public abstract IPAddressSegment toNetworkSegment(Integer segmentPrefixLength,
                                                  boolean withPrefixLength)
```
    used by getNetworkSection and by constructors of IPAddressSection, see IPAddressSegmentSeries.getNetworkSection(int, boolean)
  - toHostSegment
```
public abstract IPAddressSegment toHostSegment(Integer segmentPrefixLength)
```
    used by getHostSection, see IPAddressSegmentSeries.getHostSection(int)
  - maskRange
```
public AddressDivision.MaskResult maskRange(int maskValue)
```
  - bitwiseOrRange
```
public AddressDivision.BitwiseOrResult bitwiseOrRange(int maskValue)
```
  - getLower
```
public abstract IPAddressSegment getLower()
```
    If this segment represents a range of values, returns a segment representing just the lowest value in the range, otherwise returns this.
    
    Specified by:
    
    getLower in interface AddressSegment
    
    Specified by:
    
    getLower in interface AddressComponentRange
    
    Returns:
  - getUpper
```
public abstract IPAddressSegment getUpper()
```
    If this segment represents a range of values, returns a segment representing just the highest value in the range, otherwise returns this.
    
    Specified by:
    
    getUpper in interface AddressSegment
    
    Specified by:
    
    getUpper in interface AddressComponentRange
    
    Returns:
  - getIterable
```
public abstract Iterable<? extends IPAddressSegment> 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 AddressSegment
    
    Specified by:
    
    getIterable in interface AddressComponentRange
    
    Returns:
  - iterator
```
public abstract Iterator<? extends IPAddressSegment> 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 AddressSegment
    
    Specified by:
    
    iterator in interface AddressComponentRange
    
    Returns:
  - spliterator
```
public abstract AddressComponentSpliterator<? extends IPAddressSegment> 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 AddressSegment
    
    Specified by:
    
    spliterator in interface AddressComponentRange
    
    Returns:
  - stream
```
public abstract Stream<? extends IPAddressSegment> 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 AddressSegment
    
    Specified by:
    
    stream in interface AddressComponentRange
    
    Returns:
  - prefixBlockIterator
```
public abstract Iterator<? extends IPAddressSegment> prefixBlockIterator()
```
    Iterates through the individual prefix blocks.
    If the series has no prefix length, then this is equivalent to iterator()
  - prefixBlockSpliterator
```
public abstract AddressComponentSpliterator<? extends IPAddressSegment> prefixBlockSpliterator()
```
    Partitions and traverses through the individual prefix blocks of this segment for its prefix length.
    
    Returns:
  - prefixBlockStream
```
public abstract Stream<? extends IPAddressSegment> prefixBlockStream()
```
    Returns a sequential stream of the individual prefix blocks of this segment. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Returns:
  - prefixIterator
```
public abstract Iterator<? extends IPAddressSegment> prefixIterator()
```
    Iterates through the individual prefixes.
    If the series has no prefix length, then this is equivalent to iterator()
  - prefixSpliterator
```
public abstract AddressComponentSpliterator<? extends IPAddressSegment> prefixSpliterator()
```
    Partitions and traverses through the individual prefixes of this segment for its prefix length.
    
    Returns:
  - prefixStream
```
public abstract Stream<? extends IPAddressSegment> prefixStream()
```
    Returns a sequential stream of the individual prefixes of this segment. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Returns:
  - prefixBlockIterator
```
public abstract Iterator<? extends IPAddressSegment> prefixBlockIterator(int prefixLength)
```
    Iterates through the individual prefix blocks according to the given segment prefix length. Any existing prefix length is disregarded.
  - prefixBlockSpliterator
```
public abstract AddressComponentSpliterator<? extends IPAddressSegment> prefixBlockSpliterator(int prefixLength)
```
    Partitions and traverses through the individual prefix blocks for the given prefix length.
    
    Returns:
  - prefixBlockStream
```
public abstract Stream<? extends IPAddressSegment> prefixBlockStream(int prefixLength)
```
    Returns a sequential stream of the individual prefix blocks for the given prefix length. For a parallel stream, call BaseStream.parallel() on the returned stream.
    
    Returns:
  - getBitCount
```
public static int getBitCount(IPAddress.IPVersion version)
```
  - getByteCount
```
public static int getByteCount(IPAddress.IPVersion version)
```
  - getDefaultTextualRadix
```
public static int getDefaultTextualRadix(IPAddress.IPVersion version)
```
  - matches
```
public boolean matches(int value)
```
    Specified by:
    
    matches in interface AddressSegment
  - matchesWithPrefixMask
```
public boolean matchesWithPrefixMask(int value,
                                     Integer segmentPrefixLength)
```
  - matchesWithMask
```
public boolean matchesWithMask(int value,
                               int mask)
```
    Specified by:
    
    matchesWithMask in interface AddressSegment
  - matchesWithMask
```
public boolean matchesWithMask(int lowerValue,
                               int upperValue,
                               int mask)
```
    Specified by:
    
    matchesWithMask in interface AddressSegment
  - getValueCount
```
public int getValueCount()
```
    Description copied from interface: AddressSegment
    
    Returns the count of values in this address segment.
    
    Specified by:
    
    getValueCount in interface AddressSegment
    
    Returns:
    
    the same value as getCount() as an integer
  - getPrefixValueCount
```
public int getPrefixValueCount()
```
    Counts the number of prefixes in this address segment.
    If this segment has no prefix length, this is equivalent to getValueCount()
    
    Returns:
  - getCount
```
public BigInteger getCount()
```
    Description copied from interface: AddressItem
    
    The count of possible distinct values for this AddressComponent. If not multiple, this is 1. Note that an AddressDivisionSeries with no divisions or AddressSection with no segments has a single value of 0. For instance, if this is the ip address series subnet 0::/64, then the count is 2 to the power of 64. If this is a the segment 3-7, then the count is 5.
    
    Specified by:
    
    getCount in interface AddressItem
    
    Returns:
  - getPrefixCount
```
public BigInteger getPrefixCount(int segmentPrefixLength)
```
    Description copied from interface: AddressItem
    
    The count of the number of distinct values within the prefix part of the address item, the bits that appear within the prefix length.
    
    Specified by:
    
    getPrefixCount in interface AddressItem
    
    Returns:
  - getPrefixValueCount
```
public int getPrefixValueCount(int segmentPrefixLength)
```
    Description copied from interface: AddressSegment
    
    Returns the count of prefix values in this address segment for the given prefix bit count.
    
    Specified by:
    
    getPrefixValueCount in interface AddressSegment
    
    Returns:
    
    the count of values
  - getMaxValue
```
public long getMaxValue()
```
    Overrides:
    
    getMaxValue in class AddressDivision
  - isMultiple
```
public boolean isMultiple()
```
    Description copied from interface: AddressItem
    
    Whether this represents multiple potential values (eg a prefixed address or a segment representing a range of values)
    
    Specified by:
    
    isMultiple in interface AddressItem
    
    Overrides:
    
    isMultiple in class AddressDivision
    
    Returns:
    
    whether this segment represents multiple values
  - getSegmentValue
```
public int getSegmentValue()
```
    returns the lower value
    
    Specified by:
    
    getSegmentValue in interface AddressSegment
  - getUpperSegmentValue
```
public int getUpperSegmentValue()
```
    returns the upper value
    
    Specified by:
    
    getUpperSegmentValue in interface AddressSegment
  - getDivisionValue
```
public long getDivisionValue()
```
    returns the lower value as a long, although for individual segments getSegmentValue() provides the same value as an int
    
    Specified by:
    
    getDivisionValue in class AddressDivision
  - getUpperDivisionValue
```
public long getUpperDivisionValue()
```
    returns the lower upper value as a long, although for individual segments getUpperSegmentValue() provides the same value as an int
    
    Specified by:
    
    getUpperDivisionValue in class AddressDivision
  - reverseBits
```
public abstract IPAddressSegment reverseBits(boolean perByte)
```
    Description copied from interface: AddressComponent
    
    Returns a new AddressComponent with the bits reversed. If this component represents a range of values that cannot be reversed, then this throws IncompatibleAddressException. In a range the most significant bits stay constant while the least significant bits range over different values, so reversing that scenario results in a series of non-consecutive values, in most cases, which cannot be represented with a single AddressComponent object.
    In such cases where isMultiple() is true, call iterator(), getLower(), getUpper() or some other methods to break the series down into a series representing a single value.
    
    Specified by:
    
    reverseBits in interface AddressComponent
    
    Specified by:
    
    reverseBits in interface AddressSegment
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the component are reversed
    
    Returns:
  - reverseBytes
```
public abstract IPAddressSegment reverseBytes()
```
    Description copied from interface: AddressComponent
    
    Returns an AddressComponent with the bytes reversed. If this component represents a range of values that cannot be reversed, then this throws IncompatibleAddressException. In a range the most significant bits stay constant while the least significant bits range over different values, so reversing that scenario results in a series of non-consecutive values, in most cases, which cannot be represented with a single AddressComponent object.
    In such cases where isMultiple() is true, call iterator(), getLower(), getUpper() or some other methods to break the series down into a series representing a single value.
    
    Specified by:
    
    reverseBytes in interface AddressComponent
    
    Specified by:
    
    reverseBytes in interface AddressSegment
    
    Returns:
  - removePrefixLength
```
@Deprecated
public abstract IPAddressSegment removePrefixLength()
```
    Deprecated. use withoutPrefixLength() and toZeroHost()
    
    Returns:
  - toZeroHost
```
public abstract IPAddressSegment toZeroHost()
```
    Returns a segment with the same network bits as this segment, but with the host bits changed to 0.
    If there is no prefix length associated with this segment, returns an all-zero segment.
    This is nearly equivalent to doing the mask (see maskRange(int)) of this segment with the network mask for the given prefix length, but when applying a mask to a range of values you can have a non-sequential result.
    With this method, if the resulting series has a range of values, then the resulting series range boundaries will have host values of 0, but not necessarily all the intervening values.
    For instance, the 1-byte segment range 4-7 with prefix length 6, when masked with 252 (the network mask) results in just the single value 4, matching the result of this method. The 1-byte segment range 4-8 with prefix length 6, when masked with 252 results in the two non-sequential values, 4 and 8, but the result of this method with prefix length 6 results in the range 4-8, the same as the original segment.
    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.
    
    Returns:
  - removePrefixLength
```
@Deprecated
public abstract IPAddressSegment removePrefixLength(boolean zeroed)
```
    Deprecated. use toZeroHost() and withoutPrefixLength()
    
    Parameters:
    
    zeroed -
    
    Returns:
  - withoutPrefixLength
```
public abstract IPAddressSegment withoutPrefixLength()
```
    Returns a segment with the same values but without a prefix length.
    
    Returns:
  - isBoundedBy
```
public boolean isBoundedBy(int value)
```
    Description copied from class: AddressDivision
    
    Returns true if the possible values of this division fall below the given value.
    
    Specified by:
    
    isBoundedBy in interface AddressStringDivision
    
    Overrides:
    
    isBoundedBy in class AddressDivision
  - getSegmentPrefixLength
```
public Integer getSegmentPrefixLength()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class AddressDivision
  - prefixEquals
```
public boolean prefixEquals(IPAddressSegment other)
```
  - prefixEquals
```
public boolean prefixEquals(AddressSegment other,
                            int prefixLength)
```
    Description copied from interface: AddressSegment
    
    Returns whether the given prefix bits match the same bits of the given segment.
    
    Specified by:
    
    prefixEquals in interface AddressSegment
    
    Returns:
  - prefixContains
```
public boolean prefixContains(IPAddressSegment other)
```
    Using the prefix length of this segment, or the whole segment if it has no prefix length, returns whether the prefix bit value ranges contain the same bits of the given segment.
    
    Parameters:
    
    other -
    
    Returns:
  - prefixContains
```
public boolean prefixContains(IPAddressSegment other,
                              int prefixLength)
```
    Returns whether the given prefix bit value ranges contain the same bits of the given segment.
    
    Parameters:
    
    other -
    
    prefixLength -
    
    Returns:
  - includesZero
```
public boolean includesZero()
```
    Description copied from interface: AddressItem
    
    Returns whether this item includes the value of zero within its range
    
    Specified by:
    
    includesZero in interface AddressItem
    
    Overrides:
    
    includesZero in class AddressDivision
    
    Returns:
    
    whether this item includes the value of zero within its range
  - includesMax
```
public boolean includesMax()
```
    Description copied from interface: AddressItem
    
    Returns whether this item includes the maximum possible value for the address type or version within its range
    
    Specified by:
    
    includesMax in interface AddressItem
    
    Overrides:
    
    includesMax in class AddressDivision
    
    Returns:
    
    whether this item includes the maximum possible value within its range
  - toHexString
```
public String toHexString(boolean with0xPrefix)
```
    Description copied from interface: AddressComponent
    
    Writes this address component as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
    If this component represents a range of values outside of the network prefix length, then this is printed as a range of two hex values.
    For instance, for IPv4 addresses there are 8 hex characters, for IPv6 addresses there are 32 hex characters.
    
    Specified by:
    
    toHexString in interface AddressComponent
  - toNormalizedString
```
public String toNormalizedString()
```
    Description copied from interface: AddressComponent
    
    Produces a string that is consistent for all address components of the same type and version, and is also similar to the canonical string AddressSegmentSeries.toCanonicalString() in AddressComponent instances that are also AddressSegmentSeries instances.
    
    Specified by:
    
    toNormalizedString in interface AddressComponent
    
    Returns:
  - toNormalizedString
```
public String toNormalizedString(IPAddressSection.IPStringOptions options)
```

Class IPAddressSegment

Nested Class Summary

Nested classes/interfaces inherited from class inet.ipaddr.format.standard.AddressDivision

Field Summary

Fields inherited from class inet.ipaddr.format.AddressDivisionBase

Method Summary

Methods inherited from class inet.ipaddr.format.standard.IPAddressDivision

Methods inherited from class inet.ipaddr.format.standard.AddressDivision

Methods inherited from class inet.ipaddr.format.AddressDivisionBase

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.AddressSegment

Methods inherited from interface inet.ipaddr.format.AddressComponentRange

Methods inherited from interface inet.ipaddr.format.AddressItem

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

Methods inherited from interface inet.ipaddr.format.IPAddressGenericDivision

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

Method Detail

getNetwork

isIPv4

isIPv6

getIPVersion

getMinPrefixLengthForBlock

getMaxSegmentValue

isPrefixBlock

toNetworkSegment

toNetworkSegment

toHostSegment

maskRange

bitwiseOrRange

getLower

getUpper

getIterable

iterator

spliterator

stream

prefixBlockIterator

prefixBlockSpliterator

prefixBlockStream

prefixIterator

prefixSpliterator

prefixStream

prefixBlockIterator

prefixBlockSpliterator

prefixBlockStream

getBitCount

getByteCount

getDefaultTextualRadix

matches

matchesWithPrefixMask

matchesWithMask

matchesWithMask

getValueCount

getPrefixValueCount

getCount

getPrefixCount

getPrefixValueCount

getMaxValue

isMultiple

getSegmentValue

getUpperSegmentValue

getDivisionValue

getUpperDivisionValue

reverseBits

reverseBytes

removePrefixLength

toZeroHost

removePrefixLength

withoutPrefixLength

isBoundedBy

getSegmentPrefixLength

hashCode

prefixEquals

prefixEquals

prefixContains

prefixContains

includesZero

includesMax

toHexString

toNormalizedString

toNormalizedString