2.  Strings, Archivos y Arreglos

Problema. Leer una lista de palabras y escribir la más larga(de más letras) y la mayor (alfabeticamente). El fin de lalista se indica con la palabra “fin”

Ejemplo:

Palabra(o fin) ? calculoPalabra(o fin)? algebraPalabra(o fin)? fisicaPalabra(o fin)? computacionPalabra(o fin) ? finMás larga = computacionMayor = fisica

String masLarga="", mayor=""; Scanner U = new Scanner(System.in); while(true) { System.out.print("palabra(o fin)?") String palabra=U.nextLine(); if(palabra.equals("fin")) break; if(palabra.length() > masLarga.length()) masLarga=palabra; if( palabra.compareTo(mayor) > 0) mayor=palabra; } System.out.println("mas larga=" + masLarga); System.out.println("mayor=" + mayor);

Programa

para caracteres individuales (letra, dígito, signo especial) cada caracter se representa en 16 bits (2 bytes) convención UNICODE (extensión de ASCII) variables: ej: char c; constantes: ‘un caracter’ (entre apóstrofes) ej: ‘ ‘, ’a’, ‘A’, ’8’, ’=’ asignación: ej: c=’a’; comparación: caracter operador-relación caracter

orden entre caracteres: ‘ ‘ < ’0’ < ’1’ < ... < ’9’ < ’A’ < ... < ’Z’ < ’a’ < ... < ’z’

operaciones aritméticas (entre representaciones internas) ej: ‘c’-‘a’ entrega 2 (tipo int) (char)(‘a’+2) entrega ‘c’

Tipo Char

import java.util.*;class Caracteres { public static void main(String args[]) { Scanner C = new Scanner(System.in); System.out.print("ingrese numeros n1 n2 "); int in = C.nextInt(), fn = C.nextInt(); for (int i = in; i <= fn; i++) System.out.println(i+" <-> "+(char)i); C.nextLine(); System.out.print("ingrese letras x1 Enter x2"); char ic = C.nextLine().charAt(0), fc = C.nextLine().charAt(0); for (int i = ic; i <= fc; i++) System.out.println(i+" <-> "+(int)i); }}

Caracteres y enteros

Sintaxis Significado tipo Ej: String s=“casa” x.length( ) Nº de caracteres int s.length( )=4 x.equals(y) ¿ x es igual a y ? boolean s.equals(“casa”)=true

s.equals(“Casa”)=false x.compareTo(y) 0 si x == y

Nº < 0 si x < y Nº > 0 si x > y

int s.compareTo(“casa”)=0 s.compareTo(“casas”)<0 s.compareTo(“Casa”)>0

x.charAt(i) carácter ubicado en el indice i (desde 0)

char

s.charAt(2)=’s’ s.charAt(0)=’c’ s.charAt(4) error

x.indexOf(y) índice de primer y en x (-1 si no está)

int s.indexOf(“as”)=1 s.indexOf(“a”)=1 s.indexOf(“hola”)=-1

x.indexOf(y,i) índice de y en x (a partir de i)

int s.indexOf(“a”,2)=3

Métodos de Strings

Métodos que devuelven String (y no modifican string original) x.substring(i,j) string con caracteres

entre índices i y j-1 s.substring(1,3) s.substring(2,3)

“as” “s”

x.substring(i) x.substring(i,x.length()) s.substring(1) “asa” x.concat(y) concatena x e y

(añade y al final de x) s.concat(“do”) s + “do”

“casado”

x.replace(y,z) reemplaza todos los caracteres y por z

s.replace(‘a’,’e’) “cese”

x.toUpperCase() reemplaza minúsculas por mayúsculas

s.toUpperCase() “CASA”

x.toLowerCase() reemplaza mayúsculas por minúsculas

s.toLowerCase() “casa”

x.trim() elimina espacios al comienzo y fin

“ a b “.trim() “a b”

Más métodos

Ej: cuenta(“abra”,“abracadabra”) entrega 2 static public int cuenta(String x,String y) iterativa int n=0, l=x.length(); //repetir mientras se encuentre x for(int i=0; (i=y.indexOf(x,i))>=0; i+=l) ++n; return n; recursiva int i=y.indexOf(x); if(i<0) return 0; return 1+cuenta(x,y.substring(i+x.length()));

Apariciones de un string en otro

Ejemplos• Conversión de un número a string

String s = “”+n; //si n=123, s=“123”

String s = “”+x; //si x=4.5, s=“4.5”

• Conversión de un string a númeroint i = Integer.parseInt(s);

Double d = Double.parseDouble(s);

9

Los Archivos de Texto

• Se organizan en líneas de texto (Strings)• Cada línea consiste una cadena de caracteres que

termina con una marca de fin de línea• Después de la marca de fin de línea de la última

línea viene una marca de fin de archivo• Por convención tienen la extensión .txt• Se generan con un editor de texto (sin formato) o

por un programa

Escribiendo archivos de texto

Apertura de un archivo para escritura:PrintWriter x = new PrintWriter (

new FileWriter(filename))Se pueden escribir líneas con los siguientes métodos:

x.print(string) x.println(string)Si existía un archivo con ese nombre se borra y es reemplazado por el que genere el programaEs importante hacer que al final se ejecute la instrucción x.close() para asegurarse de que los datos que aún están en el buffer sean traspasados.• Hay que reportar que se usan métodos que pueden

causar excepciones con throws IOException

12

Leer líneas que terminan con la palabra “fin” y grabarlas en un archivo en disco de nombre “archivo.txt”.

import java.io.*; import java.util.*;class CrearArchivo { static public void main(String[]args)

throws IOException{ PrintWriter a=new PrintWriter( new FileWriter(“archivo.txt”)); Scanner U = new Scanner(System.in); while(true){ System.out.print (“linea(o fin)?“); String linea=U.nextLine() if( linea.equals(“fin”) ) break; a.println(linea); } a.close(); }}

Ejemplo: escritura

Leyendo archivos de texto en JAVA• Abrir un archivo existente :

BufferedReader x = new BufferedReader( new FileReader(filename))

• Las líneas pueden ser leídas de la siguiente manera:

String line = x.readLine()

• Archivos se tratan secuencialmente

• Si no quedan líneas por leer en el archivo, el método readLine() retornará el valor null.

• Importar clases BufferedReader y FileReader poniendo al

import java.io.*;

• reportar excepciones con throws IOException

14

Leer líneas que terminan con la palabra “fin” y grabarlas en un archivo en disco de nombre “archivo.txt”.

import java.io.*;class LeerArchivo{ static public void main(String[]args)

throws IOException { BufferedReader a = new BufferedReader( new FileReader(“archivo.txt”)); while(true){ String linea=a.readLine(); if(linea==null) break; System.out.println(linea); } a.close(); }}

Ejemplo: lectura

15

Lineas en el archivo “archivo.txt”: Nombre:nota Ej. Juan Perez:6.7

import java.io.*;class LeerArchivo{ static public void main(String[] args) throws IOException { BufferedReader a = new BufferedReader( new FileReader(“archivo.txt”)); String linea; String nombre; double notamax = 0.0; while(linea=a.readLine() != null){ int i = linea.indexOf(“:”); double nota = Double.parseDouble(linea.substring(i+1)); if(nota > notamax) { notamax = nota; n nombre = linea.substring(0,i+1); } } a.close(); System.out.println(“Nombre: “+nombre+” Nota: “+notamax); }}

Encontrar alumno con nota mayor

16

Se tienen 3 archivos

Alumnos.txt Inscripciones.txt Cursos.txt

1234 Juan Perez 1234 cc3001 cc3001 Algoritmos2345 Ana Paiva 3456 cc1001 ma1101 Algebra3456 Olga Diez 1234 ma2101 ma2101 Probabilidades

2345 cc3001 cc1001 Computacion 3456 ma1101

Resultado

Juan Perez Algoritmos ProbabilidadesAna Paiva AlgoritmosOlga Diez Computacion Algebgra

Listar nombre de alumnos con nombre de los cursos inscritos

Arreglos

• Un arreglo es una coleccion ordenada de elementos del mismo tipo– Tipos de datos primitivos (int, …)– Referencias a objetos

• El tamaño es definido en la creación (new) y no puede ser modificado

17

Arreglos de Tipos Primitivos

int[] x; // equivalente a int x[]

18

X102030

x[1] = 20;

x[2] = 30;

x[0] = 10;

x = new int[3];

Nota: x.length es una variable final que entrega el tamaño del arreglo

Arreglos de Objetos

19

X

Referencias

Circulo[] x;

x[1] = new Circulo();

x[2] = new Circulo();

x[0] = new Circulo();

x = new Circulo[3];

Arreglos de Arreglos

• Java permite crear arreglos de arreglos con la siguiente sintaxis

int[][] matriz = new int[4][]; for (int i = 0; i < matriz.length; i++) { matriz[i] = new int[5]; for (int j = 0; j < matriz[i].length; j++) { matriz[i][j] = i + j; } }

20

Arreglos de Strings

• Paso de parámetros

Static public void main(String[] args) { for (int i = 0; i < args.length; i++) { System.out.println(″Argumento ″+(i+1)+ ″ = ″+args[i]);

} }

21

Inicialización de Arreglos• Un arreglo puede inicializarse con la siguiente

sintaxis:

boolean[] respuestas = {true, false, true};String[] nombres = {"Ana María", "Carlos"};String[][] humor = { { "Coco Legrand", "Alvaro Salas" }, { "Les Luthiers" }, { "Groucho Marx", "Buster Keaton", "Jerry Lewis", "Woody Allen" }};

22

for-each (desde Java 5.0)• Java 5.0 introdujo un for simplificado para recorrer arreglos y

otras estructuras• El siguiente método retorna la suma de los elementos de un

arreglo

23

// Java 1.4 o anteriorint sum(int[] a) { int result = 0; for (int i=0; i<a.length; i++) { result += a[i]; } return result;}

// Java 5.0int sum(int[] a) { int result = 0; for (int i : a) { result += i; } return result;}

Ejemplo: Búsqueda del máximo

Estrategia: revisar todos los elementos a[1] hasta a[n] y registrar el mayor visto hasta ahora en m

Invariante:   m = max(a[1] … a[k]),  1 <= k<=n

a1 a2 ai anan-1. . . . . .

k

El invariante de una iteraciónInvariante: Alguna condición (conjunto) que describe lo que un ciclo hace. Permanece invariante durante el ciclo: al entrar, durante cada iteración y al final.Debería representar la estrategia que se usa para resolver el problema. Se usa para: - A partir del invariante desarrollar el trozo de programa- Demostrar que el trozo programa hace lo que queremos- Explicar un trozo de programaAl escribir un ciclo se debe a) establecer la validez inicial del invariante, a través de una inicialización adecuada. B) El objetivo del ciclo es llegar a un estado final F. c) En cada iteración se debe, además, preservar la validez del invariante.

Condiciones iniciales y finalesa) El invariante se debe cumplir antes de entrar al ciclo, pero no hemos revisado nada aún. Podemos decir que el primero es el mayor de los revisados hasta ahoram = a[1]; k = 1; 

a1 a2 ai anan-1. . . . . .

k

b) Para conseguir el objetivo, k debe valer n, por lo que debemos parar el ciclo cuando k = n, o continuarlo mientras k != n, o k < n

a1 a2 ai anan-1. . . . . .

k

Avanzar y restablecer el invariantec) Para avanzar hay que tratar de que k llegue a n. Esto se hace incrementando k. Esto puede significar que el invariante no se cumple pues el nuevo a[k] podría ser mayor que m. k++;

Para restablecer el invariante podemos incluir en el ciclo las siguientes instrucciones (después de incrementar k) if (a[k] < m)  m = a[k]; Ahora solo basta ensamblar a), b) y c) para tener el trozo de programa que hace lo que queremos

a1 a2 ai anan-1. . . . . .

k

ai

Ejemplo 1: ordenación por selección 

Este algoritmo se basa en hacer pasadas sucesivas sobre los datos. En cada pasada, se encuentra el máximo del arreglo, y se lo lleva al extremo derecho. Una vez hecho esto, ese elemento deja de ser considerado, porque se encuentra ya en su posición definitiva. Esto conduce al siguiente invariante:

• a[i] < a[i+1] para i = k hasta n-1• a[j] < a [i] con j = 0 hasta k-1, todos desordenados

En palabras: "Los elementos desde k hasta n-1 ya están ordenados y son mayores que los primeros k".

Condiciones iniciales y finalesa) Condiciones iniciales: al principio no se puede decir nada, por lo

que se hace k = n, lo que dice que implica:

• a[i] < a[i+1] para i = n hasta n-1 (no existe elemento)• a[j] < a [n] con j = 0 hasta n-1, todos desordenados (a[n] no

existe)

¿Más comprensible?: al principio poner el mayor del arreglo en el lugar n-1 y hacer k = n-1

b) Condición final: k = 1 (o mientras k >= 2)

• a[i] < a[i+1] para i = 1 hasta n-1 • a[j] < a [1] con j = 0 hasta 0, todos desordenados

Ord. X selección: avanzar y restablecer invariante// Ordenar a[0], ..., a[n-1] por selección k = n; // inicialmente los n primeros están desordenadoswhile( k>1 )  { --k; //acercar k a la meta, se rompe el invariante    Llevar el max de a[0], ..., a[k] hacia a[k]; //esto restablece el invariante  }

Donde Llevar el max de a[0], ..., a[k] hacia a[k] =>i = 0; // a[i] es el max hasta el momentofor( j=1; j<=k; ++j )    if( a[j]>a[i] )        i = j;// ahora intercambiamos a[i] con a[k]t = a[i];a[i] = a[k];a[k] = t;

Ejemplo 2: ordenación por inserción

Este algoritmo va construyendo un trozo ordenado del arreglo al extremo izquierdo, y en cada iteración le agrega un nuevo elemento a ese grupo.

Invariante:

• a[i] < a[i+1] para i = 0 hasta k-1• a[k] hasta a[n-1] desordenados

En palabras: "Los elementos desde 0 hasta k-1 ya están ordenados y los siguientes desordenados".

Condiciones iniciales y finalesa) Condiciones iniciales: al principio se puede decir que el primer

elemento a[0] está ordenado por definición, por lo que se hace k = 1, lo que implica:

• a[i] < a[i+1] para i = 0 hasta 1-1• a[1] hasta a[n-1] desordenados

b) Condición final: k = n (o mientras k < n)

• a[i] < a[i+1] para i = 0 hasta n-1• a[n] hasta a[n-1] desordenados (no existe!)

Avanzar y restablecer invariante

// Ordenar a[0], ..., a[n-1] por inserción k = 0; // inicialmente el primer elemento esta ordenadowhile( k < n )  { ++k; //acercar k a la meta, se rompe el invariante Insertar a[k-1] entre a[0],...,a[k-2]; //esto restablece el invariante  }

Donde

Insertar a[k-1] entre a[0],...,a[k-2] =>for( j=k-1; j>0 && a[j-1]>a[j]; --j )  {    // intercambiar a[j-1] con a[j]    t = a[j];    a[j] = a[j-1];    a[j-1] = t;  }

OptimizaciónAl seguir el proceso de la inserción, se puede observar que la variable t toma siempre el mismo valor: el del elemento que se está insertando. Por lo tanto, se puede optimizar el programa realizando una única asignación a t antes de comenzar el ciclo. Otra observación es que la mayoría de las asignaciones a a[j-1] son inútiles, porque esa variable va a ser sobre-escrita en la iteración siguiente. Luego, se puede evitar esas asignaciones, reemplazándolas por una sola al final del ciclo:

Insertar a[k-1] entre a[0],...,a[k-2] =>// versión optimizadat = a[k];for( j=k; j>0 && a[j-1]>t; --j )    a[j] = a[j-1];a[j] = t;

Versión final optimizada(y algo variada)

// Ordenar a[0],...,a[n-1] por inserciónk = 1; // inicialmente primer elemento ordenado while( k < n )  {    // Insertar a[k] entre a[0],...,a[k-1]    t = a[k];    for( j=k; j>0 && a[j-1]>t; --j )        a[j] = a[j-1];    a[j] = t;    ++k; }

Ejemplo 2: ordenación por selección 

Este algoritmo se basa en hacer pasadas sucesivas sobre los datos. En cada pasada, se encuentra el máximo del arreglo, y se lo lleva al extremo derecho. Una vez hecho esto, ese elemento deja de ser considerado, porque se encuentra ya en su posición definitiva. Esto conduce al siguiente invariante:

• a[i] < a[i+1] para i = k hasta n-1• a[j] < a [i] con j = 0 hasta k-1, todos desordenados

En palabras: "Los elementos desde k hasta n-1 ya están ordenados y son mayores que los primeros k".

Condiciones iniciales y finalesa) Condiciones iniciales: al principio no se puede decir nada, por lo

que se hace k = n, lo que dice que implica:

• a[i] < a[i+1] para i = n hasta n-1 (no existe elemento)• a[j] < a [n] con j = 0 hasta n-1, todos desordenados (a[n] no

existe)

¿Más comprensible?: al principio poner el mayor del arreglo en el lugar n-1 y hacer k = n-1

b) Condición final: k = 1 (o mientras k >= 2)

• a[i] < a[i+1] para i = 1 hasta n-1 • a[j] < a [1] con j = 0 hasta 0, todos desordenados

Ord. X selección: avanzar y restablecer invariante// Ordenar a[0], ..., a[n-1] por selección k = n; // inicialmente los n primeros están desordenadoswhile( k>1 )  { --k; //acercar k a la meta, se rompe el invariante    Llevar el max de a[0], ..., a[k] hacia a[k]; //esto restablece el invariante  }

Donde Llevar el max de a[0], ..., a[k] hacia a[k] =>i = 0; // a[i] es el max hasta el momentofor( j=1; j<=k; ++j )    if( a[j]>a[i] )        i = j;// ahora intercambiamos a[i] con a[k]t = a[i];a[i] = a[k];a[k] = t;

Ejemplo 3: ordenación por burbujaEste método se basa en hacer pasadas de izquierda a derecha sobre los datos, intercambiando pares de elementos adyacentes que estén fuera de orden. Al final de cada pasada, en forma natural el máximo estará en la posición de más a la derecha (que es su posición final) y puede por lo tanto ser excluido en pasadas sucesivas. Esto conduce al siguiente invariante (idéntico al de ordenación por selección):

• a[i] < a[i+1] para i = k hasta n-1• a[j] < a [i] con j = 0 hasta k-1, todos desordenados

Ord. X burbuja: avanzar y restablecer invariante// Ordenar a[0], ..., a[n-1] por la burbuja (borrador)k = n;while( k>1 )  {    Hacer una pasada sobre a[0], ..., a[k-1];    Disminuir k;  }

Donde Hacer una pasada sobre a[0], ..., a[k-1] =>

for( j=0; j<=k-2; ++j )   if( a[j]>a[j+1] ){ // Intercambiar a[j] con a[j+1]        t = a[j]; a[j] = a[j+1]; a[j+1] = t;   }

y Disminuir k =>--k;

Ord. X burbuja: eficienciaDisminuir k => --k; Si el archivo está inicialmente ordenado, el programa igual hace n pasadas, cuando después de la primera ya podría haberse dado cuenta que el archivo ya estaba ordenado. Para aprovechar cualquier posible orden que pueda haber en el archivo, se puede hacer que el programa anote ("recuerde") el lugar en donde se produjo el último intercambio. Si la variable i se define de manera que el último intercambio en una pasada dada fue entre a[i-1] y a[i], entonces todos los elementos desde a[i] en adelante están ya ordenados (de lo contrario habría habido intercambios más hacia la derecha), y por lo tanto k se puede disminuir haciendo que sea igual a i: Hacer una pasada sobre a[0], ..., a[k-1] =>i=0;for( j=0; j<=k-2; ++j )  if( a[j]>a[j+1] )   {    t = a[j];  a[j] = a[j+1]; a[j+1] = t;        i = j+1; //Recordar el lugar del último intercambio  }Disminuir k => k=i;

Ejemplo 4: Xn

Cuando n es entero se puede programar una función más eficiente que la que usa java, basada en el cálculo de una serie. Incluso una solución simple sería más eficiente:

public static double power(double x, int n) { // Algoritmo simple y = 1; for( j=n; j>0; --j )     y = y*x; return y;}

Este algoritmo evidentemente toma tiempo O(n), y su invariante se puede escribir como

y * xj == xn

Aprovechando el invariante para la eficienciaEs posible encontrar un algoritmo sustancialmente más eficiente de la siguiente manera. Primero se desvinculan las dos ocurrencias de x en el invariante:

y = 1;z = x;for( j=n; j>0; --j )    y = y*z;

con invariante y * zj == xn

Esto podría parecer ocioso, pero permite hacer una optimización al observar que está permitido modificar la variable z al inicio del ciclo siempre que se mantenga la validez del invariante. En particular, si j resulta ser par, podemos elevar z al cuadrado si al mismo tiempo dividimos j por 2. De esta manera, el invariante sigue igual, pero j disminuye mucho más rápido.

Algoritmo eficiente no recursivoMejor todavía, si esto se puede hacer una vez, entonces se puede hacer muchas veces siempre que j siga siendo par:

y = 1;z = x;for( j=n; j>0; --j ) // Invariante: y * zj == xn  {    while( j es par )      {       z = z*z;        j = j/2;      }    y = y*z;  } La detección que j es par se puede implementar como j es par => j&1 == 0   Este algoritmo demora tiempo O(log n), lo cual se debe a que j sólo se puede dividir log n veces por 2 antes de llegar a 1. Es cierto que j sólo se divide cuando es par, pero si es impar en una iteración del for, está garantizado que será par a la siguiente.

Ejemplo 4: Explicar un algoritmo difícil Se tiene un arreglo con n elementos (a[0] hasta a[n-1]) blanco y negros desordenados. Dejar los elementos intercalados. Si hay mas de una clase que de otra dejarlos todos al final. Ejemplo, si inicialmente se tiene

dejarlos

invariante

???????????

i j

Ejemplo 4: Explicar un algoritmo difícil (cont.)

Inicialmente se hace i = 0; j = 1;

Condicion final: j = n => continuación: while (j < n)

Restablecer el invariante

??????????

i j

i j

i j

Si a[j] mismo color que a[i] no se hace nada, si no, se intercambia con a[i+1]; j++

Otras Estructuras: Vector• Una implementación de lista enlazada eficiente• Puede contener objetos de cualquier clase• Ultimas versiones de java apuntan a que todos sean de una sola

(super)clase

Vector v = new Vector(); //crea un vector vacio

v.add(“Hola”); v.add(new Scanner()); ...//agregar elementos al final,

v.add(5, “chao”); //agrega en el indice 5

//mostrar los elementosfor(int i = 0; i < v.size(); i++) System.out.println(v.get(i).toString());

47

Generics: chequeo de tipos• Usando Generics se puede hacer que se chequee el tipo de

objeto

Vector<Tipo> v = new Vector<Tipo>();

Solo se pueden poner objetos de la Clase Tipo (o derivados)

v.add(“Hola”); //produciría error de compilación

48

Ejercicio en clases

>=0< 0 desconocidos

i j

Se tiene un arreglo a[0] . . . a[n-1] con enteros y se quiere particionarlo de modo que queden todos los menores que cero a la izquierda y los iguales o mayores que cero a la derecha.

En palabras: los elementos anteriores a a[i] son menores que cero, los elementos desde a[i] hasta a[j-1] son mayores que cero y los elementos desde a[j] en adelante son desconocidos