Miércoles 7 de Abril

Examinando los strings

Objetivos: Mostrar que se pueden formar nuevos strings concatenando otros strings o extrayendo partes de un string.

Temas:

Ejercicio:

Escribir un programa que lea una cantidad indeterminada de palabras (terminada en la palabra "fin") y escriba la palabra más larga y la mayor en orden lexicográfico.

Diálogo:

esta noche puedo escribir los versos más tristes fin
Para la frase anterior la palabra más larga es escribir y la mayor es versos. Solución del problema:

    String palabra= readString();
    String mayor= palabra;
    String maslarga= palabra;
    while (compare(palabra, "fin")!=0) {
      if (length(palabra)>length(maslarga))
        maslarga= palabra;
      if (compare(palabra,mayor)>0)
        mayor= palabra;
      palabra= readString();
    }
    print("Mayor= "); println(mayor);
    print("Mas larga= "); println(maslarga);
Observe la similitud de este programa con el programa que calcula el máximo y mínimo de un conjunto de números ingresados por el usuario (visto en una clase anterior).

Concatenación:

Los strings se pueden concatenar con el operador +:

    "hola" + "juan"   es   "holajuan"
    "hola" + " " + "juan" es ("hola" + " ") + "juan" o "hola juan"
Por lo tanto, las dos últimas líneas se pueden reescribir como:

    println("Mayor= "+mayor);
    println("Mas larga= "+maslarga);
También se puede escribir cuán larga era una palabra:

    println("El largo de "+maslarga+" es "+length(maslarga));
Al hacer la parentización queda al último una expresión de tipo string + una expresión entera. En este caso Java convierte la expresión entera al string que representa el valor de la expresión y luego realiza la concatenación. Por ejemplo:

    "numero= "+5    es   "numero= 5"
    ""+123          es   "123"
De ahora en adelante, cuando queramos desplegar un string seguido de una valor numérico, preferiremos escribir en forma abreviada:

    println("El numéro es "+num);
    println("El rango es ["+min+","+max+"]");
Por lo tanto debe tener mucho cuidado. A veces el operador + significa suma (de enteros o de reales) y a veces concatenación de strings. Es un error usar los operadores -, * o / con strings.

Substrings

Cada uno de los caracteres que forman un string tiene una posición en él. Por ejemplo se tiene el siguiente string:

    String s=         "abracadabra";
    las posiciones son 0123456789 
                               y 10
Es decir que el caracter de la posición 0 es una a, el de la posición 4 es una c y el de la posición 10 es una a. El largo del string en este caso es 11. No es válido hablar del caracter que está en la posición 11 o en la -1.

Se puede obtener un substring a partir de otro string usando la función substring. Por ejemplo:

    String subs= substring(s,4,3);
La función substring recibe como argumentos un string, del cual se obtendrá un substring, la posición del primer caracter que formará parte del substring y el número de caracteres que debe contener el substring.

El resultado de esta operación es que subs es "cad". Es importante notar que el substring entregado es también un String. La posición de la c es 0, la posición de la a es 1 y la posición de la d es 2. El largo del substring es 3.

También existe: 

    String resto= substring(s,4); // resto== "cadabra"
Esta forma de llamar a substring obtiene el substring de s que parte en la posición 4 y llega hasta el final de s.

Ejercicio:

Reemplazar las letras a por e en el string s, dejando el resultado en t. Por ejemplo si s contiene "abracadabra", t deberá quedar como "ebrecedebre". Solución: Estudiar el siguiente programa.

    String t= "";
    int i= 0;
    while (i<length(s)) {
      t= t+substring(s,i,1);
      i= i+1;
    }
Este programa es una nueva forma de acumulación. Antes de entrar al ciclo, el string t está vacío. En la primera iteración contiene el primer caracter de s ("a"). En la segunta, el primero y el segundo ("ab") y en cada iteración se agrega un nuevo caracter, hasta que al final t y s son el mismo string.

Usamos el mismo patrón, solo que ahora antes de agregar un caracter nos fijamos si es una "a", en cuyo caso agregamo una "e" y no la "a":

    String t= "";
    int i= 0;
    while (i<length(s)) {
      if (compare(substring(s,i,1), "a")==0)
        t= t+"e";
      else
        t= t+substring(s,i,1);
      i= i+1;
    }
Esa es la característica de los patrones. Todas sus formas se parecen, pero siempre son diferentes de alguna forma.

Esto mismo se puede hacer más cómodamente con la función replace que reemplaza todas las ocurrencias de un substring dentro de un string mayor por otro substring. El ejercicio quedaría simplemente como:

    String t= replace(s,"a","e");

Tarea:

Invertir los caracteres del string s, dejando el resultado en s. Por ejemplo si s contiene "roma", entonces t deberá quedar en "amor".

Indicación: cambie ligeramente el patrón de acumulación, de modo que en la segunda iteración t sea "ba" en vez de "ab". En la tercera, "rba", en la cuarta "arba", etc.