MACAddressSection

java.lang.Object
- inet.ipaddr.format.AddressDivisionGrouping
- - inet.ipaddr.mac.MACAddressSection

All Implemented Interfaces:

AddressComponent, AddressSection, AddressSegmentSeries, AddressDivisionSeries, AddressItem, AddressStringDivisionSeries, java.io.Serializable, java.lang.Comparable<AddressDivisionGrouping>, java.lang.Iterable<MACAddressSection>
```
public class MACAddressSection
extends AddressDivisionGrouping
implements AddressSection, java.lang.Iterable<MACAddressSection>
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class MACAddressSection.MACStringOptions
Represents a clear way to create a specific type of string.
- Nested classes/interfaces inherited from class inet.ipaddr.format.AddressDivisionGrouping
  AddressDivisionGrouping.StringOptions

Nested Classes
Modifier and Type	Class and Description
`static class`	`MACAddressSection.MACStringOptions` Represents a clear way to create a specific type of string.

Field Summary

Fields
Modifier and Type Field and Description

boolean extended

int startIndex

Fields
Modifier and Type	Field and Description
`boolean`	`extended`
`int`	`startIndex`

Constructor Summary

Constructors
Constructor and Description
`MACAddressSection(byte[] bytes)`
`MACAddressSection(byte[] bytes, int startIndex, boolean extended)`
`MACAddressSection(byte[] bytes, int startIndex, boolean extended, java.lang.Integer prefixLength)`
`MACAddressSection(byte[] bytes, java.lang.Integer prefixLength)`
`MACAddressSection(long value)`
`MACAddressSection(long value, int startIndex, boolean extended)`
`MACAddressSection(long value, int startIndex, boolean extended, java.lang.Integer prefixLength)`
`MACAddressSection(long value, java.lang.Integer prefixLength)`
`MACAddressSection(MACAddressSegment segment)` Constructs a single segment section, the segment being the leading segment.
`MACAddressSection(MACAddressSegment[] segments)` Use this constructor for any address section that includes the leading segment of a MAC address
`MACAddressSection(MACAddressSegment[] segments, int startIndex, boolean extended)`
`MACAddressSection(MACAddressSegment[] segments, int startIndex, boolean extended, java.lang.Integer prefixLength)`
`MACAddressSection(MACAddressSegment[] segments, java.lang.Integer prefixLength)`
`MACAddressSection(MACAddressSegment segment, int startIndex, boolean extended)` Constructs a single segment section with the segment at the given index in the address.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`MACAddressSection`	`adjustPrefixBySegment(boolean nextSegment)` Increases or decreases prefix length to the next segment boundary.
`MACAddressSection`	`adjustPrefixLength(int adjustment)` Increases or decreases prefix length by the given increment.
`MACAddressSection`	`append(MACAddressSection other)`
`MACAddressSection`	`applyPrefixLength(int prefixLength)` Applies the given prefix length to create a new segment series representing all segment series starting with the same prefix.
`boolean`	`contains(AddressSection other)` Determines if one section contains another.
`boolean`	`contains(MACAddressSection other)`
`boolean`	`equals(java.lang.Object o)`
`int`	`getBitCount()`
`int`	`getBitsPerSegment()`
`int`	`getByteCount()` returns the number of bytes in each of the address components represented by this instance
`int`	`getBytesPerSegment()`
`AddressDivisionGrouping`	`getDottedGrouping()`
`java.lang.Iterable<MACAddressSection>`	`getIterable()` Useful for using an instance in a "for-each loop".
`MACAddressSection`	`getLower()` If this instance represents multiple address components, returns the one with the lowest numeric value.
`MACAddressSection`	`getODISection()`
`int`	`getODISegmentCount()`
`MACAddressSection`	`getOUISection()`
`int`	`getOUISegmentCount()`
`java.lang.Integer`	`getPrefixLength()` The bit-length of the portion of the address that is not specific to an individual address but common amongst a group of addresses.
`MACAddressSection`	`getSection(int index)` Gets the subsection from the series starting from the given index
`MACAddressSection`	`getSection(int index, int endIndex)` Gets the subsection from the series starting from the given index and ending just before the give endIndex
`MACAddressSegment`	`getSegment(int index)`
`int`	`getSegmentCount()`
`MACAddressSegment[]`	`getSegments()`
`void`	`getSegments(AddressSegment[] segs)`
`void`	`getSegments(java.util.Collection<? super MACAddressSegment> segs)`
`void`	`getSegments(int start, int end, AddressSegment[] segs, int destIndex)` get the segments from start to end and insert into the segs array at the the given index
`void`	`getSegments(int start, int end, java.util.Collection<? super MACAddressSegment> segs)`
`MACAddressSection`	`getUpper()` If this instance represents multiple address components, returns the one with the highest numeric value.
`boolean`	`isEntireAddress(boolean extended)`
`boolean`	`isEUI64(boolean asMAC)` Equivalent to isEUI64(asMAC, false)
`boolean`	`isEUI64(boolean asMAC, boolean partial)` Whether this section is consistent with an EUI64 section, which means it came from an extended 8 byte address, and the corresponding segments in the middle match 0xff and 0xff/fe for MAC/not-MAC
`boolean`	`isExtended()`
`boolean`	`isMultipleByPrefix()` whether there is a prefix and it is less than the bit-count
`boolean`	`isPrefixed()` Indicates if the address represents all devices with the same OUI segments.
`java.util.Iterator<MACAddressSection>`	`iterator()` An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values.
`MACAddressSection`	`prepend(MACAddressSection other)`
`MACAddressSection`	`removePrefixLength()` Removes the prefix.
`MACAddressSection`	`replace(MACAddressSection other, int index)`
`MACAddressSection`	`reverseBits(boolean perByte)` Returns a new segment series with the bits reversed.
`MACAddressSection`	`reverseBytes()` Returns a new segment series with the bytes reversed.
`MACAddressSection`	`reverseBytesPerSegment()` Returns a new segment series with the bytes reversed within each segment.
`MACAddressSection`	`reverseSegments()` Returns a new segment series with the segments reversed.
`java.util.Iterator<MACAddressSegment[]>`	`segmentsIterator()`
`MACAddressSection`	`setPrefixLength(int networkPrefixLength)` Sets the prefix length.
`java.lang.String`	`toCanonicalString()` This produces a canonical string using the canonical standardized IEEE 802 MAC address representation of xx-xx-xx-xx-xx-xx For range segments, '..' is used: 11-22-33..44-55-66
`java.lang.String`	`toColonDelimitedString()`
`java.lang.String`	`toCompressedString()` This produces a shorter string for the address that uses the canonical representation but not using leading zeroes.
`java.lang.String`	`toDashedString()`
`java.lang.String`	`toDottedString()` This produces the dotted hexadecimal format aaaa.bbbb.cccc
`MACAddressSection`	`toEUI64(boolean asMAC)` If this section is part of a shorter 48 bit MAC or EUI-48 address see `isExtended()`, then the required sections are inserted (FF-FF for MAC, FF-FE for EUI-48) to extend it to EUI-64.
`IPv6AddressSection`	`toEUI64IPv6()`
`java.lang.String`	`toHexString(boolean with0xPrefix)` Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
`java.lang.String`	`toNormalizedString()` The normalized string returned by this method is the most common representation of MAC addresses: xx:xx:xx:xx:xx:xx
`java.lang.String`	`toNormalizedString(AddressDivisionGrouping.StringOptions stringOptions)`
`static java.lang.String`	`toNormalizedString(AddressDivisionGrouping.StringOptions opts, AddressDivisionGrouping section)`
`MACAddressSection`	`toOUIPrefixed()`
`java.lang.String`	`toSpaceDelimitedString()` This produces a string delimited by spaces: aa bb cc dd ee ff
`java.lang.String`	`toString()`

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping
compareTo, getBytes, getBytes, getCount, getDivision, getDivisionCount, getEquivalentPrefix, getMinPrefix, getUpperBytes, getUpperBytes, hashCode, isFullRange, isMore, isMultiple, isRangeEquivalent, isRangeEquivalentToPrefix, isZero

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

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries
getDivision, getEquivalentPrefix, getMinPrefix, isMore, isRangeEquivalentToPrefix

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

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

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

- Field Detail
  - startIndex
```
public final int startIndex
```
  - extended
```
public final boolean extended
```
- Constructor Detail
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment segment)
```
    Constructs a single segment section, the segment being the leading segment.
    
    Parameters:
    
    segment -
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment segment,
                         int startIndex,
                         boolean extended)
```
    Constructs a single segment section with the segment at the given index in the address.
    
    Parameters:
    
    segment -
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment[] segments)
```
    Use this constructor for any address section that includes the leading segment of a MAC address
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment[] segments,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment[] segments,
                         java.lang.Integer prefixLength)
```
  - MACAddressSection
```
public MACAddressSection(MACAddressSegment[] segments,
                         int startIndex,
                         boolean extended,
                         java.lang.Integer prefixLength)
```
  - MACAddressSection
```
public MACAddressSection(byte[] bytes,
                         int startIndex,
                         boolean extended,
                         java.lang.Integer prefixLength)
```
  - MACAddressSection
```
public MACAddressSection(byte[] bytes,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(byte[] bytes,
                         java.lang.Integer prefixLength)
```
  - MACAddressSection
```
public MACAddressSection(byte[] bytes)
```
  - MACAddressSection
```
public MACAddressSection(long value,
                         int startIndex,
                         boolean extended,
                         java.lang.Integer prefixLength)
```
  - MACAddressSection
```
public MACAddressSection(long value,
                         int startIndex,
                         boolean extended)
```
  - MACAddressSection
```
public MACAddressSection(long value,
                         java.lang.Integer prefixLength)
```
  - MACAddressSection
```
public MACAddressSection(long value)
```
- Method Detail
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class AddressDivisionGrouping
  - getSegments
```
public MACAddressSegment[] getSegments()
```
    Specified by:
    
    getSegments in interface AddressSegmentSeries
  - getSegments
```
public void getSegments(AddressSegment[] segs)
```
    Specified by:
    
    getSegments in interface AddressSegmentSeries
  - getSegments
```
public void getSegments(int start,
                        int end,
                        AddressSegment[] segs,
                        int destIndex)
```
    Description copied from interface: AddressSegmentSeries
    
    get the segments from start to end and insert into the segs array at the the given index
    
    Specified by:
    
    getSegments in interface AddressSegmentSeries
  - isExtended
```
public boolean isExtended()
```
    Returns:
    
    whether this section is part of a larger EUI-64 address.
  - getSegmentCount
```
public int getSegmentCount()
```
    Specified by:
    
    getSegmentCount in interface AddressSegmentSeries
  - isEntireAddress
```
public boolean isEntireAddress(boolean extended)
```
  - getSegment
```
public MACAddressSegment getSegment(int index)
```
    Specified by:
    
    getSegment in interface AddressSegmentSeries
  - getSegments
```
public void getSegments(java.util.Collection<? super MACAddressSegment> segs)
```
  - getSegments
```
public void getSegments(int start,
                        int end,
                        java.util.Collection<? super MACAddressSegment> segs)
```
  - getByteCount
```
public int getByteCount()
```
    Description copied from interface: AddressComponent
    
    returns the number of bytes in each of the address components represented by this instance
    
    Specified by:
    
    getByteCount in interface AddressComponent
    
    Returns:
  - getBitCount
```
public int getBitCount()
```
    Specified by:
    
    getBitCount in interface AddressItem
    
    Overrides:
    
    getBitCount in class AddressDivisionGrouping
    
    Returns:
    
    the number of bits in this item
  - getBitsPerSegment
```
public int getBitsPerSegment()
```
    Specified by:
    
    getBitsPerSegment in interface AddressSegmentSeries
  - getBytesPerSegment
```
public int getBytesPerSegment()
```
    Specified by:
    
    getBytesPerSegment in interface AddressSegmentSeries
  - isPrefixed
```
public boolean isPrefixed()
```
    Indicates if the address represents all devices with the same OUI segments.
    
    Specified by:
    
    isPrefixed in interface AddressDivisionSeries
    
    Overrides:
    
    isPrefixed in class AddressDivisionGrouping
    
    Returns:
    
    true if all the ODI segments are full-range, covering all devices
  - getOUISegmentCount
```
public int getOUISegmentCount()
```
  - getODISegmentCount
```
public int getODISegmentCount()
```
  - getPrefixLength
```
public java.lang.Integer getPrefixLength()
```
    Description copied from interface: AddressDivisionSeries
    
    The bit-length of the portion of the address that is not specific to an individual address but common amongst a group of addresses. Typically this is the largest number of bits in the upper-most portion of the section for which the remaining bits assume all possible values. For IP addresses, this must be explicitly defined when the address is created. For example, 1.2.0.0/16 has a prefix length of 16, while 1.2.*.* has no prefix length, even though they both represent the same set of addresses and are considered equal. Prefixes can be considered variable for any given IP addresses and can depend on the routing table. The methods getMinPrefix and getEquivalentPrefix can help you to obtain or define a prefix length if one does not exist already. 1.2.0.0/16 and 1.2.*.* both the same equivalent and minimum prefix length of 16. For MAC addresses, the prefix is implicit, so 1:2:3:*:*:* has a prefix length of 24 by definition. Generally prefixes are not variable for a given address. Either an address has a prefix or not, the one assigned by the IEEE. There is no way to explicitly define the prefix in a representation of a MAC address. The prefix length is instead determined by the address itself when created.
    
    Specified by:
    
    getPrefixLength in interface AddressDivisionSeries
    
    Overrides:
    
    getPrefixLength in class AddressDivisionGrouping
    
    Returns:
    
    the number of bits in the prefix. The prefix is the smallest bit length x for which all possible values with the same first x bits are included in this range of sections, unless that value x matches the bit count of this section, in which case the prefix is null. If the prefix is the OUI bit length (24) then the ODI segments cover all possibly values.
  - isMultipleByPrefix
```
public boolean isMultipleByPrefix()
```
    Description copied from interface: AddressDivisionSeries
    
    whether there is a prefix and it is less than the bit-count
    
    Specified by:
    
    isMultipleByPrefix in interface AddressDivisionSeries
    
    Overrides:
    
    isMultipleByPrefix in class AddressDivisionGrouping
    
    Returns:
    
    there is a prefix and there are multiple addresses associated with that prefix
  - getSection
```
public MACAddressSection getSection(int index)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index
    
    Specified by:
    
    getSection in interface AddressSection
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getSection
```
public MACAddressSection getSection(int index,
                                    int endIndex)
```
    Description copied from interface: AddressSegmentSeries
    
    Gets the subsection from the series starting from the given index and ending just before the give endIndex
    
    Specified by:
    
    getSection in interface AddressSection
    
    Specified by:
    
    getSection in interface AddressSegmentSeries
    
    Returns:
  - getOUISection
```
public MACAddressSection getOUISection()
```
  - getODISection
```
public MACAddressSection getODISection()
```
  - toOUIPrefixed
```
public MACAddressSection toOUIPrefixed()
```
  - toEUI64IPv6
```
public IPv6AddressSection toEUI64IPv6()
```
  - isEUI64
```
public boolean isEUI64(boolean asMAC)
```
    Equivalent to isEUI64(asMAC, false)
    
    Returns:
  - isEUI64
```
public boolean isEUI64(boolean asMAC,
                       boolean partial)
```
    Whether this section is consistent with an EUI64 section, which means it came from an extended 8 byte address, and the corresponding segments in the middle match 0xff and 0xff/fe for MAC/not-MAC
    
    Parameters:
    
    partial - whether missing segments are considered a match (this only has an effect if this section came from an extended 8 byte address), or in other words, we don't consider 6 byte addresses to be "missing" the bytes that would make it 8 byte.
    
    asMAC - whether to search for the ffff or fffe pattern
    
    Returns:
  - toEUI64
```
public MACAddressSection toEUI64(boolean asMAC)
```
    If this section is part of a shorter 48 bit MAC or EUI-48 address see isExtended(), then the required sections are inserted (FF-FF for MAC, FF-FE for EUI-48) to extend it to EUI-64. However, if the section does not encompass the parts of the address where the new sections should be placed, then the section is unchanged. If the section is already part of an EUI-64 address, then it is checked to see if it has the segments that identify it as extended to EUI-64 (FF-FF for MAC, FF-FE for EUI-48), and if not, AddressTypeException is thrown.
    
    Parameters:
    
    asMAC -
    
    Returns:
  - replace
```
public MACAddressSection replace(MACAddressSection other,
                                 int index)
```
  - prepend
```
public MACAddressSection prepend(MACAddressSection other)
```
  - append
```
public MACAddressSection append(MACAddressSection other)
```
  - contains
```
public boolean contains(MACAddressSection other)
```
    Parameters:
    
    other -
    
    Returns:
    
    whether this section contains the given address section
  - getLower
```
public MACAddressSection getLower()
```
    Description copied from interface: AddressComponent
    
    If this instance represents multiple address components, returns the one with the lowest numeric value.
    
    Specified by:
    
    getLower in interface AddressComponent
    
    Specified by:
    
    getLower in interface AddressSection
    
    Specified by:
    
    getLower in interface AddressSegmentSeries
    
    Returns:
  - getUpper
```
public MACAddressSection getUpper()
```
    Description copied from interface: AddressComponent
    
    If this instance represents multiple address components, returns the one with the highest numeric value.
    
    Specified by:
    
    getUpper in interface AddressComponent
    
    Specified by:
    
    getUpper in interface AddressSection
    
    Specified by:
    
    getUpper in interface AddressSegmentSeries
    
    Returns:
  - reverseBits
```
public MACAddressSection 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 AddressSection
    
    Specified by:
    
    reverseBits in interface AddressSegmentSeries
    
    Parameters:
    
    perByte - if true, only the bits in each byte are reversed, if false, then all bits in the component are reversed
    
    Returns:
  - reverseBytes
```
public MACAddressSection 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 AddressSection
    
    Specified by:
    
    reverseBytes in interface AddressSegmentSeries
    
    Returns:
  - reverseBytesPerSegment
```
public MACAddressSection reverseBytesPerSegment()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the bytes reversed within each segment.
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSection
    
    Specified by:
    
    reverseBytesPerSegment in interface AddressSegmentSeries
    
    Returns:
  - reverseSegments
```
public MACAddressSection reverseSegments()
```
    Description copied from interface: AddressSegmentSeries
    
    Returns a new segment series with the segments reversed. This does not throw AddressTypeException.
    
    Specified by:
    
    reverseSegments in interface AddressSection
    
    Specified by:
    
    reverseSegments in interface AddressSegmentSeries
    
    Returns:
  - removePrefixLength
```
public MACAddressSection removePrefixLength()
```
    Description copied from interface: AddressSegmentSeries
    
    Removes the prefix. When the series already had a prefix, the bits previously not within the prefix are zero.
    
    Specified by:
    
    removePrefixLength in interface AddressSection
    
    Specified by:
    
    removePrefixLength in interface AddressSegmentSeries
    
    Returns:
  - adjustPrefixBySegment
```
public MACAddressSection adjustPrefixBySegment(boolean nextSegment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length to the next segment boundary. When prefix length is increased, the bits moved within the prefix are zero.
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSection
    
    Specified by:
    
    adjustPrefixBySegment in interface AddressSegmentSeries
    
    Returns:
  - adjustPrefixLength
```
public MACAddressSection adjustPrefixLength(int adjustment)
```
    Description copied from interface: AddressSegmentSeries
    
    Increases or decreases prefix length by the given increment. When prefix length is increased, the bits moved within the prefix become zero. When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    adjustPrefixLength in interface AddressSection
    
    Specified by:
    
    adjustPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - applyPrefixLength
```
public MACAddressSection applyPrefixLength(int prefixLength)
```
    Description copied from interface: AddressSegmentSeries
    
    Applies the given prefix length to create a new segment series representing all segment series starting with the same prefix. When this series already has a prefix length that is smaller, then this method returns this series.
    
    Specified by:
    
    applyPrefixLength in interface AddressSection
    
    Specified by:
    
    applyPrefixLength in interface AddressSegmentSeries
  - setPrefixLength
```
public MACAddressSection setPrefixLength(int networkPrefixLength)
```
    Description copied from interface: AddressSegmentSeries
    
    Sets the prefix length. When the series already had a prefix, and the prefix length is increased, the bits moved within the prefix are zero. When the prefix is extended beyond the segment series boundary, it is removed.
    
    Specified by:
    
    setPrefixLength in interface AddressSection
    
    Specified by:
    
    setPrefixLength in interface AddressSegmentSeries
    
    Returns:
  - getIterable
```
public java.lang.Iterable<MACAddressSection> getIterable()
```
    Description copied from interface: AddressComponent
    
    Useful for using an instance in a "for-each loop". Otherwise just call AddressComponent.iterator() directly.
    
    Specified by:
    
    getIterable in interface AddressComponent
    
    Specified by:
    
    getIterable in interface AddressSection
    
    Specified by:
    
    getIterable in interface AddressSegmentSeries
    
    Returns:
  - iterator
```
public java.util.Iterator<MACAddressSection> iterator()
```
    Description copied from interface: AddressComponent
    
    An address component can represent a single segment, address, or section, or it can represent multiple, typically a subnet or range of segment, address, or section values. Call AddressItem.isMultiple() to determine if this instance represents multiple. This method iterates through the individual elements.
    
    Specified by:
    
    iterator in interface AddressComponent
    
    Specified by:
    
    iterator in interface AddressSection
    
    Specified by:
    
    iterator in interface AddressSegmentSeries
    
    Specified by:
    
    iterator in interface java.lang.Iterable<MACAddressSection>
  - segmentsIterator
```
public java.util.Iterator<MACAddressSegment[]> segmentsIterator()
```
    Specified by:
    
    segmentsIterator in interface AddressSegmentSeries
  - toHexString
```
public java.lang.String toHexString(boolean with0xPrefix)
```
    Writes this address as a single hexadecimal value with always the exact same number of characters, with or without a preceding 0x prefix.
    
    Specified by:
    
    toHexString in interface AddressComponent
  - toNormalizedString
```
public java.lang.String toNormalizedString(AddressDivisionGrouping.StringOptions stringOptions)
```
  - toNormalizedString
```
public static java.lang.String toNormalizedString(AddressDivisionGrouping.StringOptions opts,
                                                  AddressDivisionGrouping section)
```
  - toNormalizedString
```
public java.lang.String toNormalizedString()
```
    The normalized string returned by this method is the most common representation of MAC addresses: xx:xx:xx:xx:xx:xx
    
    Specified by:
    
    toNormalizedString in interface AddressComponent
    
    Returns:
  - toCanonicalString
```
public java.lang.String toCanonicalString()
```
    This produces a canonical string using the canonical standardized IEEE 802 MAC address representation of xx-xx-xx-xx-xx-xx For range segments, '..' is used: 11-22-33..44-55-66
    
    Specified by:
    
    toCanonicalString in interface AddressSegmentSeries
    
    Returns:
  - toCompressedString
```
public java.lang.String toCompressedString()
```
    This produces a shorter string for the address that uses the canonical representation but not using leading zeroes. Each address has a unique compressed string.
    
    Specified by:
    
    toCompressedString in interface AddressSegmentSeries
    
    Returns:
  - toDottedString
```
public java.lang.String toDottedString()
```
    This produces the dotted hexadecimal format aaaa.bbbb.cccc
  - toSpaceDelimitedString
```
public java.lang.String toSpaceDelimitedString()
```
    This produces a string delimited by spaces: aa bb cc dd ee ff
  - toDashedString
```
public java.lang.String toDashedString()
```
  - toColonDelimitedString
```
public java.lang.String toColonDelimitedString()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class AddressDivisionGrouping
  - getDottedGrouping
```
public AddressDivisionGrouping getDottedGrouping()
```
  - contains
```
public boolean contains(AddressSection other)
```
    Description copied from interface: AddressSection
    
    Determines if one section contains another. Sections must have the same number of segments to be comparable. For sections which are aware of their position in an address (IPv6 and MAC), their respective positions must match to be comparable.
    
    Specified by:
    
    contains in interface AddressSection
    
    Returns:
    
    whether this section contains the given address section

Nested classes/interfaces inherited from class inet.ipaddr.format.AddressDivisionGrouping

Methods inherited from class inet.ipaddr.format.AddressDivisionGrouping

Methods inherited from class java.lang.Object

Methods inherited from interface inet.ipaddr.format.AddressDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressStringDivisionSeries

Methods inherited from interface inet.ipaddr.format.AddressItem

Methods inherited from interface java.lang.Iterable

startIndex

extended

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

MACAddressSection

equals

getSegments

getSegments

getSegments

isExtended

getSegmentCount

isEntireAddress

getSegment

getSegments

getSegments

getByteCount

getBitCount

getBitsPerSegment

getBytesPerSegment

isPrefixed

getOUISegmentCount

getODISegmentCount

getPrefixLength

isMultipleByPrefix

getSection

getSection

getOUISection

getODISection

toOUIPrefixed

toEUI64IPv6

isEUI64

isEUI64

toEUI64

replace

prepend

append

contains

getLower

getUpper

reverseBits

reverseBytes

reverseBytesPerSegment

reverseSegments

removePrefixLength

adjustPrefixBySegment

adjustPrefixLength

applyPrefixLength

setPrefixLength

getIterable

iterator

segmentsIterator

toHexString

toNormalizedString

toNormalizedString

toNormalizedString

toCanonicalString

toCompressedString

toDottedString

toSpaceDelimitedString

toDashedString

toColonDelimitedString

toString