Lección 3.

1: Cadena de Caracteres
Ha obtenido 0 punto(s) sobre 0 hasta ahora.
Cadenas ("Strings")

Definición

Pascal, como cualquier otro lenguaje, debe tener la capacidad de procesar frases como
"Presione ENTER para continuar", "Calculando...", "Proceso terminado", etc.

Los datos tipo char y string permiten la manipulación de datos no numéricos.

Una cadena de caracteres o string es una serie de caracteres cuya longitud (número de
caracteres que contiene) puede variar de 1 hasta 255 caracteres. Turbo Pascal tiene el tipo
de dato string que almacena información de texto. Este dato se puede almacenar en
constantes y en variables de cadena. Una variable de cadena está declarada para la palabra
string seguida de la longitud máxima de la cadena encerrada entre corchetes.

Declaración de una variable tipo string

Las variables de cadena se pueden declarar las de cualquier otro tipo, ya sea en la
sección var o en type.

Si se declara como var, se hace de la siguiente manera:

Var

  Mensaje : string [80];

   Nombre : string [40];

Si la cadena es declarada como type, haríamos la declaración así:

Type

   Cadena80 = string [80];

   Cadena40 = string [40];

Var

   Mensaje : Cadena80;

   Nombre : Cadena40;

Es importante recordar que si se declara como Type inmediatamente después, dentro de las
variables, se debe declarar una variable que haga referencia al Type.

Una vez declaradas las variables de cadena se pueden realizar asignaciones o bien
operaciones de lectura / escritura en los programas.
Por ejemplo:

Program Ejemplo;

Var

   Mensaje = string[40];

Begin

   Mensaje := `Hola mis amigos, por favor estudien bastante´;

   Write (`Mi mensaje de hoy para ustedes es: `),Mensaje;

   Writeln;

   Write (`Presione enter...´);

   Readln

End.                       

Longitud de una cadena

Una cadena físicamente es una estructura de una secuencia de 0 hasta 255 caracteres de
longitud. Sin embargo, la ocupación en memoria de una cadena es un número de bytes igual
al de caracteres de la cadena más uno. Así la cadena:

`Programador´

tiene una longitud de 11 caracteres, entonces ocupará en memoria 12 bytes. Esto se debe a
que el primer byte en una cadena, contiene la longitud de la cadena actualmente almacenada
en memoria.

Supongamos que esta palabra corresponde a un dato almacenado en la

variable PUESTO que fue definida de la siguiente manera:

Var

      Puesto : String[20];

Sucede que, entonces, la longitud lógica de la variable será de 11 bytes pero la longitud
física será de 20 bytes pues así fue definida.

Asignación de cadenas
A las variables de cadena, como se ha visto, se pueden dar valores con una sentencia de
asignación o con una sentencia de lectura (read). Ambas situaciones se pueden describir con
la ecuación:

Destino                      fuente

Donde destino es la cadena a la que se da un valor y fuente es la expresión de cadena que

contiene el correspondiente valor. Esta ecuación actúa como la sentencia de asignación que
evalúa la cadena fuente y se almacena en la variable de la cadena destino.

Dependiendo del tamaño (longitud de la cadena) de las cadenas fuente y destino se pueden
presentar tres casos diferentes que analizaremos a partir de la siguiente declaración de
variables de cadena.

  Var

      Cad1  :  String [8];

      Cad2  :  String [11];

      Cad3  :  String [15];

      Cad4  :  String [11];

1 Caso I. Las longitudes de la cadena destino y fuente son iguales

Supongamos que se ejecuta la sentencia

      Cad2 := `informatica´;

Este caso no presenta problemas, pues cada posición de cad2 se rellena con un carácter.

      Cad2        I           N         F         O         R         M         A         T          I           C         A

                        1          2          3          4          5          6          7          8          9          10      
11

Lo mismo sucede si se ejecuta la sentencia

      Cad4 := Cad2;

2 Caso II. La longitud de la cadena destino  es mayor que la cadena fuente

Supongamos que ahora se ejecuta la sentencia

Cad3 := Cad2;

Resultará que Cad3 tiene 15 caracteres y sólo hay 11 caracteres en cad2. La cadena Cad3
seguirá teniendo una longitud máxima de 15 caracteres, pero sólo se almacenan en ella
ahora 11 caracteres y su longitud actual será de 11.
      Cad3        I  N F O R M   A T I  C   A                                        longitud actual = 11

                        1 2 3  4  5 6   7 8 9 10 11  12  13  14  15             longitud máxima = 15

3 Caso II. La longitud de la cadena destino  es mayor que la cadena fuente

Supongamos que se trata de ejecutar ahora

Cad1 := Cad2;

En este caso, como Cad1 tiene una longitud de ocho caracteres, la cadena destino no se
puede almacenar totalmente. En este caso se trunca la cadena destino y se almacenan en
Cad1 los primeros ocho caracteres (de izquierda a derecha) de Cad2.

      Cad1        I  N F O R M   A T                                                     longitud actual = 11

                        1 2 3  4  5 6   7 8                                                     longitud máxima = 8

Las operaciones básicas con strings son: asignación, comparación y concatenación.

Asignación

Es posible asignar una cadena a otra cadena, incluso aunque esta última sea de longitud
física más pequeña. En este caso, no se produce ningún error en tiempo de compilación ni
en tiempo de ejecución. Se producirá un truncamiento de los datos de la cadena mayor a la
longitud física máxima de la cadena más pequeña.

Ejemplo:

Var

      Cad1 : string[15];

Begin

      Cad1 := `Hola Margarita, cómo estás?´

End.

En este caso se asignará a Cad1 la cadena `Hola Margarita,´. Se producirá un truncamiento

de los datos de la cadena mayor a la longitud física máxima de la cadena más pequeña.

Comparaciones

Las comparaciones de cadenas de caracteres se hacen según el orden de los caracteres en el

código ASCII y con los operadores de relación.

      `0´ < `1´                 `1´ < `2´                      `8´ < `9´

      `A´ < `B´                `C´ < `D´                    `M´ > `B´
      `a´ < `h´                 `m´ > `b´                     `p´ < `r´

Concatenación

Otra operación básica que se pueda realizar con cadenas es la concatenación. La operación
de concatenación. La concatenación es el proceso de combinar dos o más cadenas en una
sola cadena. Turbo Pascal proporciona dos métodos independientes para realizar la
concatenación.

a.      Mediante el operador de concatenación (+)

Frase := `Perro que ladra´ + `no muerde, ´ +´mientras esté ladrando´

            produciría una sola cadena almacenada en la variable Frase:

            `Perro que ladra no muerde, mientras esté ladrando´

b.      Mediante la función concat

Program union;

Var

      Cad1,Cad2,Cad3 : string [40];

Begin

      Cad1 := `Programa´;

      Cad2 := ` de computadora´;

      Cad3 := Concat (Cad1,Cad2);

      Write (`La frase completa es `,Cad3);

End.   

Otras funciones y procedimientos con cadenas

Las cadenas permiten otras operaciones como las siguientes:

-         Función Lenght : Proporciona la longitud lógica de una cadena de caracteres y

devuelve un valor entero. La sintaxis es:

            Lenght (cadena)

Ejemplo:

            Lenght (`Esto es una prueba´);      

            Esta instrucción devolvería el valor de 16.

-         Función Delete : Borra o elimina una subcadena de una cadena. Una subcadena es
una cadena contenida dentro de otra de mayor longitud. La sintaxis es:

                        Delete (cadena,posición,número)

                        Cadena : Representa la cadena original o fuente

                        Posición : Representa la posición del primer carácter a suprimir

Número: Es la cantidad de caracteres que se borrarán (debe ser un valor entero)

-         Función Insert: Inserta una subcadena en una cadena. La sintaxis es la siguiente:

                        Insert (Cad1,cadena,posición)

                        Cad1: Cadena a insertar

                        Cadena : Cadena donde se insertará

                        Posición: Carácter a partir del cual se insertará Cad1

Si una vez insertada la nueva cadena el tamaño total excede al límite de la variable, se
truncará la cadena hasta su longitud máxima.

-         Función Pos (Posición): Esta función permite determinar si una cadena está contenida
en otra. En este caso, la función devuelve la posición donde comienza la cadena buscada en
la cadena fuente. Si la cadena no existe, se devuelve un resultado de 0. Utiliza la siguiente
sintaxis:

                        Pos (Cadena buscada, Cadena fuente)  

-         Función Copy (Copiar): Esta función devuelve una cadena de caracteres (subcadena)
extraída de una cadena.

                        Copy (Cadena,Posición, Número)

                        Cadena : Expresión tipo cadena (fuente)

                        Posición : Primer caracter a extraer (tipo entero)

                        Número : Total de caracteres a extraer (tipo entero)

Si la posición es mayor que la longitud de "Cadena", se devuelve una cadena vacía; si el

número especifica más caracteres que los indicados desde posición, sólo se devuelve el
resto de la cadena.

Ejemplo:

            Ch := `Esto es una cadena muy larga´;

            Ch2 := Copy (Ch,1,18);

            Write (Ch2)

Esto produciría la cadena `Esto es una cadena´.

-         Función de conversión a mayúsculas (Upcase)

La función Upcase toma un argumento de tipo char y devuelve la correspondiente

equivalencia de la expresión en mayúscula. Si la expresión ya está en mayúscula o no tiene
ningún carácter equivalente en mayúscula, se devuelve el carácter sin modificar.

Sintaxis: Upcase (Letra)

Letra es de tipo char. Por ejemplo: Upcase (`a´) devuelve `A´.

-         Acceso a posiciones individuales en una cadena

Como las cadenas son arrays, se puede acceder a sus elementos en forma individual.
Ejemplo:

            Nombre := ´Picapiedra´

Entonces:

            Nombre[1]   P                      

            Nombre[2]    i                       

            Nombre[3]    c                      

            Nombre[4]   a                       

            Nombre[5]   p                       

            Nombre[6]   i

            Nombre[7]   e                       

            Nombre[8]   d                       

            Nombre[9]   r            

            Nombre[10] a

Cadenas de Caracteres

Representación de caracteres

 Una cadena de caracteres es una sucesión finita de caracteres

 Para representar un carácter se utiliza un código que asignará a cada carácter un
determinado número de bits
 Con n bits se representan un máximo de m=2 n caracteres
  Para representar m caracteres se necesitan al menos n bits siendo n= log 2 m =
3.16*log 10 m

Códigos

 ASCII – American Standar Code for Information Interchange 

o 7 bits => 128 caracteres
o Versión extendida 8 bits (1 byte)  => 256 caracteres

 BCD – Binary Coded Decimal

o 6 bits => 64 caracteres
o Versión extendida EBCDIC – Extended Binary Coded Decimal Interchange
Code 8 bits => 256 caracteres

 UNICODE
o 16 bits (2 bytes) => 65.536 caracteres (aprox.34.000 utilizados)

Definición de cadena

Una cadena de caracteres es una sucesión de caracteres (normalmente limitado a 255

caracteres) representables por el ordenador y que se almacenan de manera contigua en
memoria.

var_cadena : CADENA [ longitud ]

Ejemplos

nombre: cadena [25]     dni: cadena [8]

teléfono: cadena [10]     comentario:cadena

Errores

a: cadena [256]
vacia : cadena [0]

Almacenamiento en memoria

 Si una variable cadena se ha declarado de tamaño n, entonces se reserva en memoria

un espacio fijo de n bytes de forma que a dicha variable solo se le puede asignar una
cadena de exactamente la misma longitud (Pascal l estándar)
 Se almacena un espacio de memoria igual a la longitud máxima de la cadena de
caracteres, y se guarda también en algún sitio la longitud actual actua l de dicha
cadena (Turbo Pascal)
 Se utiliza un carácter específico para señalar el final de la cadena ca dena de
caracteres
 que generalmente es el carácter '\ 0' ó NUL (C)

Operaciones a Nivel Caracter:

Son aquellas que permite acceder a cada elemento de la cadena de caracteres:

setChar

getChar

insChar

remChar

Operaciones a Nivel Palabra:

Son aquellas que permite acceder a cada palabra de la cadena de caracteres:

cantPal

addPal

InsPal

remPal

Operaciones primitivas

Asignación

Las constantes cadenas deben ir entre comillas, Si se asigna una cadena con longitud mayor
a otra con longitud menor, lo habitual es que el compilador simplemente trunque la cadena
mayor para ajustarla al tamaño máximo de la cadena menor.

 nombre, cad: cadena[5]

 cad2:cadena[10]
 cad ← ‘Alejandro’
 cad2 ← ‘Alejandro’
 nombre ← cad
 cad ← cad2

Acceso

Para acceder a cada carácter de la cadena se usa la misma notación que con los arrays

 nombre[i] devuelve un valor de tipo carácter (OJO NO de tipo cadena)

 nombre[3] devuelve ‘e’

Para modificar un carácter dentro de la cadena también se usa la notación de los arrays
  nombre[i] ← ‘a’
 nombre[5] ← ‘o’  {nombre quedaría como ‘Alejo’}

A diferencia de lo que ocurre con los arrays, las cadenas son accesibles globalmente por su
nombre
sin necesidad de acceder elemento a elemento (es decir, no es necesario acceder carácter a
carácter)

 nombre ← ‘María

Lectura y Escritura

 LEER(nombre)
 ESCRIBIR(nombre)

Para leer o escribir un carácter concreto de la cadena

 LEER(nombre[i])
 ESCRIBIR(nombre[i])

Longitud de una cadena – long(cad): devuelve un

número entero en el rango [0,255]
Comparación de cadenas

 La comparación se hace carácter a carácter

 Operadores relacionales =,<,<=,>,>=,<>

Concatenación de cadenas

 Es una operación cerrada (el resultado es otra cadena)

 Función CONCAT(cad1,cad2): Devuelve una cadena que es el resultado de unir las
dos cadenas cad1 y cad2
 Se puede utilizar también el operador + para la concatenación (cad1+cad2)
 Restricciones
o Si la suma de las longitudes de las cadenas supera los 255 caracteres, la
cadena resultante estará formada por la primera cadena y los (255-
LONG(cad1 )) primeros caracteres de la segunda

Extracción de una subcadena

 SUB(cad,pos,num_car): extrae una subcadena a partir de la cadena ‘cad’

comenzando en la posición ‘pos’ y con una lógitud de ‘num_car’ caracteres

 Restricciones
o Si la posición a partir de la cual se desea extraer la subcadena es mayor que
la longitud de la cadena original, el resultado será la cadena vacía.
o El número de caracteres a extraer debe ser un número entero positivo mayor
que cero; en caso contrario debe devolverse la cadena vacía.
 o En el caso de que el número de caracteres a extraer superen el tamaño de la
cadena original, entonces se procederá al truncamiento de la cadena
extraída.

Inserción de una subcadena

 INSERTA(cad,subcad,pos): inserta la subcadena ‘subcad’ en la cadena ‘cad’ a partir

de la posición ‘pos’ de la cadena original.
 Restricciones
o En el caso de que la posición a partir de la cual se desea insertar la
subcadena sea mayor que la longitud de la cadena, entonces debe devolver
la concatenación de ambas cadenas.

Borrado de una subcadena

 BORRA(cad,pos,num_car): borra de la cadena ‘cad’ un total de ‘num_car’

caracteres comenzando en la posición ‘pos.
 Restricciones
o Si la posición a partir de la cual se desea borrar la subcadena es mayor que
la longitud de la cadena, entonces debe devolver la cadena de entrada.
o El número de caracteres a borrar debe ser un número entero positivo mayor
que cero; en caso contrario debe devolverse la cadena de entrada sin borrar
ningún carácter.
o Si el número de caracteres a extraer supera el tamaño de la cadena, entonces
se borrará hasta el final de la cadena de entrada y no más caracteres.

Búsqueda de una subcadena

 BUSCA(subcad,cad): devuelve un entero que indica la posición que ocupa el primer

carácter de la subcadena ‘subcad’ en la cadena ‘cad’, ‘cad’ , o un negativo (o cero)
si no se encuentra la subcadena dentro de la cadena
Ejemplo

Ejemplo U3 - Cadenas
Creando Clase Conjunto usando Vectores

Ejercicio T3E1: Realice un programa que me permita manejar un Conjunto.

1.1. Análisis:

        Cantidad

        Elementos     

1.2. Diseño: se pedirá al usuario información de.

 Constructor
 setElem
 getElem
 setDim
 getDim
 Pertenece
 Agregar
 Remover

1.3. Implementacion:

1.3.1 Creamos la Clase Conjunto en una Unidad

unit uconjunto;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Dialogs;
const
  MAX_ELE=1200;
type

  { Conjunto }

  Conjunto=Class
    private
      elem:array[1..MAX_ELE]of char;
      dim:integer;
    public
      constructor Conjunto();
      procedure setElem(pos:integer;ele:char);
      function getElem(pos:integer):char;
      procedure setDim(n:integer);
      function getDim():integer;
      function pertenece(ele:char):boolean;
      procedure agregar(ele:char);
      procedure remover(ele:char);
  end;

implementation
{ Conjunto }

constructor Conjunto.Conjunto();
var
  i:integer;
begin
  dim:=0;
  for i:=1 to MAX_ELE do
    elem[i]:=char(0);
end;

procedure Conjunto.setElem(pos: integer; ele: char);

begin
   if(pos>=1)AND(pos<=dim)then
     elem[pos]:=ele
   else
     Writeln('Conjunto.setElem:Fuera de Rango...');
end;

function Conjunto.getElem(pos: integer): char;

begin
  if(pos>=1)AND(pos<=dim)then
     result:=elem[pos]
   else
     result:=char(0);
end;

procedure Conjunto.setDim(n: integer);

begin
  if(n>=0)AND(n<=MAX_ELE)then
     dim:=n
   else
     Writeln('Conjunto.setDim:Fuera de Rango...');
end;

function Conjunto.getDim(): integer;

begin
  result:=dim;
end;

function Conjunto.pertenece(ele: char): boolean;

var
  i:integer;
  sw:boolean;
begin
  sw:=false;
  i:=1;
  while(i<=dim)and(NOT sw)do
  begin
    if(ele=elem[i])then
       sw:=true
    else
      i:=i+1;
  end;
  result:=sw;
end;

procedure Conjunto.agregar(ele: char);

begin
  if(NOT pertenece(ele))then
  begin
    dim:=dim+1;
    elem[dim]:=ele;
  end;
end;

procedure Conjunto.remover(ele: char);

var
  i,j:integer;
begin
  if(pertenece(ele))then
  begin
    i:=1;
    while(i<=dim)AND(ele<>elem[i])do
      i:=i+1;
    for j:=i to dim-1 do
      elem[i]:=elem[i+1];
    dim:=dim-1;
  end;
end;

end.

1.3.2. Creamos el Programa para probar el funcionamiento de la Clase

program t3e1;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes, uconjunto
  { you can add units after this };
var
  c:conjunto;
  i:integer;
begin
  c:=conjunto.Conjunto();
  c.agregar('a');
  c.agregar('b');
  c.agregar('c');
  c.agregar('d');
  c.agregar('a');
  write('Los Elementos Son : ');
  for i:=1 to c.getDim() do // a,b,c,d
    write(c.getElem(i),', ');
  writeln;
  if(c.pertenece('c'))then
  begin
        Writeln('Eliminando : c');
        c.remover('c');
  end;
  if(NOT c.pertenece('x'))then
  begin
        Writeln('No Pertenece : x');
  end;
  write('Los Elementos Son : ');
  for i:=1 to c.getDim() do // a,b,d
    write(c.getElem(i),', ');
  writeln;
end.

Realice una Aplicación que me permita Administrar una Clase llamada Cadena , que
realice las siguientes operaciones: (Con Interfaces Gráficas)

Operaciones:

 getDim
 setChar
 getChar
 addChar
 remChar

Puede desarrollar ambos lenguajes de programacion:

En Pascal:

Video
Para desarrollar en Java Utilizaremos (Android Studio) :

Para ello primeramente debemos crear un proyecto

 Nombre Proyecto : PCadena

 Nombre Layout: FCadena

 Nombre Activity: fcadena

y luego hacemos algunos ajustes en:

1.- En el Formulario :
* Layout / Formulario (FCadena.xml)

<?xml version="1.0" encoding="utf-8"?>

<AbsoluteLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="bo.edu.uagrm.ficct.inf120.pcadena.Fcadena">

<TextView
android:id="@+id/L1"
android:layout_x="0dp"
android:layout_y="0dp"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:text="Cadena de Caracteres"
android:textSize="22sp"
android:textStyle="bold" />

<TextView
android:id="@+id/L2"
android:layout_x="0dp"
android:layout_y="30dp"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:text="{ }"
android:textSize="22sp"
android:textStyle="bold" />

<EditText
android:id="@+id/ele"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
 android:layout_y="70dp"
android:ems="60"
android:inputType="text"
android:hint="Caracter..."/>
<EditText
android:id="@+id/pos"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
android:layout_y="110dp"
android:ems="2"
android:inputType="number"
android:hint="Posicion..."/>

<Button
android:id="@+id/B1"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
android:layout_y="150dp"
android:text="Crear"
android:onClick="eCrear" />
<Button
android:id="@+id/B2"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
android:layout_y="190dp"
android:text="Adicionar Caracter"
android:onClick="eAddChar" />
<Button
android:id="@+id/B3"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
android:layout_y="230dp"
android:text="Fijar Caracter"
android:onClick="eSetChar" />
<Button
android:id="@+id/B4"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
android:layout_y="270dp"
android:text="Obtener Caracter"
android:onClick="eGetChar" />
<Button
android:id="@+id/B5"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
android:layout_y="310dp"
android:text="Remover Caracter"
android:onClick="eRemChar" />
<Button
android:id="@+id/B6"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_x="0dp"
android:layout_y="340dp"
 android:text="Salir"
android:onClick="eSalir" />

</AbsoluteLayout>
2.- Ahora creamos la Clase Cadena, ademas de la Clase Conjunto:

* Clase Cadena (Cadena.java)

public class Cadena {

public Context ctx;
final int MAX_C=1000;
private char elem[] = new char[MAX_C];
private int dim;
private Conjunto May,Min,Dig,Sep;
Cadena(){
dim=-1;
for (int i = 0; i < MAX_C ; i++)
elem[i]=(char)(0);
May=new Conjunto();//'A'..'Z'
for (int i = 0; i < 26 ; i++)
May.agregar((char)(65+i));
Min=new Conjunto();//'a'..'z'
for (int i = 0; i < 26 ; i++)
Min.agregar((char)(97+i));
Dig=new Conjunto();//'0'..'9'
for (int i = 0; i <= 9 ; i++)
Dig.agregar((char)(48+i));
Sep=new Conjunto();//' ','_','-','.',':',',',';'
Sep.agregar(' ');
Sep.agregar('_');
Sep.agregar('-');
Sep.agregar('.');
Sep.agregar(':');
Sep.agregar(',');
}
public int getDim(){
return dim+1;
}
public void addChar(char ele){
if(dim<MAX_C){
dim++;
elem[dim]=ele;
}else
ShowMessage("Almac. Lleno");
}
public void setChar(int pos,char ele){
pos--;
if((pos>=0)&&(pos<=dim))
elem[pos]=ele;
else
ShowMessage("Fuera de Rango...");
}
public char getChar(int pos){
pos--;
if((pos>=0)&&(pos<=dim))
return elem[pos];
else
return (char)(0);
 }
public void remChar(int pos){
pos--;
if((pos>=0)&&(pos<=dim)){
for (int i = pos; i < dim ; i++)
elem[i]=elem[i+1];
dim--;
}
else
ShowMessage("Fuera de Rango...");
}
public void ShowMessage(String msg){
Toast.makeText(ctx,msg,Toast.LENGTH_LONG).show();
}
}

* Clase Conjunto(Conjunto.java)

public class Conjunto {

final static int MAX_E=256;
private char elem[] = new char[256];
private int dim;
Conjunto(){
dim=-1;
for (int i = 0; i <MAX_E ; i++)
elem[i]=(char)(0);
}
public boolean pertenece(char ele){
int i=0;
boolean sw=false;
while((i<dim)&&(! sw)){
if(ele==elem[i])
sw=true;
i++;
}
return sw;
}
public void agregar(char ele){
if(!pertenece(ele)){
dim++;
elem[dim]=ele;
}
}
}
3.- Ahora hacemos algunos ajuste desde la codigo para tener acceso al
layout
y programamos los eventos:

* Eventos(fcadena.java)
public class Fcadena extends Activity {
EditText ele,pos;
TextView L2;
Cadena C;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
AppCompat

setContentView(R.layout.fcadena);
ele = (EditText)findViewById(R.id.ele);
pos = (EditText)findViewById(R.id.pos);
 L2 = (TextView)findViewById(R.id.L2);
}
public void eCrear(View view){
C = new Cadena();
actualizarCad();
ShowMessage("Objeto Creado...");
}
public void eAddChar(View view){
C.addChar(ele.getText().charAt(0));
actualizarCad();
ShowMessage("Adicion Caracter...");
}
public void eSetChar(View view){
int p=Integer.parseInt(pos.getText().toString());
char e=ele.getText().charAt(0);
C.setChar(p,e);
actualizarCad();
ShowMessage("Fijar Caracter...");
}
public void eGetChar(View view){
int p=Integer.parseInt(pos.getText().toString());
char car=C.getChar(p);
ele.setText(car);
actualizarCad();
ShowMessage("Obtener Caracter...");
}
public void eRemChar(View view){
int p=Integer.parseInt(pos.getText().toString());
C.remChar(p);
actualizarCad();
ShowMessage("Eliminar Caracter...");
}
public void ShowMessage(String msg){
Toast.makeText(this,msg,Toast.LENGTH_LONG).show();
}
public void actualizarCad(){
L2.setText("{ ");
for (int i = 1; i <=C.getDim() ; i++)
L2.append(C.getChar(i)+" ");
L2.append(" }");
}

4.- Felicidades, has concluido tu aplicación Cadena.