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:
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 getBuilder(int) to return instances of its own type. See the documentation of 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	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	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(int index, java.util.Collection<? extends PyInteger> c)`
`boolean`	`addAll(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.Collection
parallelStream, removeIf, stream, toArray

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface java.util.List
replaceAll, sort, spliterator

- 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.util.Collection<PyInteger>
    
    Specified by:
    
    iterator in interface java.lang.Iterable<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>

Class BaseBytes

Nested Class Summary

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

Field Summary

Fields inherited from class org.python.core.PyObject

Constructor Summary

Method Summary

Methods inherited from class org.python.core.PySequence

Methods inherited from class org.python.core.PyObject

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.List

Constructor Detail

BaseBytes

BaseBytes

BaseBytes

Method Detail

pyinsert

__len__

asString

decode

decode

decode

__reduce__

partition

rpartition

rsplit

rsplit

rsplit

split

split

split

splitlines

splitlines

isalnum

isalpha

isdigit

islower

isspace

istitle

isupper

capitalize

lower

swapcase

title

upper

intAt

size

isEmpty

contains

iterator

toArray

toArray

add

remove

containsAll

addAll

addAll

removeAll

retainAll

clear

equals

hashCode

get

set

add

remove

indexOf

lastIndexOf

listIterator

listIterator

subList

len

reduce