com.mathworks.toolbox.javabuilder.MWCharArray Class

Namespace: com.mathworks.toolbox.javabuilder

Java class to manage MATLAB character arrays

Description

Declaration

public class MWCharArray extends MWArray

Implemented Interfaces: Disposable, java.io.Serializable, java.lang.Cloneable, java.lang.Comparable

Creation

Constructors

MWCharArray()

Creates an empty char array.

MWCharArray(char val)

Constructs a new char array that represents the primitive char argument.

MWCharArray(java.lang.Object val)

Constructs a char array that represents the Object argument.

Properties

expand all

Public Properties

`EMPTY_ARRAY` — Represent an empty array
`public static final MWArray`

A convenient, efficient, and consistent way to represent an empty array as follows:

public static final MWArray EMPTY_ARRAY

Methods

expand all

Public Methods

`applyVisitor`	`public abstract <T> T applyVisitor(AbstractMWArrayVisitor<T> v)` This method is abstract and returns a type specified by the type parameter <T>. It takes an instance of `AbstractMWArrayVisitor<T>` as an argument. The purpose of this method is to apply the visitor pattern to an MWArray object. By calling this method with an appropriate visitor, you can traverse and perform operations on elements of the MWArray in a type-safe manner. Parameters: v An instance of `AbstractMWArrayVisitor<T>` representing the visitor to be applied to the MWArray object. Returns: T The result of applying the visitor to the MWArray object, with the specific type specified by <T>.
`classID`	`public MWClassID classID()` Returns the MATLAB type of this array. Example: Getting the Class ID of a Character Array Create an MWCharArray object and then display the class ID: char[] chArray1 = {'H', 'e', 'l', 'l', 'o'}; MWCharArray A = new MWCharArray(chArray1); System.out.println("The class of A is " + A.classID()); The class of A is char Returns: `MWClassID.CHAR` for `MWCharArray`.
`clone`	`public java.lang.Object clone() throws java.lang.CloneNotSupportedException` Creates and returns a deep copy of this array. Changing the data in a deep copy does not change the original array. Example: Cloning a Character Array Object Create a clone of `MWCharArray` object A as follows: char[] chArray = {'H', 'e', 'l', 'l', 'o'}; MWCharArray A = new MWCharArray(chArray); Object C = A.clone(); System.out.println("Clone of matrix A is:"); System.out.println(C.toString()); Clone of matrix A is: Hello Throws: java.lang.CloneNotSupportedException The object's class does not implement the Cloneable interface.
`columnIndex`	`public int[] columnIndex()` Returns an array containing the column index of each element in the underlying MATLAB^® array. Specified by: `columnIndex` in class `MWArray` Returns: Array of indices.
`compareTo`	`public int compareTo(java.lang.Object obj)` Compares this array with the specified array for order. Specified by: `compareTo` in interface `java.lang.Comparable` Specified by: `compareTo` in class `MWArray` Parameters: obj Object Array to compare with this MWArray object
`deserialize`	`public static MWArray deserialize(byte[] data)` Create a new MWArray from serialized data. Parameters: data serialized array returned from MWArray.serialize Returns: the deserialized MWArray
`dispose`	`public void dispose()` Frees the native MATLAB array contained by this array. Specified by: `dispose` in interface `Disposable` Specified by: `dispose` in class `MWArray`
`equals`	`public boolean equals(java.lang.Object obj)` Indicates whether some other array is equal to this one. Specified by: `equals` in class `MWArray` Parameters: obj Object Array to compare with this MWArray object
`get`	`public java.lang.Object get(int index)` Returns the element at the specified 1-based offset in this array. Specified by: `get` in class `MWArray` Parameters: index The index of the requested element. Valid range: 1 <= index <= N, where N = total number of elements in the array. Returns: Object containing the requested element. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`get`	`public java.lang.Object get(int[] index)` Returns the element at the specified 1-based index-array in this array. Specified by: `get` in class `MWArray` Parameters: index Array of indices specifying the location of the requested element. The length of the index array must be exactly the number of dimensions of this array. Each element of the index array has the valid range: 1 <= index[i] <= N[i], where N[i] = the size of the ith dimension. Returns: Object containing the requested element. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`getChar`	`public char getChar(int index)` Returns the character at the specified 1-based offset. Parameters: index The index of the requested element. Valid range: 1 <= index <= N, where N = total number of elements in the array. Returns: Value of the requested element. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`getCell`	`public char getChar(int[] index)` Returns the character at the specified 1-based index-array. Example: Getting Character Array Data with getChar Use getChar to display the string stored in MWCharArray object A as follows: char[] chArray = {'H', 'e', 'l', 'l', 'o'}; MWCharArray A = new MWCharArray(chArray); for (int i = 1; i <= 5; i++) System.out.print(A.getChar(i)); Hello Parameters: index Array of indices specifying the location of the requested element. The length of the index array must be exactly the number of dimensions of this array. Each element of the index array has the valid range: 1 <= index[i] <= N[i], where N[i] = the size of the ith dimension. Returns: Value of the requested element. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`getData`	`public java.lang.Object getData()` Returns a 1-D array containing a copy of the data in the underlying MATLAB array. The elements of the returned array are converted according to default conversion rules. If the underlying MATLAB array is a complex numeric type, getData returns the real part. If the underlying array is a cell or struct array, toArray is recursively called on each cell. Specified by: getData in class MWArray Returns: A 1-D array of elements stored in column-wise order. The length of the returned array equals `numberOfElements()` for a non-sparse array, and `numberOfNonZeros()` for a sparse array.
`getDimensions`	`public int[] getDimensions()` Returns an array containing the size of each dimension of this array. Specified by: `getDimensions` in class `MWArray` Returns: array containing size of each dimension
`hashCode`	`public int hashCode()` Returns a hash code value for this array. Specified by: `hashCode` in class `MWArray`
`isEmpty`	`public boolean isEmpty()` Tests if this array has no elements. Specified by: `isEmpty` in class `MWArray` Returns: `true` if empty, `false` otherwise
`isSparse`	`public boolean isSparse()` Tests if this array is sparse. Specified by: `isSparse` in class `MWArray` Returns: `true` if empty, `false` otherwise
`maximumNonZeros`	`public int maximumNonZeros()` Returns the allocated capacity of a sparse array. If the underlying array is non-sparse, this method returns the same value as `numberOfElements()`. Specified by: `maximumNonZeros` in class `MWArray` Returns: Currently allocated number of non-zero elements in a sparse array.
`newInstance`	`public static MWCharArray newInstance(int[] dims)` Constructs a char array with the specified dimensions. The elements of the array are all initialized to 0. Example: Constructing a Character Array Object with newInstance Create an MWCharArray object containing the text Hello: int[] dims = {1, 5}; char[] chArray = {'H', 'e', 'l', 'l', 'o'}; String str = new String(chArray); MWCharArray A = MWCharArray.newInstance(dims, str); System.out.println("The array string is \"" + A + "\""); The array string is "Hello" Parameters: dims Array of dimension sizes. Each dimension size must be non-negative. Returns: A new MWCharArray with the specified dimensions. Throws: java.lang.NegativeArraySizeException A negative dimension size is supplied.
`newInstance`	`public static MWCharArray newInstance(int[] dims, java.lang.Object data)` Constructs a char array with the specified dimensions and initializes the array with the supplied data. The input array must be of type char[] or java.lang.String. The characters in the array are assumed to be stored in column-major order. Parameters: dims Array of dimension sizes. Each dimension size must be non-negative. data Data to initialize the array with. Returns: A new MWCharArray with the specified dimensions and initialized with the supplied data. Throws: java.lang.NegativeArraySizeException A negative dimension size is supplied. java.lang.ArrayStoreException Non-character data has been supplied.
`numberOfDimensions`	`public int numberOfDimensions()` Returns the number of dimensions of this array. Specified by: `numberOfDimensions` in class `MWArray` Returns: Number of dimensions.
`numberOfElements`	`public int numberOfElements()` Returns the total number of elements in this array. Specified by: `numberOfElements` in class `MWArray` Returns: Number of elements.
`numberOfNonZeros`	`public int numberOfNonZeros()` Returns the number of non-zero elements in a sparse array. If the underlying array is non-sparse, this method returns the same value as `numberOfElements()`. Specified by: `numberOfNonZeros` in class `MWArray` Returns: Current number of non-zero elements in a sparse array.
`readResolve`	`protected java.lang.Object readResolve() throws java.io.ObjectStreamException` Called by serialization mechanism when loading a new array from a byte stream. This method validates the correct array type. Returns: Returns this Object indicating validated array type. Throws: java.io.InvalidObjectException Attempt to load an invalid array handle. java.io.ObjectStreamException An object stream exception.
`rowIndex`	`public int[] rowIndex()` Returns an array containing the row index of each element in the underlying MATLAB array. Specified by: `columnIndex` in class `MWArray` Returns: Array of indices.
`serialize`	`public byte[] serialize() throws java.io.IOException` Serialize the MATLAB array to a byte array. Returns: Serialized MATLAB array data Throws: java.io.IOException If the array cannot be serialized. For example, executable content (function handles, class instances) cannot be serialized.
`set`	`public void set(int index, java.lang.Object element)` Replaces the element at the specified 1-based offset in this array with the specified element. Specified by: `set` in class `MWArray` Parameters: index The index of the element to replace. Valid range: 1 <= index <= N, where N = total number of elements in the array. element New element to replace at index. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`set`	`public void set(int[] index, java.lang.Object element)` Replaces the element at the specified 1-based index-array in this array with the specified element. Specified by: `set` in class `MWArray` Parameters: index Array of indices specifying the location of the element to replace. The length of the index array must be exactly the number of dimensions of this array. Each element of the index array has the valid range: 1 <= index[i] <= N[i], where N[i] = the size of the ith dimension. element New element to replace at index. If element is of type MWArray, the cell at index is set to a shared copy of the underlying MATLAB array. Otherwise, a new MATLAB array is created from element using default conversion rules and assigned to the cell at index. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`set`	`public void set(int index, char element)` Replaces the character at the specified 1-based offset in this array with the specified char value. Parameters: index The index of the element to replace. Valid range: 1 <= index <= N, where N = total number of elements in the array. element New element to replace at index. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`set`	`public void set(int[] index, char element)` Replaces the character at the specified 1-based index-array in this array with the specified char value. Example: Setting Values in a Character Array Display a phrase stored in MWCharArray object A, change one of the characters, and then display the modified phrase as follows: char[] chArray = {'G', 'a', 'r', 'y'}; MWCharArray A = new MWCharArray(chArray); System.out.println(" I think " + A + " lives here." + "\n"); System.out.println("Changing the first character to M ...\n"); int[] index = {1, 1}; A.set(index, 'M'); System.out.println(" I think " + A + " lives here." + "\n"); When run, the example above displays this output: I think Gary lives here. Changing the first character to M yields the following output: I think Mary lives here. Parameters: index Array of indices specifying the location of the element to replace. The length of the index array must be exactly the number of dimensions of this array. Each element of the index array has the valid range: 1 <= index[i] <= N[i], where N[i] = the size of the ith dimension. element New element to replace at index. Throws: java.lang.IndexOutOfBoundsException An invalid index has been supplied.
`setData`	`public void setData(java.lang.Object data)` Specified by: `setData` in class `MWArray`
`sharedCopy`	`public java.lang.Object sharedCopy()` Creates and returns a shared copy of this array. A shared copy points to the same underlying MATLAB array as the original. Changing the data in a shared copy also changes the original array. Example: Making a Shared Copy of a Character Array Object Create a shared copy of MWCharArray object A as follows: char[] chArray = {'H', 'e', 'l', 'l', 'o'}; MWCharArray A = new MWCharArray(chArray); Object S = A.sharedCopy(); System.out.print("Shared copy of matrix A is \"" + S.toString() + "\""); Shared copy of matrix A is "Hello" Returns: An MWCharArray instance representing a shared copy of the underlying MATLAB array.
`toArray`	`public java.lang.Object[] toArray()` Returns an array containing a copy of the data in the underlying MATLAB array. The returned array has the same dimensionality as the underlying MATLAB array. The elements of the returned array are converted according to default conversion rules. If the underlying MATLAB array is a complex numeric type, toArray returns the real part. If the underlying array is sparse, a full representation of the array is returned. Care should be taken when calling toArray on a sparse array with large row and column dimensions, as this action may exhaust system memory. If the underlying array is a cell or struct array, toArray is recursively called on each cell. Specified by: `toArray` in class `MWArray` Returns: An array with the same dimensionality of the MATLAB array.
`toString`	`public java.lang.String toString()` Returns a string representation of this array. Specified by: `toString` in class MWArray
`validate`	`protected void validate()` Validates the internal array handle. Called by constructors and deserialization code.

Inherited Methods

Methods inherited from class com.mathworks.toolbox.javabuilder.MWArray.

disposeArray

public static void disposeArray(java.lang.Object obj)

This method destroys any native MATLAB arrays contained in the input object and frees the memory occupied by them. This is a static method of the class and thus does not need to be invoked in reference to an instance of the class. If the input object implements the Disposable interface, the object is freed by calling its Disposable.dispose() method. If the input object represents an array of Disposable instances, each object in the array is disposed. If the input object represents an array of java.lang.Object, or a multi-dimensional array, the array is recursively processed to free each Disposable instance contained in the array.

Example: Constructing an MWNumericArray Object

MWArray[] MArr = new MWArray[10];
for (int i = 0; i < 10; i++)
    MArr[i] = new MWNumericArray();
MWArray.disposeArray(MArr);

Parameters:

obj: Object to process.

Methods inherited from class java.lang.Object.

`finalize`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`getClass`	`public final Class<?> getClass()` Returns the runtime class of this Object.
`notify`	`public final void notify()`
`notifyAll`	`public final void notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`wait`	`public final void wait(long timeout, int nanos) throws InterruptedException` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.

Examples

collapse all

Construct Initialized Character Array Object

char[] chArray1 = {'H', 'e', 'l', 'l', 'o'};
char[] chArray2 = {'W', 'o', 'r', 'l', 'd'};
MWCharArray A = new MWCharArray(chArray1);
 
System.out.println("The string in MWCharArray1 is \"" + A + "\"");

 The string in MWCharArray1 is "Hello"

Construct MWCharArray from String Object

String str = new String(chArray2);
MWCharArray A2 = new MWCharArray(str);
 
System.out.println("The string in MWCharArray2 is \"" +
                         A2 + "\"");

The string in MWCharArray2 is "World"

Version History

Introduced in R2006a

How useful was this information?

Unrated 1 star 2 stars 3 stars 4 stars 5 stars