es:manual:items:generativos:siette.util.corpus.table []

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
===== siette.util.corpus.Table =====
Esta clase da soporte al manejo de [[es:manual:items:generativos:tablas|tablas]], [[es:manual:items:generativos:bases_de_datos|bases de datos]] y [[es:manual:items:generativos:web-semantica|web semántica]]. Una tabla es una lista no ordenada de //registros//. Cada uno de estos registros tiene un conjunto de //atributos//, (tambien llamados //campos// por analogía con los //sistemas de bases de datos//) que toman //valores//. Una tabla puede describirse mediante un fichero cuya primera línea (opcionalmente) contiene los nombres de los campos, y las siguientes líneas, una por //registro// los valores de cada uno de los //atributos//. El tamaño de las tablas es teóricamente ilimitado, aunque evidentemente nada hay //ilimitado// en informática, simplemente no se especifica su tamaño.

Esta clase soporta tanto fichero de texto en formato CSV con la extensión ''.txt'' o ''.csv''; o ficheros en formato de //hoja de cálculo// con extendión ''.xlx'' o ''.xlsx''. 


==== Constructores ====
<code java>
public Table(String sURL, boolean hasTitleRow, String separator, String charSet, boolean filterHTML)
public Table(String sURL, boolean hasTitleRow, String separator)
public Table(String sURL, String separator, String charSet)
public Table(String sURL, String separator)
public Table(String sURL, boolean hasTitleRow)
public Table(String sURL)
public Table(Table table)
public Table()
</code>

Por comodidad de programación se han definido varios constructores. Unos llaman a otros pasándoles parámetros por defecto. Si se construye el objeto sin inicializarlo la primera operación debe ser la llamada al método ''getTable''.
Los constructores resuelven de forma inteligente la carga del fichero, dependiendo de su extensión. Por ejemplo los ficheros con extensión ''.xls'' se consideran ficheros de Excel en formato antiguo.

El constructor ''Table(Table table)'' es un constructor de copia, duplica la. tabla que se le pasa como parámetro construyendo una nueva instancia.

^ Parámetro ^ Descripción ^Valor por defecto ^
|''sURL'' | Contiene la dirección web (URI) del fichero que contiene la tabla. Esta dirección puede ser relativa al [[es:manual:temas#directorio auxiliar]] de la asignatura o absoluta, si se trata de una localización externa a Siette |  |
|''hasTitleRow'' | Indica si la tabla contiene una primera fila con los nombres de los campos | ''true'' |
|''separator'' | Es una secuencia de caracteres que se usa en el método ''split'' de la clase ''String'' para separar los valores de los atributos | ''" \t,"'' |
|''charSet'' | Sistema de codificación del fichero que contiene la tabla | ''"UTF-8"'' |
|''filterHTML'' | Indica a Siette que el fichero contiene caracteres especiales y que al presentarlos debe convertirlos en entidades HTML. | ''true'' |

==== setRandom ====
<code java>
public void setRandom(Random random)
</code>

Inicializa la clase con un determinado objeto de la clase ''siette.util.Random'' de manera que este objeto determine la secuencia aleatoria de elecciones que se vayan a realizar. Es decir, si se pide a un objeto de la clase ''Table'' que seleccione una entrada aleatoriamente y despues otra, la clase usaran este objeto ''random'' para hacer la selección. Suponiendo que se eligen las entradas X e Y con este objeto ''random'', siempre que se use ese mismo objeto (creado con una misma semilla), se volveran a elegir exactamente las entradas X e Y.

Este comportamiento determinista es el que permite elegir dos entradas de forma aleatoria cuando se plantea la pregunta y volver a elegir las mismas entradas cuando se tiene que volver a plantear la misma pregunta al alumno, o bien cuando se tiene que mostrar al profesor la instancia de la pregunta a la que respondió el alumno. 

Cuando se usa la clase ''Table'' desde Siette, ya se incluye internamente un objeto ''random'' diferente para cada instancia de cada pregunta, por lo que no es necesario llamar de forma explicita a este método.

==== setTable ====
<code java>
public void setTable(String sURL, boolean hasTitleRow)
public void setTable(String sURL, boolean hasTitleRow, String separator)
public void setTableXLS(String sURL, boolean hasTitleRow)
public void setTableXLSX(String sURL, boolean hasTitleRow)
</code>

Estos métodos sirven para cargar un fichero que contenga una tabla. Los tres primeros usan ficheros de texto, y los dos últimos ficheros de //hojas de cálculo//. (Ver la sección [[#constructores]] para el significado de los parámetro)
==== setExclusive ====
<code java>
public void setExclusive()
public void setNotExclusive()
</code>

La selección en una tabla tiene dos modos de funcionamiento //exclusivo// y //no exclusivo//. El modo //exclusivo// que es el que se usa por defecto elimina  de la tabla cada registro que se haya seleccionando previamente, de manera que no se pueda seleccionar dos veces el mismo registro. El modo //no exclusivo// si lo permite.
Si no se especifica lo contrario, el modo por defecto es //exclusivo//.
==== setFilterHTML ====
<code java>
public void setFilterHTML()
public void setNotFilterHTML()
</code>

Los ficheros de tablas pueden contener caracteres especiales que cuando se presentan en una página web pueden no mostrarse correctamente. Para inidcar que Siette debe transformarr estos caracteres en secuencias correspondientes a [[https://www.w3schools.com/html/html_entities.asp|entidades HTML]]. Por defecto esta opción esta activada, salvo que expresamente se llame al método ''setNotFilterHTML''
==== setCharSet ====
<code java>
public void setCharSet(String cs)
</code>

Indica el tipo de codificación del fichero de entrada. Por defecto ''UTF-8''. Hay que llamar a este método antes de la lectura del fichero.
==== setMatchMode ====
<code java>
public void setMatchMode(int mode)
public void setExactMatch()
public void setPartialMatch()
</code>

Cuando se realizan búsquedas en la tabla, hay dos modos de hacerlo considerando que debe haber conincidencia //total//, o //parcial// entre el contenido de la tabla y la cadena de búsqueda. Por ejemplo, si la tabla contiene el valor''alineamiento'' y la cadena de búsqueda es ''linea'', la busqueda tendrá exito en el caso de que sea en modo //parcial// ya que parte de la cadena de la tabla contiene la cadena de búsqueda. Sin embargo si el modo es //total// este término no se considerará correspondiente a la búsqueda. Por fecto el modo es //parcial//.

Nótese que la secuencia de búsqueda es ''línea'' (con acento), a pesar de que el modo sea //parcial// puede que no se encuentre este valor, depende si se consideran iguales las letras acentuadas y no acentuadas. Ver [[#setIgnoreCase]] y [[#setIgnoreAccents]].
==== setIgnoreCase ====
<code java>
public void setIgnoreCase()
public void setCaseSensitive()
</code>

Indica a Siette que al realizar las búsquedas en la tabla debe considerar como la misma letra las máyusculas y las minúsculas, o por el contrario, considerar que son letras diferentes.

==== setIgnoreAccent ====
<code java>
public void setIgnoreAccent()
public void setNotIgnoreAccent()
</code>

Indica a Siette que al realizar las búsquedas en la tabla debe considerar como la misma letra los carecteres acentuados y los no acentuados, o por el contrario, considerar que son letras diferentes.

==== size ====
<code java>
public int size()
public int nRows()
public int nCols()
</code>

Los métodos ''size'' y ''nRows'' devuelven el número de filas de la tabla. El método ''nCols'' devuelve el número de columnas (//atributos//).

==== sort ====
<code java>
public Table sort(int n)
public Table sort(String nombreColumna)
public Table sort(int n, boolean descendente)
public Table sort(String nombreColumna, boolean descendente)
</code>

Devuelve una tabla con las filas ordenadas según la n-sima columna, o bien el de la columna etiquetada con el valor ''nombreColumna'' . El segundo parámetro, en caso de usarse con el valor ''true'' indicaría que la ordenación se realizaría en orden inverso.

==== selectTable ====
<code java>
public Table selectTable(int columnPos, String[] attPos, int modePos, int columnNeg, String[] attNeg, int modeNeg )
public Table selectTable(int columnPos, String[] attPos, int columnNeg, String[] attNeg)
public Table selectTable(int columnPos, String[] attPos, int modePos)
public Table selectTable(int columnPos, String[] attPos)
public Table selectTable(int columnPos, String attPos)

public Table selectTable(String namePos, String[] attPos, int modePos, String nameNeg, String[] attNeg, int modeNeg )
public Table selectTable(String namePos, String[] attPos,  String nameNeg, String[] attNeg)
public Table selectTable(String namePos, String[] attPos, int modePos)
public Table selectTable(String namePos, String[] attPos)
public Table selectTable(String namePos, String attPos)
</code>

Todos estos métodos devuelven una subtabla a partir de la tabla original. Se han implementado diversos métodos para mayor facilidad en la programación, pero en realidad son el mismo método usando valores por defecto. La siguiente tabla indica el significado de cada uno de los parámetros:

^ Parámetro ^ Descripción ^Valor por defecto ^
|''columnPos'' | Posición de la columna en la que se realiza la búsqueda. Téngase en cuenta que la numeración empieza en 0, por lo que la primera columna es la 0, la segunda la 1, y así sucesivamente. |  |
|''namePos'' | En vez de especificar el número de la columna, ésta se identifica mediante el nombre del atributo que aparece en la primera fila de la tabla. |  |
|''attPos'' | Es un array que contiene la lista de valores que deben contnener los atributos que se buscan | ''new String[] {}'' |
|''modePos'' | Puede tener dos valores ''Table.ALL'' y ''Table.ANY''. El primer valor indica que los registros que se buscan deben contener TODOS los valores de ''attPos'' en el campo especificado mediante ''columnPos'' o ''namePos''. El segundo valor indica que es suficient si contiene ALGUNO de estos valores. | ''Table.ALL'' |
|''columnNeg'' | Igual que ''columnPos'', pero especificando la columna en la que debe aplicarse la condición de que los valores de ''attNeg'' no estén. | |
|''nameNeg'' | Igual que el anterior pero indicando el nombre de la columna | |
|''attNeg'' | Lo mismo que ''attPos'' pero especificando lo valores de los atributos que no deben estar en la columna ''columnNeg''  | ''new String[] {}'' |
|''modeNeg'' | Igual que ''modeNeg'', pero con el significado negativo, es decir el modo ''Table.ALL'' indicaría que en el campo señalado por ''columnNeg'' o ''nameNeg'' no debe contener TODOS los valores listados en ''attNeg''. La opcion ''Table.ANY'' indica que no debe contener ninguno de estos valores.  | ''Table.ANY'' |

Supongamos que la ttabla contiene una descripcion de prendas de vestir, y que existen los campos ''NOMBRE'', ''TALLA'' y ''COLOR''. Y sea el siguiente programa:

     Table t = new Table(...);
     String[] tallas = {"38","39","40"}
     String[] colores = {"rojo","azul"};
     Table t2 = t.selectTable("TALLA", tallas, Table.ANY, "COLOR", colores, Table.ANY);

La instrucción ''selectTable'' forma una subtabla que contiene solamente los registros que en el campo ''TALLA'' tienen el valor ''28'', ''39'' o ''40'', y que en el campo ''COLOR'' no tienen ni el valor ''rojo'', ni el valor ''azul''. La instrucción

     Table t3 = t.selectTable("COLOR", "rojo");

selecciona todos los registros que en el campo ''COLOR'' tengan el valor ''rojo''. La tabla creada tendrá los mismos campos que la tabla original y conservará las opciones asignadas a la tabla original, como [[#setFilterHTML], [[#setIgnoreCase]], etc.

Para hacer búsquedas múltiples simplemente se pueden encadenar llamadas a este método. Por ejemplo:

    Table t4 = t.selectTable("COLOR", "rojo").select("TALLA","40");

crea una tabla con los registros de ''COLOR'' ''rojo'' de la ''TALLA'' ''40''. (Para ello crea una tabla intermedia a la que no se da nombre).

Finalemnte hay algunas funciones especiales

<code java>
public Table selectTable(String[] attPos)
public Table selectTable(String attPos)
</code>

Buscan el valor o valores de ''attPos'' en cualquiera de los campos de la tabla.

<code java>
public Table selectTable(int n)
</code>

Selecciona una subtabla con n filas elegidos al azar

<code java>
public Table selectTable()
</code>

Devuelve una copia de la tabla integra.

==== selectSet ====
<code java>
public Set selectSet(int columnPos, String[] attPos, int modePos, int columnNeg, String[] attNeg, int modeNeg )
public Set selectSet(int columnPos, String[] attPos, int columnNeg, String[] attNeg)
public Set selectSet(int columnPos, String[] att, int mode)
public Set selectSet(int columnPos, String[] att)
public Set selectSet(int columnPos, String att)

public Set selectSet(String namePos, String[] attPos, int modePos, String nameNeg, String[] attNeg, int modeNeg )
public Set selectSet(String namePos, String[] attPos,  String nameNeg, String[] attNeg)
public Set selectSet(String namePos, String[] att, int mode)
public Set selectSet(String namePos, String[] att)
public Set selectSet(String namePos, String att)

public Set selectSet(String[] att)
public Set selectSet(String att)
public Set selectSet()
</code>

Son métodos similares a [[#selectTable]] pero que devuelven conjuntos de elemntos de la clase [[siette.util.corpus.Row]], una clase auxiliar para el manejo de tablas.

==== selectAll ====
<code java>
public String[][] selectAll(int columnPos, String[] attPos, int modePos, int columnNeg, String[] attNeg, int modeNeg)
public String[][] selectAll(int columnPos, String[] attPos, int columnNeg, String[] attNeg)
public String[][] selectAll(int columnPos, String[] att, int mode)
public String[][] selectAll(int columnPos, String[] att)
public String[][] selectAll(int columnPos, String att)

public String[][] selectAll(String namePos, String[] attPos, int modePos, String nameNeg, String[] attNeg, int modeNeg )
public String[][] selectAll(String namePos, String[] attPos,  String nameNeg, String[] attNeg)
public String[][] selectAll(String namePos, String[] att, int mode)
public String[][] selectAll(String namePos, String[] att)
public String[][] selectAll(String namePos, String att)

public String[][] selectAll(String[] att)
public String[][] selectAll(String att)
public String[][] selectAll()
</code>

Son métodos similares a [[#selectTable]] pero que devuelven la tabla como una matriz de cadenas de caracteres ''String[][]'' por filas y columnas.
==== select ====
<code java>
public String[] select(int columnPos, String[] attPos, int columnNeg, String[] attNeg)
public String[] select(int columnPos, String[] att)
public String[] select(int columnPos, String att)
public String[] select(int columnPos)

public String[] select(String namePos, String[] attPos, String nameNeg, String[] attNeg)
public String[] select(String namePos, String[] att)
public String[] select(String namePos, String att)
public String[] select(String[] att)

public String[] select(String att)
public String[] select()
</code>


==== addTable ====
<code java>
public void addTable(Table t)
</code>

Añade ala  tabla todas las filas de la otra tabla ''t''.

==== delRow ====
<code java>
public void delRow(int columnPos, String[] attPos, int modePos, int columnNeg, String[] attNeg, int modeNeg )
public void delRow(int columnPos, String[] attPos, int columnNeg, String[] attNeg)
public void delRow(int columnPos, String[] attPos, int modePos)
public void delRow(int columnPos, String[] attPos)
public void delRow(int columnPos, String attPos)

public void delRow(String namePos, String[] attPos, int modePos, String nameNeg, String[] attNeg, int modeNeg )
public void delRow(String namePos, String[] attPos,  String nameNeg, String[] attNeg)
public void delRow(String namePos, String[] attPos, int modePos)
public void delRow(String namePos, String[] attPos)
public void delRow(String namePos, String attPos)

public void delRow(String[] atts)
public void delRow(String att)
</code>

Son métodos similares a [[#selectTable]], pero lo único que hacen es borrar de la tabla los elementos que coinciden con los atributos que se le pasa.


==== getRow ====
<code java>
public Row getRow(int i)
</code>

Devuelve un objeto de la clase [[siette.util.corpus.Row]] (una subclase de ''java.util.ArrayList<String>'' que representa una fila completa de la tabla.

==== get ====
<code java>
public String[] get(int i)
public String get(int i, int j)
public String get(String[] rowString, String name)
public String get(int i, String name)
</code>

Devuelve el valor de un campo concreto de la tabla, por fila y columna. Téngase en cuenta que la numeración tanto de filas como columnas comienza en 0, por lo que la función:

   get(1,3)

devuelve el valor del cuarto campo del segundo registro. Puede indicarse la posición del registro por su nombre:

   get(1,"COLOR");

Devuele el valor del campo ''COLOR'' del segundo registro. (Si la tabla tiene una fila de títulos el segundo registro corresponderá a la tercera fila).

Esta funcion esta pensada para utilizarla junto con la clase [[siette.util.Random]], obteniendo valores de registros al azar, por ejemplo:

   get(Random.nextInt(t.size()),"COLOR");

devuelve un color al azar, evidentemente con una frecuencia proporcional al número de ocurrencias que haya en la tabla.
  
<code java>
public String[] get(int i)
</code>

La función ''get'' con un solo argumento devuelve un vector de ''String'' con todos los valores de la fila, es decir, es similar a la función [[#getRow]]

   
==== getAlternatives ====
<code java>
public Set<String> getAlternativesSet(int j)
public Set<String> getAlternativesSet(String name)

public String[] getAlternatives(int j)
public String[] getAlternatives(String name)
</code>

Estos métodos devuelven o bien un conjunto o un array de cadenas de caracteres, (en cualquier caso, sin elementos repetidos), con todos los posibles valores del campo de la tabla que se indique. Por ejemplo para la tabla:

    PRENDA.   COLOR   TALLA
     X8978    azul     40
     X7866    rojo     39
     X7846    azul     39
     X7867    blanco   39
     X7836    rojo     40
     X7826    azul     39
     X7861    rojo     38

la llamada al método ''getAlternatives("COLOR")'' devuelve el array ''{"azul","rojo","blanco"}''. Este método es útil junto con el método [#toPattern]] para crear patrones u opciones de respuesta a una pregunta.

==== getFirstRow ====
<code java>
public String[] getFirstRow()
</code>

Devuelve la //primera fila// de la tabla, es decir, un array con los nombres de todos los campos.

==== toString ====
<code java >
public String toString()
</code>

Devuelve sobre una cadena de caracteres toda la tabla, incluyendo la cabecera, con los valores separados por el separador por defecto.

==== find ====
<code java>
public String find(int n)
public int find(String title)
</code>

Estas dos funciones son una la inversa de la otra. La primera devuelve el nombre del campo n-esimo (Iniciando la cuenta en 0), y la segunda devuelve la posición del campo ''title'' en la secuencia de campos. 

==== allValues ====
<code java>
public String[] allValues(ArrayList list, String title)
public String[] allValues(String title)
</code>

Devuelve todos los posibles valores de un campo. Ver [[#getAlternatives]]. El prmer método esta pensado para recibir un objeto de la clase [[siette.util.corpus.Row]] como parámetro ''list''.
==== getTable ====
<code java>
public static String[][] getTable(ArrayList<String> list)
public static String[][] getTable(Set<Row> set)
</code>

Son funciones auxiliares para transformar las salidas de otros métodos en una matriz de cadenas de caracteres. 

==== toHint ====
<code java>
public static String toHint(String in, String remove, String replace)
public static String toHint(String in, Set<String> set, String replace)
</code>

Se trata de una funcion auxiliar que permite construir de forma automática ayudas en las preguntas generadas a partir de textos. Es de mucha utilidad cuando se trabaja con [[es:manual:items:generativos:bases_de_datos|bases de datos]] y [[es:manual:items:generativos:web-semantica|web semántica]].

La función da como resultado la misma cadena ''in'' pero en la que se han reemplazado todas las ocurrencias de la ubcadena''remove'' por la cadena ''replace''. La segunda función puede llamarse con un conjunto de cadenas de caracteres, y todas ellas serán reemplazadas. Por ejemplo

   String texto = "Johannes Chrysostomus Wolfgangus Theophilus Mozart "
                + "más conocido como Wolfgang Amadeus Mozart o simplemente Mozart"
                + "fue un compositor y pianista del antiguo Arzobispado de Salzburgo,"
                + "maestro del Clasicismo, considerado como uno de los músicos más"
                + " influyentes y destacados de la historia."
   String[] remove = {"Johannes", "Chrysostomus", "Wolfgangus",  
                       "Theophilus", "Mozart", "Amadeus" };            
   String replace = "___";             
   Table.toHint(texto, remove, replace); 

da como resultado:   

   ___ ___ ___ ___ ___ , más conocido como ___ ___ ___ o simplemente ___,
   fue un compositor y pianista del antiguo Arzobispado de Salzburgo, 
   maestro del Clasicismo, considerado como uno de los músicos más influyentes 
   y destacados de la historia.


==== cap ====
<code java >
public static String cap(String st)
</code>

Pone en mayúsculas la primera letra de una cadedena de caracteres ''st''.

==== toPattern ====
<code java >
public static String toPattern(String in, boolean escape, int patternAlign)
public static String toPattern(String in, boolean escape)
public static String toPattern(String in)
</code>

Son métodos iguales a los de la clase [[siette.util.corpus.Dictionary]].

El proposito de estas funciones es construir un [[es:manual:items:patron:siette|patrón Siette]] a partir de una cadena de entrada ''in''. Al construir un patrón Siette algunos caracteres son caracteres especiales que no pueden usarse directamente en las expresiones, si no se especifica otra cosa, estos caracteres simplemente se eliminan.

   out.println(Table.toPattern("Miguel (de) Cervantes"));

produce la salida

   Miguel de Ceravntes

Otra opciones, es construir el patrón de manera que conserve los caracteres especiales, para lo cual hay que precederlo del caracter de//escape//

   out.println(Table.toPattern("Miguel (de) Cervantes"),true);

produce la salida

   Miguel \(de\) Ceravntes

que es un patrón Siette valido. Finalmente tambien se puede construir un [[es:manual:items:patron:siette|patrón Siette]] de manera que parte del texto sea opcional a derecha o izquierda, por ejemplo:

   out.println(Table.toPattern("Miguel de Cervantes"),false, Table.LEFT);

produce en la salida el patrón Siette:

   {{Miguel} de} Cervantes

o bien

   out.println(Table.toPattern("Aguila culebrera blanca"),false, Table.RIGHT);

produce en la salida el patrón Siette:

   Aguila{ culebrera{ blanca}}

El primer patrón daria como buena una respuesta que dijera simplemente ''Cervantes'' y el segundo una respuesta que dijera simplemente ''Aguila''. Dependiendo de la aplicación unas veces es mas conveniente un patrón que otro.   


<code java >
public static String toPattern(Set set, int mode)
public static String toPattern(List aList, int mode)
public static String toPattern(String[] aString, int mode)
public static String toPatternAll(Set set)
public static String toPatternAll(List aList)
public static String toPatternAll(String[] aString)
public static String toPatternAny(Set set)
public static String toPatternAny(List aList)
public static String toPatternAny(String[] aString)
</code>

Este conjunto de métodos devuelve un [[es:manual:items:patron:siette|patrón Siette]] combinando las cadenas de caracteres que se les pasan como argumentos, ya sea como un array de cadenas de caracteres, una lista o un conjunto. El atributo ''mode'' puede tomar dos valores, correspondientes a dos constantes de la clase ''Table.ALL'' y ''Table.ANY'' indciando como deben combianrse. Por ejemplo

     toPattern(new String[] {"rojo","azul","blanco"}, Table.ALL)

genera el siguiente [[es:manual:items:patron:siette|patrón Siette]]:

     rojo+azul+blanco

que reconoce respuestas como:

     rojo,azul,blanco
     rojo,blanco,azul
     azul rojo blanco
     ...

Las versiones abreviadas de esta funcion imponen el modo en el propio nombre de la función, como por ejemplo

    toPatternAny(new String[] {"rojo","azul","blanco"})

que genera el patrón

    rojo|azul|blanco

que acepta cualquiera de estas cadenas como respuesta.        

==== toText ====
<code java >
public static String toText(String[] aString, int mode, String lang)
public static String toText(Set set, int mode, String lang)
public static String toTextAll(String[] aString, String lang)
public static String toTextAll(Set set, String lang) 
public static String toTextAll(String s, String lang)
public static String toTextAny(String[] aString, String lang)
public static String toTextAny(Set set, String lang)
public static String toTextAny(String s, String lang)
</code>

Son métodos iguales a los de la clase [[siette.util.corpus.Dictionary]].

Los métodos ''toText'' son similares a los métodos ''toPattern'' solo que en vez de crear un patrón Siette, forman una frase en lenguaje natural. Estan pensados para trabajar con una lista de atributos y generar textos que pueden usarse en las rpeguntas de respuesta corta como //ejemplos// de respuestas correctas, o en la seccion de //ayuda//. Por ejemplo,

     toText(new String[] {"rojo","azul","blanco"}, Table.ALL, "es")

devuelve la cadena de caracteres:

     rojo, azul y blanco 

Los métodos 'toTextAll' y ''toTextAny'', utilizan un modo por defecto, por ejemplo

     toTextAll(new String[] {"red","blue","white"}, "en")

devuelve la cadena:

     red, blue and white