Archivos De Texto Y Punteros En Java

ARCHIVOS DE TEXTO Y PUNTEROS COLEGIO NACIONAL DE EDUCACION PROFESIONAL TECNICA PLANTEL: DR GUILLERMO FIGEROA CARDENAS MODULO PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS ALUMNO: ROBERTO ANTONIO COTO IXTEPAN GRUPO: 4202 INFORMATICA

CUARTO SEMESTRE

___________ FIRMA

LUGAR: SAN ANDRES TUXTLA VER.

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

1

ARCHIVOS DE TEXTO Y PUNTEROS

INDICE INTRODUCCION........................................................................................................................................................3 ARCHIVOS DE TEXTO..............................................................................................................................................4 APERTURA DE ARCHIVOS DE TEXTO...............................................................................................................5 LECTURA DE ARCHIVOS DE TEXTO..................................................................................................................6 RECORRIDO DE UN ARCHIVO DE TEXTO................................................................................................7 ESCRIBIR EN UN ARCHIVO DE TEXTO.............................................................................................................8 OPERACIONES CON ARCHIVOS DE TEXTO.....................................................................................................9 CERRAR ARCHIVOS DE TEXTO........................................................................................................................10 PUNTEROS.................................................................................................................................................................11 QUE ES UNA LISTA LIGADA..............................................................................................................................12 QUE ES UN PUNTERO..........................................................................................................................................13 COMO SE CREA UN PUNTERO...........................................................................................................................14 QUE ES UN NODO.................................................................................................................................................18 COMO AGREGAR UN NODO..............................................................................................................................20 COMO MODIFICAR UN NODO...........................................................................................................................22 QUE ES UNA LISTA CIRCULAR DOBLEMENTE LIGADA.............................................................................23 Listas Enlazadas frente a Arrays.........................................................................................................................25 CODIGOS ...................................................................................................................................................................27 CONCLUSION............................................................................................................................................................33 .......................................................................................................................................................................................33

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

2

ARCHIVOS DE TEXTO Y PUNTEROS

INTRODUCCION En esta pequeña antología veremos temas de suma importancia que nos ayudaran en la vida de programador, usando la tecnología JAVA™ y usando sus aplicaciones, comenzaremos a ver algunos de estos temas, son los archivos de texto y los punteros, para que sirven los archivos de texto, estos nos ayudaran a guardar información tales como escritos pero sin formato ya que no se le puede poner negrita, cursiva, subrayado y color. También veremos su apertura en un código java, llenado, su recorrido, el cerrado de la aplicación y operaciones que se usan en el, además veremos un poco sobre punteros, ya que los punteros casi no son utilizados en java si no que se usan como referencias a un nodo u otro objeto. Un algoritmo común de las listas de enlace simple es la inserción de nodos. Este algoritmo está implicado de alguna forma porue tiene mucho que ver con cuatro casos: cuando el nodo se debe insertar antes del primer nodo; cuando el nodo se debe insertar después del último nodo; cuando el nodo se debe insertar entre dos nodos; y cuando la lista de enlace simple no existe Mezclando una lista de enlace simple con un array uni-dimensional para acceder a los nodos mediante los índices del array no se consigue nada. Gastará más memoria, porque necesitará los elementos del array más los nodos, y tiempo, porque necesitará mover los ítems del array siempre que inserte o borre un nodo. Sin embargo, si es posible integrar el array con una lista enlazada para crear una estructura de datos útil (por ejemplo, las tablas hash).

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

3

ARCHIVOS DE TEXTO Y PUNTEROS

ARCHIVOS DE TEXTO Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra. Los archivos de texto plano (en inglés plain text) son aquellos que están compuestos únicamente por texto sin formato, sólo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Algunos de los sistemas de codificación más usados son: ASCII, ISO-8859-1 o latín-1, Unicode, etc. Se les conoce también como archivos de texto llano, o texto simple, por carecer de información destinada a generar formatos (negritas, subrayado, cursivas, tamaño, etc.) y tipos de letra (por ejemplo, Arial, Times, Courier, etc.). El término texto plano proviene de una traducción literal del término inglés plain text, término que en lengua castellana significa texto simple o texto sencillo. Las aplicaciones destinadas a la escritura y modificación de archivos de texto se llaman editores de texto. En el artículo podrá encontrar varios ejemplos de editores. En sistemas Unix las convenciones de nombres de archivos son más relajadas. La extensión .txt se ha hecho popular en los últimos tiempos, pero habitualmente el contenido del archivo se determina con programas que examinan los primeros bytes, como por ejemplo el comando file. Los archivos nos permiten guardar nuestro trabajo para que no perdamos datos una vez que cerremos la aplicación. Existen dos tipos de archivos en Java, en este trial veremos los primeros. Los archivos de texto en Java se manejan mediante la clase BufferedReader y la clase PrintWriter.

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

4

ARCHIVOS DE TEXTO Y PUNTEROS

APERTURA DE ARCHIVOS DE TEXTO La clase file tiene un método llamado readline () que retorna toda una línea del archivo de texto y deja posicionado el puntero de archivo en la siguiente línea. Cuando llega al final del archivo readline retorna un string vacío. def creartxt(): archi=open('datos.txt','w') archi.close() def grabartxt(): archi=open('datos.txt','a') archi.write('Linea 1\n') archi.write('Linea 2\n') archi.write('Linea 3\n') archi.close() def leertxt(): archi=open('datos.txt','r') linea=archi.readline() while linea!="": print linea linea=archi.readline() archi.close() creartxt() grabartxt() leertxt() Luego de de abrir el archivo para lectura procedemos a leer la primera línea: archi=open('datos.txt','r') Linea=archi.readline ()

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

5

ARCHIVOS DE TEXTO Y PUNTEROS

LECTURA DE ARCHIVOS DE TEXTO El while se repite mientras el método readline () no retorne un string vacío. Dentro del while procedemos a imprimir la línea que acabamos de leer y leemos la siguiente (el método readline () retorna el contenido de toda la línea inclusive el salto de línea \n): while linea!="": print linea linea=archi.readline() Podemos leer todo el contenido de un archivo de texto y almacenarlo en una lista (esto tiene sentido si el archivo de texto no es muy grande): def creartxt(): archi=open('datos.txt','w') archi.close() def grabartxt(): archi=open('datos.txt','a') archi.write('Linea 1\n') archi.write('Linea 2\n') archi.write('Linea 3\n') archi.close() def leertxtenlista(): archi=open('datos.txt','r') lineas=archi.readlines() print lineas archi.close() creartxt() grabartxt() leertxtenlista() Utilizamos el método readlines() en lugar de readline(). El método readlines() retorna una lista con cada línea del archivo de texto. Recordemos que podemos procesar luego cada elemento de la lista recorriéndola con una estructura repetitiva: def leertxtenlista(): archi=open('datos.txt','r') lineas=archi.readlines() for li in lineas: print li archi.close() PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

6

ARCHIVOS DE TEXTO Y PUNTEROS

RECORRIDO DE UN ARCHIVO DE TEXTO El bitstream que creamos al guardar un archivo podemos leerlo mediante la clase BufferedReader. Pero al igual que la clase PrintWriter esta clase no sabe qué tipo de archivo está leyendo por lo que hay que especificarle que obtenga el bitstream desde un archivo utilizando la clase FileReader. Para construir un FileReader lo único que tenemos que hacer es utilizar el constructor que recibe el nombre de archivo o un objeto de la clase File representando el archivo que queremos leer. Una vez que ya tenemos el FileReader debemos utilizarlo para construir un BufferedReader, de la manera que se ve a la izquierda. Una vez que tengamos el BufferedReader podemos utilizar varios métodos que nos permiten escribir a archivos de texto. El primero que vamos a ver es el método read (), que nos devuelve un int. Con el código Unicode del carácter leído, para poder convertir este código en un carácter debemos utilizar un cast a char. Para hacer un cast de un tipo de dato a otro tenemos que poner la variable que queremos que reciba el valor, un símbolo de igual, el tipo de dato al que queremos convertir y el valor que queremos convertir, como se ve en la imagen de la izquierda. El otro método del BufferedReader que nos va a ser muy útil es el método readline (), este método nos permite leer todo un archivo mucho más rápido y nos es muy útil cuando queremos obtener datos de un archivo de inicio ya que podemos leer una línea cada vez y utilizarla de la manera que nos convenga. Al igual que cuando utilizamos el PrintWriter debemos cerrar el archivo al terminarlo de utilizar utilizando el método close() del BufferedReader ya que aunque en este caso no se pierden datos, otros programas no van a poder utilizar el archivo hasta que lo cerremos. Por último vamos a darle un rápido vistazo a la clase File que nos es muy útil siempre que trabajamos con archivos. El constructor de File recibe un String con la ruta del archivo, una vez que creamos el objeto tipo File podemos utilizar los siguientes métodos: f.canRead(): Devuelve un boolean verdadero en caso de que se pueda leer el archivo, falso en caso de que no se pueda leer. f.canWrite(): Devuelve un boolean verdadero en caos de que se pueda escribir el archivo, falso en caso de que no se pueda escribir. f.delete(): Intenta borrar el archivo, devuelve true si pudo hacerlo, false en caso de que no lo haya borrado. PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

7

ARCHIVOS DE TEXTO Y PUNTEROS f.deleteOnExit(): Borra el archivo al terminar el programa, muy útil cuando necesitamos un lugar para guardar muchos datos y no queremos saturar la memoria porque nos permite crear un archivo temporal en el que se guarden los datos.

ESCRIBIR EN UN ARCHIVO DE TEXTO Si vamos a escribir en un fichero de texto, sería una buena práctica el validar si dicho fichero existe o no. También podríamos escribir sobre el fichero directamente. Ahora que esto lo haríamos si no nos importase mucho el contenido que este tuviese. Para validar si existe un fichero podemos leer el ejemplo Saber si existe un fichero con Java. Dicho artículo nos explica de forma detallada lo simple que esto resulta. Resumiendo, bastará utilizar el método exists() de la clase File. 1. String sFichero = "fichero.txt"; 2. File fichero = new File(sFichero); 3. 4. if (fichero.exists()) {...} En el caso de que no exista el fichero, nos pondremos manos a la obra para escribir sobre el fichero. Lo primero que tendremos que hacer será crear un BufferedWriter. Esta clase nos ayuda a manejar los stream en forma de buffer con métodos muy sencillos. Este buffer necesitará saber cual es el fichero. Esto se lo proporcionamos desde la clase FileWriter. Recuerda que la filosofía de acceso a la lectura y escritura a los ficheros, siempre es la misma. Buffer, que envuelve a Reader, que a su vez envuelve al fichero (o stream). El código nos quedaría algo así: 1. BufferedWriter bw = new BufferedWriter(new FileWriter(sFichero)); PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

8

ARCHIVOS DE TEXTO Y PUNTEROS Para escribir texto nos apoyamos en el método .write() del buffer. Muy sencillo. La verdad es que no se me ocurría que texto grabar sobre el fichero, a si que, al final, vamos a volcar 10 líneas iguales ayudándonos de un bucle for. 1. for (int x=0;x<10;x++) 2. bw.write("Fila numero " + x + "\n"); No nos podemos olvidar de dos últimas cosas. Siempre que manejemos el fichero para escribir deberemos de cerrarle con el método .close(). Y lo otro, que toda la operativa de la clase java.io.* nos avisará de sus problemas de acceso a fichero, elevándonos una excepción IOException. Que habrá que capturar en alguna parte de nuestro código.

OPERACIONES CON ARCHIVOS DE TEXTO En Java, puede utilizar el objeto file para realizar operaciones básicas de E/S de archivos, tales como crear, abrir, leer un archivo y escribir en el. Por ejemplo puede utilizar los métodos de la clase File para realizar operaciones de E/S de archivos, tal como utilizar los métodos createNewFile o delete de la clase File para eliminar o crear un archivo. Puede utilizar las clases Buffered Reader y Buffered Writer para leer y escribir el contenido de archivo. Archivos (Ficheros) y Excepciones Los programas que hemos desarrollado hasta el momento trabajan con datos almacenados temporalmente en memoria durante la ejecución del programa. Una vez finaliza la ejecución o se apaga el computador los datos se pierden. Para evitar esto, la mayoría de Lenguajes de Programación permiten almacenar y recuperar información en archivos, brindando las herramientas necesarias para manejo de los datos y el control de errores(excepciones). Excepciones Son errores que ocurren en tiempo de ejecución. Algunos ejemplos típicos de excepciones es la división por cero, elevar cero al exponente cero, raíz de números negativos, al trabajar con archivos, cuando se intenta abrir un archivo para lectura que PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

9

ARCHIVOS DE TEXTO Y PUNTEROS no existe. Para manejar este tipo de errores Python nos ofrece la sentencia try y except cuya estructura general es: Try: except: Ejemplo: def division(a,b): try: definida'

print float(a)/b except:

print 'División por cero no esta

CERRAR ARCHIVOS DE TEXTO Es muy importante recordar que debemos cerrar el archivo al terminar de utilizarlo, ya que en caso contrario no estamos seguros de que todos los cambios se guarden en el archivo. Para poder cerrar el archivo utilizamos el método close() del PrintWriter. Al igual que al leer debemos recordar utilizar un try. Cuando utilizamos el PrintWriter todo entra a un buffer y una vez que terminemos de escribir los datos debemos recordar utilizar el método flush() del PrintWriter para escribir todo al archivo. Al terminar de usar el archivo también debemos recordar que debemos cerrarlo mediante el método close() del PrintWriter. Esta operación nos permite añadir nuevos datos al final de un archivo, pero sin modificar la ya existente Esta operación nos permite acceder a los datos de un archivo(creado con anterioridad) para extraerlos y realizar operaciones con ellos. Sin embargo, no permite adicionar o modificar los datos del archivo. Python nos proporciona varios métodos para lectura de datos desde un archivo: read(), readline(), readlines(). read(n): este método devuelve una cadena con los primeros n caracteres del archivo. Si no recibe ningún argumento devuelve todo el contenido del archivo. Si el valor de n es mayor que el número de caracteres del archivo, devuelve los caracteres del archivo.

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

10

ARCHIVOS DE TEXTO Y PUNTEROS

PUNTEROS Java se asemeja mucho a C y C++. Esta similitud, evidentemente intencionada, es la mejor herramienta para los programadores, ya que facilita en gran manera su transición a Java. Desafortunadamente, tantas similitudes hacen que no se repare en algunas diferencias que son vitales. La terminología utilizada en estos lenguajes, a veces es la misma, pero hay grandes diferencias subyacentes en su significado, como se ha recalcado a lo largo de esta sección. C tiene tipos de datos básicos y punteros. C++ modifica un poco este panorama y le añade los tipos referencia. Java también especifica sus tipos primitivos, elimina cualquier tipo de punteros y tiene tipos referencia mucho más claros. Todo este maremágnum de terminología provoca cierta consternación, así que los párrafos que siguen intentan aclarar lo que realmente significan los términos que se utilizan. Se conocen ya ampliamente todos los tipos básicos de datos: datos base, integrados, primitivos e internos; que son muy semejantes en C, C++ y Java; aunque Java simplifica un poco su uso a los desarrolladores haciendo que el chequeo de tipos sea bastante más rígido. Además, Java añade los tipos boolean y hace imprescindible el uso de este tipo booleano en sentencias condicionales. C y C++ permiten la declaración y uso de punteros, que pueden ser utilizados en cualquier lugar. Esta tremenda flexibilidad resulta muy útil, pero también es la causa de que se pueda colgar todo el sistema. La intención principal en el uso de los punteros es comunicarse más directamente con el hardware, haciendo que el código se acelere. Desafortunadamente, este modelo de tan bajo nivel hace que se pierda robustez y seguridad en la programación y hace muy difíciles tareas como la liberación automática de memoria, la defragmentación de memoria, o realizar programación distribuida de forma clara y eficiente. Las referencias se incorporaron a C++ en un intento de manejar punteros de C de forma más limpia y segura. Sin embargo, como no elimina los punteros, la verdad es que su propósito lo consigue a medias. Es más, se podría decir que con las referencias C++, el lenguaje se vuelve más complicado y no es más poderoso que antes . Las referencias deben ser inicializadas cuando se declaran y no se pueden alterar posteriormente. Esto permite incrementar la eficiencia en tiempo de ejecución sobre la PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

11

ARCHIVOS DE TEXTO Y PUNTEROS solución basada en punteros, pero es más por las deficiencias de los punteros que por las ventajas de las referencias. Piénsese en una referencia como si se tratase de la llave electrónica de la habitación de un hotel. Vamos a utilizar precisamente este ejemplo del Hotel para demostrar el uso y la utilización que se puede hacer de las referencias en Java.

QUE ES UNA LISTA LIGADA La Lista enlazada proporciona el método insertAt () que coge el índice en la lista, donde el nuevo nodo ha de ser insertado, como primer argumento. El segundo argumento es el objeto que será almacenado en la lista. Obsérvese que no es necesario colocar moldeo alguno para hacer algo a una clase descendiente que depende de uno de sus padres. Una lista ligada circular es una lista en la cual el último nodo es ligado al primer elemento de la lista. La ventaja de este tipo de estructura es que siempre se puede llegar a cualquier nodo siguiendo las ligas. La desventaja e s que si no se tiene cuidado una búsqueda puede resultar en un ciclo infinito. Esto se puede evitar al determinar a un nodo como nodo-cabeza o nodo inicial. Hasta ahora se han manejado listas que se recorren en una sóla dirección. En alguna aplicaciones es práctico o hasta indispensable poder recorrer una lista en ambas direcciones. Para estos casos se tienen las listas doblemente ligadas. Esta propiedad implica que que cada nodo debe tener dos apuntadores, uno al nodo predecesor y otro al nodo sucesor.

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

12

ARCHIVOS DE TEXTO Y PUNTEROS

QUE ES UN PUNTERO Un puntero es una variable que contiene una dirección de memoria. Normalmente, esa dirección es la posición de otra variable en la memoria. Si la variable p de tipo float, está en la dirección 1111 y la variable ptr en la dirección 1021, entonces, si el contenido de ptr es la dirección de p, es decir 1111, decimos que ptr es un apuntador a p.

ptr

p

1021

1111

1111

45.23

Algunas consideraciones para utilizar punteros o apuntadores: Existen dos operadores especiales de punteros: & y *. El operador de dirección (&) devuelve la dirección de memoria de su operando. El operador de indirección (*) devuelve el contenido de la dirección apuntada por el operando. Los punteros apuntan a un tipo de variable, el cual se define en la declaración, por ejemplo; int float char

*ptr1; /* apunta solo a variables tipo int */ *ptr; /* apunta solo a variables tipo float */ *prt2; /* apunta solo a variable tipo char */

El operador de dirección & delante del nombre de una variable nos devuelve la dirección de la variable, ejemplo; int float

a; p, q;

ptr1 = &a; ptr = &p;

El valor apuntado por un puntero se obtiene con el operador de indirección *. Si usamos la ilustración anterior *ptr corresponde al valor 45.23 de la variable p. Si hacemos q = *ptr; entonces q y p tienen el mismo valor, pero ptr no apunta a q, sino a p. PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

13

ARCHIVOS DE TEXTO Y PUNTEROS En conclusión, si ptr contiene la dirección de memoria de la variable p, entonces ptr apunta a p y *ptr indica el contenido de p, es decir, cuando se modifica o cambia el valor de *ptr se cambia también el valor de la variable p. Concretamente si hacemos *ptr = 100; entonces, el valor de la variable p también es 100. Todo esto se da porque ptr a punta a p o de manera equivalente, porque ptr contiene la dirección de p. De manera general una declaración de un puntero consiste en un tipo base(int, char, flotat), un asterisco * y el nombre de la variable. La forma general es: tipo *nombre_de _variable;

COMO SE CREA UN PUNTERO Se pueden declarar apuntadores a una estructura: typedef struct { int edad; float salario; /* declaración de tipo estructura global */ char nom[15]; }xxx; xxx

*ptr3;

/* apuntador al tipo de estructura xxx */

a única forma de hacer que un puntero haga referencia a otra posición de memoria (instancia) es asignarlo a un objeto creado con la sentencia new o usando el operador = y asignar otra área de memoria a dicho objeto. Ejemplo: String cadena1=new String("Hola Mundo"); String cadena2=new String("Esta es una cadena con siete palabras"); ........ cadena1=cadena2;

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

14

ARCHIVOS DE TEXTO Y PUNTEROS En este caso el objeto cadena1 que tiene una referencia a una instancia de la clase String que contiene la cadena "Hola Mundo" es asignado a una instancia de String que contiene la cadena "Esta es una cadena con siete palabras", quedando liberada la memoria ocupada por la primera instancia de String que estaba asignada al objeto cadena1, después de la asignación los dos objetos cadena1 y cadena2 apuntan (hacen referencia) a la misma instancia de la clase String que contiene la cadena "Esta es una cadena con siete palabras". Recientemente he tenido que leer archivos de java de texto, me resultó muy sencillo con la siguiente sentencia: El siguiente código hace lo siguiente, lee un número de un archivo, lo leo como String, lo convierto a entero y lo guardo en la variable maxim. int maxim; File f = new File( “cont.txt” ); BufferedReader entrada = new BufferedReader( new FileReader( f ) ); if (f.exists()){ String texto = entrada.readLine(); maxim = Integer.parseInt(texto); } Con lo de crear quiero indicar escribir sobre un archivo de texto, o ya bien sea, aunque tambien puede crear un archivo de texto y no escribirle nada, aunque no es muy logico, jejeje. Para hacer esto se puede hacer de varias forma, yo prefiero utilizar un String para mandar a leer y escribir a un archivo, ya que de esa manera puede utilizar el tokenizer y hacer un escanner mas facilmente, aunque si se desea un escanner y parser mas completo se debe de usar herramientas como JLex y Cup (Medio controlo eso por si necesitan ayuda, ojala que me recuerde nada mas, XD). Para escribir este es un método, llamado Abrirá, al cual le deben de pasar como parámetro la dirección del archivo, este método solo carga el contenido de un archivo de texto desde una ubicacion especifica a un string: public String Abrira(String Dir){ String Llevo_Texto = new String(”"); try{ FileReader Carga_Escritura = new FileReader(Dir); BufferedReader Lev_Text = new BufferedReader(Carga_Escritura); String Llevo_Otro = new String(); PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

15

ARCHIVOS DE TEXTO Y PUNTEROS while((Llevo_Otro = Lev_Text.readLine())!=null){ if(Llevo_Texto == null){ Llevo_Texto = Llevo_Otro; } if(Llevo_Texto != null){ Llevo_Texto = Llevo_Texto + Llevo_Otro + “\n”; } } Lev_Text.close(); Carga_Escritura.close(); } catch(FileNotFoundException e){ System.out.println(”El Archivo No se encontro”); } catch(IOException e){ System.out.println(”ERROR: No se puede leer el archivo”); } return Llevo_Texto; } Para llamar a este metodo seria:

VarInstanceada.Abrira(”C:\entrada.txt”);

Si se desea escribir en un archivo de texto, seria: public boolean Guardara(String Conte, String Dir){ if(Directo != “”) Dir = Directo + Dir; boolean Est; try{ FileWriter Carga_Escritura = new FileWriter(Dir); BufferedWriter Lev_Text = new BufferedWriter(Carga_Escritura); if(Conte == null){ Conte = “”; } Lev_Text.write(Conte); PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

16

ARCHIVOS DE TEXTO Y PUNTEROS Lev_Text.close(); Carga_Escritura.close(); Est = true; } catch(FileNotFoundException e) { System.out.println(”El Archivo No se encontro”); Est = false; } catch(IOException e){ System.out.println(”ERROR: No se puede leer el archivo”); Est = false; } return Est; } Se usa un boolean para validar si se logro guardar o no. Este metodo crea archivos y les inserta texto, si se desea agregar mas contenido a un archivo bastara con, abrir primero el archivo y guardar el contenido en algun lado y luego volver a crear el archivo (Con el mismo nombre) y escribir lo que tenia antes y luego agregandole lo que deseemos. Como siempre es mas facil ver esto en codigo, asi que les dejo mi clase de manejar archivo. Como en el caso de cualquier otra variable, un puntero puede utilizarse a la derecha de una declaración de asignación para asignar su valor a otro puntero. Por ejemplo: int x; int *p1,*p2; p1=&x; p2=p1; Tanto p1 como p2 apuntan a x.

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

17

ARCHIVOS DE TEXTO Y PUNTEROS

QUE ES UN NODO inf. sig sig

inf.

sig

inf. sig

inf

Inicio Null

Nodo1 Nodo4

Nodo2

Nodo3

Esta clase representa un nodo en el arbol de busqueda de los tableros del juego de los Perros y el Conejo

Field Summary (package private) hijos java.util.Vector

El conjunto de los hijos de este nodo

(package private) ID java.lang.String

El identificador de este nodo

(package private) identidad java.lang.String Indica

si el nodo es para evaluar a los perros o al conejo

(package private) nivel int

El nivel al que pertenece este nodo

(package private) valor int

El valor de este nodo

Constructor Summary Nodo()

Constructor vacio Nodo(java.lang.String tablero, java.lang.String ide, int nivel)

Obtenemos una instancia de Nodo a partir de su identificador, si es perro o conejo y el nivel al que pertenece

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

18

ARCHIVOS DE TEXTO Y PUNTEROS

Method Summary void creaHijos()

Metodo para crear los hijos de este nodo int evaluar(Cromosoma cromosoma)

Metodo que sirve para evaluar a este nodo java.util.Vector getHijos()

Metodo para obtener los hijos de este Nodo java.lang.String getId()

Metodo para obtener el id de este Nodo java.lang.String getIdentidad()

Metodo para obtener la identidad de este Nodo int getNivel()

Metodo para obtener el nivel de este Nodo int getValor()

Metodo para obtener el valor de este Nodo private ordenaCadena(java.lang.String cadena) java.lang.String Metodo para ordenar una cadena de

caracteres

int revisarAvanzadaConejo()

Metodo para revisar cuantas posibilidades tiene el conejo de avanzar int revisarJugadasGanadoras()

Metodo para revisar si el nodo es una buena posicion para presionar y ganar int revisarJugadasPerdedoras()

Metodo para revisar si el nodo es una jugada mala int revisarMovimientosConejo()

Metodo para contar cuantos posibles movimientos tiene el conejo int revisarNivelConejo()

Metodo para revisar si el conejo no se encuentra en una posicion peligrosa int revisarProfundidadPerros()

Metodo para revisar si los perros se encuentran en su profundidad PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

19

ARCHIVOS DE TEXTO Y PUNTEROS int revisarSiYaGane()

Metodo para revisar si el perro esta en una posicion ganadora inminente void setHijos(java.util.Vector hijos)

Metodo para asignar los hijos de este Nodo void setId(java.lang.String id)

Metodo para asignar el id de este Nodo void setIdentidad(java.lang.String identidad)

Metodo para asignar la identidad de este Nodo void setNivel(int nivel)

Metodo para asignar el nivel de este Nodo void setValor(int valor)

Metodo para asignar el valor de este Nodo java.lang.String toString()

Metodo que sirve para obtener la representacion String de este objeto Methods inherited from class java.lang.Object , clone, equals, finalize, getClass, hashCode, notify, notifyAll, registerNatives, wait, wait, wait

COMO AGREGAR UN NODO Nodo public Nodo() Constructor vacio Nodo public Nodo(java.lang.String tablero, java.lang.String ide, int nivel) Obtenemos una instancia de Nodo a partir de su identificador, si es perro o conejo y el nivel al que pertenece Parameters: tablero - El identificador del nodo ide - Si es para perros o conejo PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

20

ARCHIVOS DE TEXTO Y PUNTEROS nivel - El nivel al que pertenece este nodo toString public java.lang.String toString() Metodo que sirve para obtener la representacion String de este objeto Overrides: toString in class java.lang.Object evaluar public int evaluar(Cromosoma cromosoma) Metodo que sirve para evaluar a este nodo Parameters: cromosoma - El cromosoma que contiene los factores de la formula revisarProfundidadPerros public int revisarProfundidadPerros() Metodo para revisar si los perros se encuentran en su profundidad revisarSiYaGane public int revisarSiYaGane() Metodo para revisar si el perro esta en una posicion ganadora inminente revisarMovimientosConejo public int revisarMovimientosConejo() Metodo para contar cuantos posibles movimientos tiene el conejo revisarNivelConejo public int revisarNivelConejo() Metodo para revisar si el conejo no se encuentra en una posicion peligrosa revisarAvanzadaConejo public int revisarAvanzadaConejo() Metodo para revisar cuantas posibilidades tiene el conejo de avanzar revisarJugadasPerdedoras public int revisarJugadasPerdedoras() Metodo para revisar si el nodo es una jugada mala revisarJugadasGanadoras public int revisarJugadasGanadoras() Metodo para revisar si el nodo es una buena posicion para presionar y ganar creaHijos PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

21

ARCHIVOS DE TEXTO Y PUNTEROS public void creaHijos() Metodo para crear los hijos de este nodo ordenaCadena private java.lang.String ordenaCadena(java.lang.String cadena) Metodo para ordenar una cadena de caracteres Parameters: cadena - La cadena a ordenar

COMO MODIFICAR UN NODO setId public void setId(java.lang.String id) Metodo para asignar el id de este Nodo Parameters: id - El nuevo id setIdentidad public void setIdentidad(java.lang.String identidad) Metodo para asignar la identidad de este Nodo Parameters: identidad - La nueva identidad setHijos public void setHijos(java.util.Vector hijos) Metodo para asignar los hijos de este Nodo Parameters: hijos - Los nuevos hijos setValor public void setValor(int valor) Metodo para asignar el valor de este Nodo Parameters: valor - El nuevo valor setNivel public void setNivel(int nivel) Metodo para asignar el nivel de este Nodo Parameters: nivel - El nuevo nivel getHijos PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

22

ARCHIVOS DE TEXTO Y PUNTEROS public java.util.Vector getHijos() Metodo para obtener los hijos de este Nodo getValor public int getValor() Metodo para obtener el valor de este Nodo getNivel public int getNivel() Metodo para obtener el nivel de este Nodo

QUE ES UNA LISTA CIRCULAR DOBLEMENTE LIGADA Además de los arrays, otra de las estructuras de datos muy utilizada es la lista enlazada. Esta estructura implica cuatro conceptos: clase auto-refenciada, nodo, campo de enlace y enlace. • • • • • • • • • • •

Clase auto-referenciada: una clase con al menos un campo cuyo tipo de referencia es el nombre de la clase: class Employee { private int empno; private String name; private double salary; public Employee next; // Other members } Employee es una clase auto-referenciada porque su campo next tiene el tipo Employee.

• •

•

Nodo: un objeto creado desde una clase auto-referenciada. Campo de enlace: un campo cuyo tipo de referencia es el nombre de la clase. En el fragmento de código anterior, next es un campo de enlace. Por el contrario, empno, name, y salary son campos no de enlace. Enlace: la referencia a un campo de enlace. En el fragmento de código anterior, la referencia next a un nodo Employee es un enlace.

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

23

ARCHIVOS DE TEXTO Y PUNTEROS Los cuatro conceptos de arriba nos llevan a la siguiente definición: una lista enlazada es una secuencia de nodos que se interconectan mediante sus campos de enlace. En ciencia de la computación se utiliza una notación especial para ilustrar las listas enlazadas. En la siguiente imagen aparece una variante de esta notación que utilizaré a lo largo de esta sección:

La figura anterior presenta tres nodos: A, B y C. Cada nodo se divide en áreas de contenido (en naranja) y una o más áreas de enlace (en verde). Las áreas de contenido representan todos los campos que no son enlaces, y cada área de enlace representa un campo de enlace. Las áreas de enlace de A y C tienen unas flechas para indicar que referencian a otro nodo del mismo tipo (o subtipo). El único área de enlace de B incorpora una X para indicar una referencia nula. En otras palabras, B no está conectado a ningún otro nodo. Aunque se pueden crear muchos tipos de listas enlazadas, las tres variantes más populares son la lista de enlace simple, la lista doblemente enlazada y la lista enlazada circular. Exploremos esas variantes, empezando con la lista enlazada. Lista de Enlace Simple Una lista de enlace simple es una lista enlazada de nodos, donde cada nodo tiene un único campo de enlace. Una variable de referencia contiene una referencia al primer nodo, cada nodo (excepto el último) enlaza con el nodo siguiente, y el enlace del último nodo contiene null para indicar el final de la lista. Aunque normalmente a la variable de referencia se la suele llamar top, usted puede elegir el nombre que quiera. La siguiente figura presenta una lista de enlace simple de tres nodos, donde top referencia al nodo A, A conecta con B y B conecta con C y C es el nodo final:

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

24

ARCHIVOS DE TEXTO Y PUNTEROS

Un algoritmo común de las listas de enlace simple es la inserción de nodos. Este algoritmo está implicado de alguna forma porue tiene mucho que ver con cuatro casos: cuando el nodo se debe insertar antes del primer nodo; cuando el nodo se debe insertar después del último nodo; cuando el nodo se debe insertar entre dos nodos; y cuando la lista de enlace simple no existe. Antes de estudiar cada caso consideremos el siguiente pseudocódigo: DECLARE CLASS Node DECLARE STRING name DECLARE Node next END DECLARE DECLARE Node top = NULL

Este pseudocódigo declara una clase auto-referenciada llamada Node con un campo no de enlace llamado name y un campo de enlace llamado next. También declara una variable de referencia top (del tipo Node) que contiene una referencia al primer Node de una lista de enlace simple. Como la lista todavía no existe, el valor inicial de top es NULL. Cada uno de los siguientes cuatro casos asume las declaraciones de Node y top: •

• • • •

La lista de enlace simple no existe:: Este es el caso más simple. Se crea un Node, se asigna su referencia a top, se inicializa su campo no de enlace, y se asigna NULL a su campo de enlace. El siguiente pseudocódigo realiza estas tareas: top = NEW Node top.name = "A" top.next = NULL

Listas Enlazadas frente a Arrays Las listas enlazadas tienen las siguiente ventajas sobre los arrays: •

No requieren memoria extra para soportar la expansión. Por el contrario, los arrays requieren memoria extra si se necesita expandirlo (una vez que todos los elementos tienen datos no se pueden añadir datos nuevos a un array).

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

25

ARCHIVOS DE TEXTO Y PUNTEROS

•

Ofrecen una inserción/borrado de elementos más rápida que sus operaciones equivalentes en los arrays. Sólo se tienen que actualizar los enlaces después de identificar la posición de inserción/borrado. Desde la perspectiva de los arrays, la inserción de datos requiere el movimiento de todos los otros datos del array para crear un elemento vacío. De forma similar, el borrado de un dato existente requiere el movimiento de todos los otros datos para eliminar el elementovacío.

En contraste, los arrays ofrecen las siguiente ventajas sobre las listas enlazadas: • •

Los elementos de los arrays ocupan menos memoria que los nodos porque no requieren campos de enlace. Los arrays ofrecen un aceso más rápido a los datos, medante índices basados en enteros.

Las listas enlazadas son más apropiadas cuando se trabaja con datos dinámicos. En otras palabras, inserciones y borrados con frecuencia. Por el contrario, los arrays son más apropiados cuando los datos son estáticos (las inserciones y borrados son raras). De todas formas, no olvide que si se queda sin espacio cuando añade ítems a un array, debe crear un array más grande, copiar los datos del array original el nuevo array mayor y elimiar el original. Esto cuesta tiempo, lo que afecta especialmente al rendimiento si se hace repetidamente. Mezclando una lista de enlace simple con un array uni-dimensional para acceder a los nodos mediante los índices del array no se consigue nada. Gastará más memoria, porque necesitará los elementos del array más los nodos, y tiempo, porque necesitará mover los ítems del array siempre que inserte o borre un nodo. Sin embargo, si es posible integrar el array con una lista enlazada para crear una estructura de datos útil (por ejemplo, las tablas hash). Otra estructura de datos que forma parte del framework, aunque no deriva de Collection<E>, dado que no se trata de una colección per se sino de un mapeo, es la que define la interfaz Map, el conocido diccionario o matriz asociativa, en el que cada valor tiene asociado una clave que usaremos para recuperar el elemento, en lugar de un índice como el caso de las listas. Por ejemplo podríamos tener un mapeo en el que las claves fueran los días de la semana y los valores, el número de líneas de código que escribimos.

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

26

ARCHIVOS DE TEXTO Y PUNTEROS

CODIGOS APERTURA DE UN ARCHIVO DE TEXTO import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class readText { /** * @param args */ public static void main(String[] args) { File f = new File( "E:\\investiogacion iber.txt" ); BufferedReader entrada; try { entrada = new BufferedReader( new FileReader( f ) ); String linea; while(entrada.ready()){ linea = entrada.readLine(); System.out.println(linea); } }catch (IOException e) { e.printStackTrace(); } } } Este programa lo que hace es abrir un archivo de texto desde una unidad por ejemplo la unidad C:// seguido con el nombre del archivo y lee el archivo de texto

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

27

ARCHIVOS DE TEXTO Y PUNTEROS ESCRIBIR EN UN ARCHIVO DE TEXTO import java.io.*; class FileStreamsTest { public static void main(String[] args) { try { File inputFile = new File("original.txt"); File outputFile = new File("outagain.txt"); //Creamos entradas y salidas por cónsola FileInputStream fis = new FileInputStream(inputFile); FileOutputStream fos = new FileOutputStream(outputFile); int c; while ((c = fis.read()) != -1) { //lee byte a byte de fis y lo vuelca en fos fos.write(c); } fis.close(); fos.close();//importante , no dejarse abierto canales } catch (FileNotFoundException e) { //la excepción provendria de no encontrar original.txt // originada en la linea FileInputStream fis = new FileInputStream(inputFile); // java exige recoger la excepcion al usar este canal ( try{..} catch{..} ) // el fichero de salida no genera excepción , ya que se va a crear o sobreescribir System.err.println("FileStreamsTest: " + e); } catch (IOException e) { // excepción más genérica de entrada / salida System.err.println("FileStreamsTest: " + e); } } } Este programa realiza un apertura y escritura de un archivo de texto asi como poderlo editar a nuestro gusto usando principales variables como el filewritter entre otros

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

28

ARCHIVOS DE TEXTO Y PUNTEROS NODOS // SLLDelDemo.java class SLLDelDemo { static class Node { String name; Node next; } public static void main (String [] args) { // Build Figure 6's singly linked list (i.e., B A D C) Node top = new Node (); top.name = "C"; top.next = null; Node temp = new Node (); temp.name = "D"; temp.next = top; top = temp; temp = new Node (); temp.name = "A"; temp.next = top; top = temp; temp = new Node (); temp.name = "B"; temp.next = top; top = temp; dump ("Initial singly-linked list", top); // 1. Delete the first node top = top.next; dump ("After first node deletion", top); // Put back B temp = new Node (); temp.name = "B"; temp.next = top; top = temp; PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

29

ARCHIVOS DE TEXTO Y PUNTEROS // 2. Delete any node but the first node temp = top; while (temp.name.equals ("A") == false) temp = temp.next; temp.next = temp.next.next; }

dump ("After D node deletion", top);

static void dump (String msg, Node topNode) { System.out.print (msg + " ");

}

while (topNode != null) { System.out.print (topNode.name + " "); topNode = topNode.next; } System.out.println ();

}

Lo que realiza este programa es hacer una referencia a un nodo y crear punteros después ordenar las letras A,B,C,D entre otras mas un msj en pantalla Listas ligadas import import import import import

java.awt.*; java.net.*; java.io.*; java.awt.event.*; java.util.*;

class Tabla extends Frame { Panel panel; TextField textver,textinser,textbus; TextArea textimpri; Button mostrar, buscar, insertar, cierra; Label lab1, lab2, titulo; public static final int size_hash = 5; LinkedList []Arreglo = new LinkedList[size_hash]; Tarea1 prueba = new Tarea1(Arreglo,size_hash); public Tabla(String title) { PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

30

ARCHIVOS DE TEXTO Y PUNTEROS super (title); Font f = new Font( "Tahoma", 0 , 13 ); titulo = new Label("TABLA HASH"); titulo.setBounds(180,20,400,50); Font ff = new Font( "Tahoma", 1 ,18 ); titulo.setFont( ff ); add(titulo); setFont( f ); setResizable(false); //no maximizar setBounds(150,100,500,450); setLayout(null); textver = new TextField(40); textver.setBounds(60,170,400,25); para ver comentarios

//cuadro

textinser = new TextField(40); textinser.setBounds(180,90,130,25); //cuadro para escribir cadenas a insertar textbus = new TextField(40); textbus.setBounds(180,130,130,25); para escribir cadenas a buscar

//cuadro

textimpri = new TextArea(20,40); textimpri.setBounds(150,220,310,190); donde se imprime la tabla

//area

textver.setText("Introduzca una cadena arriba y haga click en el boton insertar "); textimpri.setEditable(false); puede escribir textver.setEditable(false); se puede escribir textinser.setEditable(true); textbus.setEditable(true);

//no se

insertar = new Button("Insertar"); largo , ancho insertar.setBounds(330,90,100,20);

//x, y,

//no

buscar = new Button("Buscar"); PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

31

ARCHIVOS DE TEXTO Y PUNTEROS buscar.setBounds(330,130,100,20); mostrar = new Button("Mostrar_Tabla"); mostrar.setBounds(55,240,90,25); cierra = new Button("Cerrar"); cierra.setBounds(55,300,90,25); mostrar.setEnabled(false); buscar.setEnabled(false); cierra.setEnabled(true);

//desabiliter

lab1 = new Label("Busca Cadena: "); lab2 = new Label("Dar una Cadena: "); lab1.setBounds(60,130,110,20); lab2.setBounds(60,90,110,20); add(lab1); add(lab2); add(textver); add(textimpri); add(textinser); add(textbus); add(insertar); add(buscar); add(mostrar); add(cierra); mostrar.addActionListener(new accion()); buscar.addActionListener(new accion()); insertar.addActionListener(new accion()); cierra.addActionListener(new accion()); addWindowListener(new Cerrar()); setVisible(true); } Este programa te permite ingresar caracteres mediante una lista ligada y mandarla imprimir en pantallag,guardarla en una cadena y la busca,

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

32

ARCHIVOS DE TEXTO Y PUNTEROS

CONCLUSION Bueno estos temas nos servirán en la programación, ya que es muy importante aprender a programar nuestras propias aplicaciones tales como los juegos u otros programas que nos pueden servir en nuestra vida cotidiana y también relacionado ala apertura de archivos de texto mediante códigos y usar listas ligadas, punteros y nodos etc., por eso es muy importante el manejo de el lenguaje de programación java en nuestra vida como programador,

ARCHIVOS DE TEXTO http://www.wikipedia.com/searchresults=?archivos_texto.html ABRIR ,EDITAR Y CERRAR ARCHIVOS DE TEXTO http://www.magusoft.com/trials/open_file=?archivos_texto LISTAS http://www.pdfcoke.com/doc/11410360/JavaListas LISTAS LIGADAS http://www.pdfcoke.com/doc/12882782/ListasLigadas NODOS http://www.pdfcoke.com/doc/135534535/Nodos_java PUNTEROS http://www.pdfcoke.com/doc/114335434/Apuntadoresenjava

PROGRAMACION ORIENTADA A OBJETOS PSP: IBER ALEJANDRO PUCHETA SOLIS INFORMATICA 4202

33