org.python.core

## Class BaseBytes

- java.lang.Object
- - org.python.core.PyObject
  - - org.python.core.PySequence
    - - org.python.core.BaseBytes

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Iterable<PyInteger>, java.util.Collection<PyInteger>, java.util.List<PyInteger>
  Direct Known Subclasses:
    PyByteArray

      public abstract class BaseBytes
      extends PySequence
      implements java.util.List<PyInteger>

  Base class for Jython `bytearray` (and `bytes` in due course) that provides most of the Java API, including Java `List` behaviour. Attempts to modify the contents through this API will throw a `TypeError` if the actual type of the object is not mutable. It is possible for a Java client to treat this class as a `List<PyInteger>`, obtaining equivalent functionality to the Python interface in a Java paradigm.

  Subclasses must define (from `PySequence`):

  - `getslice(int, int, int)`
  - `repeat(int)`
  each returning an appropriate concrete type. Mutable subclasses should override:
  - `PySequence.pyset(int, PyObject)`
  - `PySequence.setslice(int, int, int, PyObject)`
  - `PySequence.del(int)`
  - `PySequence.delRange(int, int)`
  since the default implementations will otherwise throw an exception.

  Many of the methods implemented here are inherited or thinly wrapped by `PyByteArray`, which offers them as Java API, or exposes them as Python methods. These prototype Python methods mostly accept a `PyObject` as argument, where you might have expected a `byte[]` or `BaseBytes`, in order to accommodate the full range of types accepted by the Python equivalent: usually, any `PyObject` that implements `BufferProtocol`, providing a one-dimensional array of bytes, is an acceptable argument. In the documentation, the reader will often see the terms "byte array" or "object viewable as bytes" instead of `BaseBytes` when this broader scope is intended.

  Where the methods return a `BaseBytes`, this is will normally be an instance of the class of the object on which the method was actually called. For example `capitalize()`, defined in `BaseBytes` to return a BaseBytes, actually returns a `PyByteArray` when applied to a `bytearray`. Or it may be that the method returns a `PyList` of instances of the target type, for example `rpartition(PyObject)`. This is achieved by the sub-class defining `getslice(int, int, int)` and `getResult(Builder)` to return instances of its own type. See the documentation of the particular methods for more information.

  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.python.core.PyObject

      `PyObject.ConversionException`

  - ### Field Summary

    - ### Fields inherited from class org.python.core.PyObject

      `gcMonitorGlobal, TYPE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BaseBytes(PyType type)` Constructs a zero-length `BaseBytes` of explicitly-specified sub-type.
    `BaseBytes(PyType type, int size)` Constructs a zero-filled array of defined size and type.
    `BaseBytes(PyType type, int[] value)` Constructs a byte array of defined type by copying values from int[].

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `__len__()` Equivalent to the standard Python __len__ method.
    `PyObject` | `__reduce__()` Support for pickling byte arrays: reduce a byte array to the actual type, arguments for (re-)construction of the object, and the dictionary of any user-defined sub-class.
    `void` | `add(int index, PyInteger element)`
    `boolean` | `add(PyInteger o)`
    `boolean` | `addAll(java.util.Collection<? extends PyInteger> c)`
    `boolean` | `addAll(int index, java.util.Collection<? extends PyInteger> c)`
    `java.lang.String` | `asString()` Present the bytes of a byte array, with no decoding, as a Java String.
    `BaseBytes` | `capitalize()` Java API equivalent of Python `capitalize()`.
    `void` | `clear()`
    `boolean` | `contains(java.lang.Object o)` Returns true if this list contains the specified value.
    `boolean` | `containsAll(java.util.Collection<?> c)`
    `PyObject` | `decode()` Decode the byte array to a Unicode string according to the default encoding.
    `PyObject` | `decode(java.lang.String encoding)` Decode the byte array to a Unicode string according to the specified encoding and default error policy.
    `PyObject` | `decode(java.lang.String encoding, java.lang.String errors)` Decode the byte array to a Unicode string according to the specified encoding and error policy.
    `boolean` | `equals(java.lang.Object other)` Test for the equality of (the value of) this byte array to the object `other`.
    `PyInteger` | `get(int index)`
    `int` | `hashCode()`
    `int` | `indexOf(java.lang.Object o)`
    `int` | `intAt(int index)` Return the Python byte (in range 0 to 255 inclusive) at the given index.
    `boolean` | `isalnum()` Java API equivalent of Python `isalnum()`.
    `boolean` | `isalpha()` Java API equivalent of Python `isalpha()`.
    `boolean` | `isdigit()` Java API equivalent of Python `isdigit()`.
    `boolean` | `isEmpty()`
    `boolean` | `islower()` Java API equivalent of Python `islower()`.
    `boolean` | `isspace()` Java API equivalent of Python `isspace()`.
    `boolean` | `istitle()` Java API equivalent of Python `istitle()`.
    `boolean` | `isupper()` Java API equivalent of Python `isupper()`.
    `java.util.Iterator<PyInteger>` | `iterator()`
    `int` | `lastIndexOf(java.lang.Object o)`
    `java.util.ListIterator<PyInteger>` | `listIterator()`
    `java.util.ListIterator<PyInteger>` | `listIterator(int index)`
    `BaseBytes` | `lower()` Java API equivalent of Python `lower()`.
    `PyTuple` | `partition(PyObject sep)` Implementation of Python `partition(sep)`, returning a 3-tuple of byte arrays (of the same type as `this`).
    `void` | `pyinsert(int index, PyObject element)` Insert the element (interpreted as a Python byte value) at the given index.
    `PyInteger` | `remove(int index)`
    `boolean` | `remove(java.lang.Object o)`
    `boolean` | `removeAll(java.util.Collection<?> c)`
    `boolean` | `retainAll(java.util.Collection<?> c)`
    `PyTuple` | `rpartition(PyObject sep)` Implementation of Python `rpartition(sep)`, returning a 3-tuple of byte arrays (of the same type as `this`).
    `PyList` | `rsplit()` Implementation of Python `rsplit()`, that returns a list of the words in the byte array, using whitespace as the delimiter.
    `PyList` | `rsplit(PyObject sep)` Implementation of Python `rsplit(sep)`, that returns a list of the words in the byte array, using `sep` as the delimiter.
    `PyList` | `rsplit(PyObject sep, int maxsplit)` Implementation of Python `rsplit(sep, maxsplit)`, that returns a list of the words in the byte array, using `sep` as the delimiter.
    `PyInteger` | `set(int index, PyInteger element)`
    `int` | `size()` Number of bytes in `bytearray` (or `bytes`) object.
    `PyList` | `split()` Implementation of Python `split()`, that returns a list of the words in the byte array, using whitespace as the delimiter.
    `PyList` | `split(PyObject sep)` Implementation of Python `split(sep)`, that returns a list of the words in the byte array, using `sep` as the delimiter.
    `PyList` | `split(PyObject sep, int maxsplit)` Implementation of Python `split(sep, maxsplit)`, that returns a list of the words in the byte array, using `sep` as the delimiter.
    `PyList` | `splitlines()` Implementation of Python `splitlines()`, returning a list of the lines in the byte array, breaking at line boundaries.
    `PyList` | `splitlines(boolean keepends)` Implementation of Python `splitlines(keepends)`, returning a list of the lines in the string, breaking at line boundaries.
    `java.util.List<PyInteger>` | `subList(int fromIndex, int toIndex)`
    `BaseBytes` | `swapcase()` Java API equivalent of Python `swapcase()`.
    `BaseBytes` | `title()` Java API equivalent of Python `title()`.
    `java.lang.Object[]` | `toArray()`
    `<T> T[]` | `toArray(T[] a)`
    `BaseBytes` | `upper()` Java API equivalent of Python `upper()`.

    - ### Methods inherited from class org.python.core.PySequence

      `__delitem__, __delslice__, __eq__, __finditem__, __finditem__, __ge__, __getitem__, __getslice__, __gt__, __iter__, __le__, __lt__, __ne__, __nonzero__, __setitem__, __setitem__, __setslice__, __tojava__, isMappingType, isNumberType, isSequenceType`

    - ### Methods inherited from class org.python.core.PyObject

      `__abs__, __add__, __and__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __cmp__, __coerce__, __coerce_ex__, __complex__, __contains__, __delattr__, __delattr__, __delete__, __delitem__, __delslice__, __dir__, __div__, __divmod__, __ensure_finalizer__, __findattr__, __findattr__, __findattr_ex__, __finditem__, __float__, __floordiv__, __format__, __get__, __getattr__, __getattr__, __getitem__, __getnewargs__, __getslice__, __hash__, __hex__, __iadd__, __iand__, __idiv__, __idivmod__, __ifloordiv__, __ilshift__, __imod__, __imul__, __index__, __int__, __invert__, __ior__, __ipow__, __irshift__, __isub__, __iternext__, __itruediv__, __ixor__, __long__, __lshift__, __mod__, __mul__, __neg__, __not__, __oct__, __or__, __pos__, __pow__, __pow__, __radd__, __rand__, __rdiv__, __rdivmod__, __reduce_ex__, __reduce_ex__, __repr__, __rfloordiv__, __rlshift__, __rmod__, __rmul__, __ror__, __rpow__, __rrshift__, __rshift__, __rsub__, __rtruediv__, __rxor__, __set__, __setattr__, __setattr__, __setitem__, __setslice__, __str__, __sub__, __truediv__, __trunc__, __unicode__, __xor__, _add, _and, _callextra, _cmp, _div, _divmod, _doget, _doget, _doset, _eq, _floordiv, _ge, _gt, _iadd, _iand, _idiv, _idivmod, _ifloordiv, _ilshift, _imod, _imul, _in, _ior, _ipow, _irshift, _is, _isnot, _isub, _itruediv, _ixor, _jcall, _jcallexc, _jthrow, _le, _lshift, _lt, _mod, _mul, _ne, _notin, _or, _pow, _rshift, _sub, _truediv, _xor, asDouble, asIndex, asIndex, asInt, asInt, asIterable, asLong, asLong, asName, asName, asString, asStringOrNull, asStringOrNull, bit_length, conjugate, delDict, delType, dispatch__init__, fastGetClass, fastGetDict, getDict, getType, implementsDescrDelete, implementsDescrGet, implementsDescrSet, invoke, invoke, invoke, invoke, invoke, invoke, isCallable, isDataDescr, isIndex, isInteger, noAttributeError, object___subclasshook__, readonlyAttributeError, setDict, setType, toString`

    - ### Methods inherited from class java.lang.Object

      `getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface java.util.List

      `replaceAll, sort, spliterator`

    - ### Methods inherited from interface java.util.Collection

      `parallelStream, removeIf, stream`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach`

- - ### Constructor Detail

    - #### BaseBytes

          public BaseBytes(PyType type)

      Constructs a zero-length `BaseBytes` of explicitly-specified sub-type.
      Parameters:
        `type` - explicit Jython type

    - #### BaseBytes

          public BaseBytes(PyType type,
                           int size)

      Constructs a zero-filled array of defined size and type.
      Parameters:
        `size` - required
        `type` - explicit Jython type

    - #### BaseBytes

          public BaseBytes(PyType type,
                           int[] value)

      Constructs a byte array of defined type by copying values from int[].
      Parameters:
        `type` - explicit Jython type
        `value` - source of values (and size)

  - ### Method Detail

    - #### pyinsert

          public void pyinsert(int index,
                               PyObject element)

      Insert the element (interpreted as a Python byte value) at the given index. The default implementation produces a Python TypeError, for the benefit of immutable types. Mutable types must override it.
      Parameters:
        `index` - to insert at
        `element` - to insert (by value)
      Throws:
        `PyException` - `IndexError` if the index is outside the array bounds
        `PyException` - `ValueError` if element<0 or element>255
        `PyException` - `TypeError` if the subclass is immutable

    - #### __len__

          public int __len__()

      Description copied from class: `PyObject`
      Equivalent to the standard Python __len__ method. Part of the mapping discipline.
      Overrides:
        `__len__` in class `PyObject`
      Returns:
        the length of the object

    - #### asString

          public java.lang.String asString()

      Present the bytes of a byte array, with no decoding, as a Java String. The bytes are treated as unsigned character codes, and copied to the to the characters of a String with no change in ordinal value. This could also be described as 'latin-1' or 'ISO-8859-1' decoding of the byte array to a String, since this character encoding is numerically equal to Unicode.
      Overrides:
        `asString` in class `PyObject`
      Returns:
        the byte array as a String

    - #### decode

          public PyObject decode()

      Decode the byte array to a Unicode string according to the default encoding. The returned PyObject should be a `PyUnicode`, since the default codec is well-behaved.
      Returns:
        object containing the decoded characters

    - #### decode

          public PyObject decode(java.lang.String encoding)

      Decode the byte array to a Unicode string according to the specified encoding and default error policy. The returned PyObject will usually be a `PyUnicode`, but in practice it is whatever the `decode` method of the codec decides.
      Parameters:
        `encoding` - the name of the codec (uses default codec if `null`)
      Returns:
        object containing the decoded characters

    - #### decode

          public PyObject decode(java.lang.String encoding,
                                 java.lang.String errors)

      Decode the byte array to a Unicode string according to the specified encoding and error policy. The returned PyObject will usually be a `PyUnicode`, but in practice it is whatever the `decode` method of the codec decides.
      Parameters:
        `encoding` - the name of the codec (uses default codec if `null`)
        `errors` - the name of the error policy (uses 'strict' if `null`)
      Returns:
        object containing the decoded characters

    - #### __reduce__

          public PyObject __reduce__()

      Support for pickling byte arrays: reduce a byte array to the actual type, arguments for (re-)construction of the object, and the dictionary of any user-defined sub-class.
      Overrides:
        `__reduce__` in class `PyObject`
      Returns:
        PyTuple that is first stage in pickling byte array

    - #### partition

          public PyTuple partition(PyObject sep)

      Implementation of Python `partition(sep)`, returning a 3-tuple of byte arrays (of the same type as `this`). Split the string at the first occurrence of `sep`, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing the string itself, followed by two empty byte arrays.

      The elements of the `PyTuple` returned by this method are instances of the same actual type as `this`.

      Parameters:
        `sep` - the separator on which to partition this byte array
      Returns:
        a tuple of (head, separator, tail)

    - #### rpartition

          public PyTuple rpartition(PyObject sep)

      Implementation of Python `rpartition(sep)`, returning a 3-tuple of byte arrays (of the same type as `this`). Split the string at the rightmost occurrence of `sep`, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing two empty byte arrays, followed by the byte array itself.

      The elements of the `PyTuple` returned by this method are instances of the same actual type as `this`.

      Parameters:
        `sep` - the separator on which to partition this byte array
      Returns:
        a tuple of (head, separator, tail)

    - #### rsplit

          public PyList rsplit()

      Implementation of Python `rsplit()`, that returns a list of the words in the byte array, using whitespace as the delimiter. See `rsplit(PyObject, int)`.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Returns:
        PyList of byte arrays that result from the split

    - #### rsplit

          public PyList rsplit(PyObject sep)

      Implementation of Python `rsplit(sep)`, that returns a list of the words in the byte array, using `sep` as the delimiter. See `rsplit(PyObject, int)` for the semantics of the separator.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Parameters:
        `sep` - `bytes`, or object viewable as bytes, defining the separator
      Returns:
        PyList of byte arrays that result from the split

    - #### rsplit

          public PyList rsplit(PyObject sep,
                               int maxsplit)

      Implementation of Python `rsplit(sep, maxsplit)`, that returns a list of the words in the byte array, using `sep` as the delimiter. If `maxsplit` is given, at most `maxsplit` splits are done (thus, the list will have at most `maxsplit+1` elements). If `maxsplit` is not specified, then there is no limit on the number of splits (all possible splits are made).

      The semantics of `sep` and maxcount are identical to those of `split(sep, maxsplit)` , except that splits are generated from the right (and pushed onto the front of the result list). The result is only different from that of `split` if `maxcount` limits the number of splits. For example,

      - `bytearray(b' 1 2 3 ').rsplit()` returns `[bytearray(b'1'), bytearray(b'2'), bytearray(b'3')]`, and
      - `bytearray(b' 1 2 3 ').rsplit(None, 1)` returns `[bytearray(b' 1 2'), bytearray(b'3')]`.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Parameters:
        `sep` - `bytes`, or object viewable as bytes, defining the separator
        `maxsplit` - maximum number of splits
      Returns:
        PyList of byte arrays that result from the split

    - #### split

          public PyList split()

      Implementation of Python `split()`, that returns a list of the words in the byte array, using whitespace as the delimiter. See `split(PyObject, int)`.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Returns:
        PyList of byte arrays that result from the split

    - #### split

          public PyList split(PyObject sep)

      Implementation of Python `split(sep)`, that returns a list of the words in the byte array, using `sep` as the delimiter. See `split(PyObject, int)` for the semantics of the separator.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Parameters:
        `sep` - `bytes`, or object viewable as bytes, defining the separator
      Returns:
        PyList of byte arrays that result from the split

    - #### split

          public PyList split(PyObject sep,
                              int maxsplit)

      Implementation of Python `split(sep, maxsplit)`, that returns a list of the words in the byte array, using `sep` as the delimiter. If `maxsplit` is given, at most `maxsplit` splits are done. (Thus, the list will have at most `maxsplit+1` elements). If `maxsplit` is not specified, then there is no limit on the number of splits (all possible splits are made).

      If `sep` is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). The `sep` argument may consist of multiple characters (for example, `'1<>2<>3'.split('<>')` returns `['1', '2', '3']`). Splitting an empty string with a specified separator `['']`.

      If `sep` is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a `None` separator returns `[]`. For example,

      - `bytearray(b' 1 2 3 ').split()` returns `[bytearray(b'1'), bytearray(b'2'), bytearray(b'3')]`, and
      - `bytearray(b' 1 2 3 ').split(None, 1)` returns `[bytearray(b'1'), bytearray(b'2 3 ')]`.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Parameters:
        `sep` - `bytes`, or object viewable as bytes, defining the separator
        `maxsplit` - maximum number of splits
      Returns:
        PyList of byte arrays that result from the split

    - #### splitlines

          public PyList splitlines()

      Implementation of Python `splitlines()`, returning a list of the lines in the byte array, breaking at line boundaries. Line breaks are not included in the resulting segments.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Returns:
        List of segments

    - #### splitlines

          public PyList splitlines(boolean keepends)

      Implementation of Python `splitlines(keepends)`, returning a list of the lines in the string, breaking at line boundaries. Line breaks are not included in the resulting list unless `keepends` is true.

      The elements of the `PyList` returned by this method are instances of the same actual type as `this`.

      Parameters:
        `keepends` - if true, include the end of line bytes(s)
      Returns:
        PyList of segments

    - #### isalnum

          public boolean isalnum()

      Java API equivalent of Python `isalnum()`. This method treats the bytes as US-ASCII code points.
      Returns:
        true if all bytes in the array are code points for alphanumerics and there is at least one byte, false otherwise.

    - #### isalpha

          public boolean isalpha()

      Java API equivalent of Python `isalpha()`. This method treats the bytes as US-ASCII code points.
      Returns:
        true if all bytes in the array are alphabetic and there is at least one byte, false otherwise

    - #### isdigit

          public boolean isdigit()

      Java API equivalent of Python `isdigit()`. This method treats the bytes as US-ASCII code points.
      Returns:
        true if all bytes in the array are code points for digits and there is at least one byte, false otherwise.

    - #### islower

          public boolean islower()

      Java API equivalent of Python `islower()`. This method treats the bytes as US-ASCII code points.
      Returns:
        true if all cased bytes in the array are code points for lowercase characters and there is at least one cased byte, false otherwise.

    - #### isspace

          public boolean isspace()

      Java API equivalent of Python `isspace()`. This method treats the bytes as US-ASCII code points.
      Returns:
        true if all the bytes in the array are code points for whitespace characters and there is at least one byte, false otherwise.

    - #### istitle

          public boolean istitle()

      Java API equivalent of Python `istitle()`. This method treats the bytes as US-ASCII code points.
      Returns:
        true if the string is a titlecased string and there is at least one cased byte, for example uppercase characters may only follow uncased bytes and lowercase characters only cased ones. Return false otherwise.

    - #### isupper

          public boolean isupper()

      Java API equivalent of Python `isupper()`. This method treats the bytes as US-ASCII code points.
      Returns:
        true if all cased bytes in the array are code points for uppercase characters and there is at least one cased byte, false otherwise.

    - #### capitalize

          public BaseBytes capitalize()

      Java API equivalent of Python `capitalize()`. This method treats the bytes as US-ASCII code points. The `BaseBytes` returned by this method has the same actual type as `this/self`.
      Returns:
        a copy of the array with its first character capitalized and the rest lowercased.

    - #### lower

          public BaseBytes lower()

      Java API equivalent of Python `lower()`. This method treats the bytes as US-ASCII code points. The `BaseBytes` returned by this method has the same actual type as `this/self`.
      Returns:
        a copy of the array with all the cased characters converted to lowercase.

    - #### swapcase

          public BaseBytes swapcase()

      Java API equivalent of Python `swapcase()`. This method treats the bytes as US-ASCII code points. The `BaseBytes` returned by this method has the same actual type as `this/self`.
      Returns:
        a copy of the array with uppercase characters converted to lowercase and vice versa.

    - #### title

          public BaseBytes title()

      Java API equivalent of Python `title()`. The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries, which may not be the desired result. The `BaseBytes` returned by this method has the same actual type as `this/self`.
      Returns:
        a titlecased version of the array where words start with an uppercase character and the remaining characters are lowercase.

    - #### upper

          public BaseBytes upper()

      Java API equivalent of Python `upper()`. Note that `x.upper().isupper()` might be `false` if the array contains uncased characters. The `BaseBytes` returned by this method has the same actual type as `this/self`.
      Returns:
        a copy of the array with all the cased characters converted to uppercase.

    - #### intAt

          public int intAt(int index)
                    throws PyException

      Return the Python byte (in range 0 to 255 inclusive) at the given index.
      Parameters:
        `index` - of value in byte array
      Returns:
        the integer value at the index
      Throws:
        `PyException` - `IndexError` if the index is outside the array bounds

    - #### size

          public int size()

      Number of bytes in `bytearray` (or `bytes`) object.
      Specified by:
        `size` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `size` in interface `java.util.List<PyInteger>`
      Returns:
        Number of bytes in byte array.
      See Also:
        `List.size()`

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `isEmpty` in interface `java.util.List<PyInteger>`

    - #### contains

          public boolean contains(java.lang.Object o)

      Returns true if this list contains the specified value. More formally, returns true if and only if this list contains at least one integer e such that o.equals(PyInteger(e)).
      Specified by:
        `contains` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `contains` in interface `java.util.List<PyInteger>`

    - #### iterator

          public java.util.Iterator<PyInteger> iterator()

      Specified by:
        `iterator` in interface `java.lang.Iterable<PyInteger>`
      Specified by:
        `iterator` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `iterator` in interface `java.util.List<PyInteger>`

    - #### toArray

          public java.lang.Object[] toArray()

      Specified by:
        `toArray` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `toArray` in interface `java.util.List<PyInteger>`

    - #### toArray

          public <T> T[] toArray(T[] a)

      Specified by:
        `toArray` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `toArray` in interface `java.util.List<PyInteger>`

    - #### add

          public boolean add(PyInteger o)

      Specified by:
        `add` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `add` in interface `java.util.List<PyInteger>`

    - #### remove

          public boolean remove(java.lang.Object o)

      Specified by:
        `remove` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `remove` in interface `java.util.List<PyInteger>`

    - #### containsAll

          public boolean containsAll(java.util.Collection<?> c)

      Specified by:
        `containsAll` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `containsAll` in interface `java.util.List<PyInteger>`

    - #### addAll

          public boolean addAll(java.util.Collection<? extends PyInteger> c)

      Specified by:
        `addAll` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `addAll` in interface `java.util.List<PyInteger>`

    - #### addAll

          public boolean addAll(int index,
                                java.util.Collection<? extends PyInteger> c)

      Specified by:
        `addAll` in interface `java.util.List<PyInteger>`

    - #### removeAll

          public boolean removeAll(java.util.Collection<?> c)

      Specified by:
        `removeAll` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `removeAll` in interface `java.util.List<PyInteger>`

    - #### retainAll

          public boolean retainAll(java.util.Collection<?> c)

      Specified by:
        `retainAll` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `retainAll` in interface `java.util.List<PyInteger>`

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `clear` in interface `java.util.List<PyInteger>`

    - #### equals

          public boolean equals(java.lang.Object other)

      Test for the equality of (the value of) this byte array to the object `other`. In the case where `other` is a `PyObject`, the comparison used is the standard Python `==` operation through `PyObject`. When `other` is not a `PyObject`, this object acts as a `List<PyInteger>`.
      Specified by:
        `equals` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `equals` in interface `java.util.List<PyInteger>`
      Overrides:
        `equals` in class `PyObject`
      Parameters:
        `other` - object to compare this byte array to
      Returns:
        `true` if and only if this byte array is equal (in value) to `other`
      See Also:
        `List.equals(java.lang.Object)`

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in interface `java.util.Collection<PyInteger>`
      Specified by:
        `hashCode` in interface `java.util.List<PyInteger>`
      Overrides:
        `hashCode` in class `PyObject`

    - #### get

          public PyInteger get(int index)

      Specified by:
        `get` in interface `java.util.List<PyInteger>`

    - #### set

          public PyInteger set(int index,
                               PyInteger element)

      Specified by:
        `set` in interface `java.util.List<PyInteger>`

    - #### add

          public void add(int index,
                          PyInteger element)

      Specified by:
        `add` in interface `java.util.List<PyInteger>`

    - #### remove

          public PyInteger remove(int index)

      Specified by:
        `remove` in interface `java.util.List<PyInteger>`

    - #### indexOf

          public int indexOf(java.lang.Object o)

      Specified by:
        `indexOf` in interface `java.util.List<PyInteger>`

    - #### lastIndexOf

          public int lastIndexOf(java.lang.Object o)

      Specified by:
        `lastIndexOf` in interface `java.util.List<PyInteger>`

    - #### listIterator

          public java.util.ListIterator<PyInteger> listIterator()

      Specified by:
        `listIterator` in interface `java.util.List<PyInteger>`

    - #### listIterator

          public java.util.ListIterator<PyInteger> listIterator(int index)

      Specified by:
        `listIterator` in interface `java.util.List<PyInteger>`

    - #### subList

          public java.util.List<PyInteger> subList(int fromIndex,
                                                   int toIndex)

      Specified by:
        `subList` in interface `java.util.List<PyInteger>`

Jython homepage