Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer. Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar.

La clase StringBuffer dispone de muchos métodos para modificar el contenido de los objetos StringBuffer. Si el contenido de una cadena va a ser modificado en un programa, habrá que sacrificar el uso de objetos String en beneficio de StringBuffer, que aunque consumen más recursos del sistema, permiten ese tipo de manipulaciones.

Al estar la mayoría de las características de los StringBuffers basadas en su tamaño variable, se necesita un nuevo método de creación:

    StringBuffer();
    StringBuffer( int len );
    StringBuffer( String str );

Se puede crear un StringBuffer vacío de cualquier longitud y también se puede utilizar un String como punto de partida para un StringBuffer.

    StringBuffer Dos = new StringBuffer( 20 );
    StringBuffer Uno = new StringBuffer( "Hola Mundo" );

El cambio de tamaño de un StringBuffer necesita varias funciones específicas para manipular el tamaño de las cadenas:

    int length();
    char charAt( int index );
    void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );
    String toString();
    void setLength( int newlength );
    void setCharAt( int index,char ch );
    int capacity();
    void ensureCapacity( int minimum );
    void copyWhenShared();

Obervar que una de las funciones devuelve una cadena constante normal de tipo String. Este objeto se puede usar con cualquier función String, como por ejemplo, en las funciones de comparación.

Para cambiar el contenido de un StringBuffer, se pueden utilizar dos métodos: append() e insert().

En el ejemplo CadAppend.java, vemos el uso de estos dos métodos:

    class CadAppend {
        public static void main( String args[] ) {
            StringBuffer str = new StringBuffer( "Hola" );
            str.append( " Mundo" );
            System.out.println( str );
            }
        }

En este otro ejemplo, CadInversa.java, mostramos un método muy simple que le da la vuelta a una cadena:

    class CadInversa {
        public static String cadenaInversa( String fuente ) {
            int longitud = fuente.length(); 
    
            StringBuffer destino = new StringBuffer( longitud );
            for( int i=(longitud-1); i >= 0; i-- )
                destino.append( fuente.charAt( i ) );
    
            return( destino.toString() );
            }
    
        public static void main( String args[] ) {
            System.out.println( cadenaInversa( "Hola Mundo" ) );
            }
        }

Las funciones que cambian el tamaño son pues:

    StringBuffer append( Object obj );
    StringBuffer append( String str );
    StringBuffer append( char str[] );
    StringBuffer append( char str[],int offset,int len );
    StringBuffer append( boolean b );
    StringBuffer append( int i );
    StringBuffer append( long l );
    StringBuffer append( float f );
    StringBuffer append( double d );
    StringBuffer append( char ch );
    StringBuffer insert( int offset,Object obj );
    StringBuffer insert( int offset,String str );
    StringBuffer insert( int offset,char str[] );
    StringBuffer insert( int offset,boolean b );
    StringBuffer insert( int offset,int i );
    StringBuffer insert( int offset,long l );
    StringBuffer insert( int offset,float f );
    StringBuffer insert( int offset,double d );
    StringBuffer insert( int offset,char ch );

Hay que recordar que los operadores "+" y "+=" también se pueden aplicar a cadenas. Ambos realizan una concatenación y están implementados con objetos StringBuffer.

Por ejemplo, la sentencia:

    String s = "¿Qué" + " tal ?";

es interpretada por el compilador como:

    String s = 
        new StringBuffer().append( "¿Qué" ).append( " tal ?" ).toString();

y se marcaría el StringBuffer para borrarlo ya que el contenido pasa al objeto String. También, la sentencia:

    s += " por ahí!";

sería interpretada por el sistema como:

    String s = 
        new StringBuffer().append( s ).append( " por ahí!" ).toString();

y volvería a marcar para borrar el nuevo StringBuffer.

Tutorial de Java

[Anterior] [Indice] [Siguiente]