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
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
INTRODUCCION
En esta pequea antologa veremos temas de suma importancia que nos ayudaran en la vida de programador, usando la tecnologa 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 informacin tales como escritos pero sin formato ya que no se le puede poner negrita, cursiva, subrayado y color. Tambin veremos su apertura en un cdigo java, llenado, su recorrido, el cerrado de la aplicacin y operaciones que se usan en el, adems 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 comn de las listas de enlace simple es la insercin 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 despus 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 ms memoria, porque necesitar los elementos del array ms 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).
ARCHIVOS DE TEXTO
Los archivos de texto plano son aquellos que estn compuestos nicamente por texto sin formato, solo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce tambin como archivos de texto llano o texto simple por carecer de informacin destinada a generar formatos y tipos de letra. Los archivos de texto plano (en ingls plain text) son aquellos que estn compuestos nicamente por texto sin formato, slo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Algunos de los sistemas de codificacin ms usados son: ASCII, ISO-8859-1 o latn-1, Unicode, etc. Se les conoce tambin como archivos de texto llano, o texto simple, por carecer de informacin destinada a generar formatos (negritas, subrayado, cursivas, tamao, etc.) y tipos de letra (por ejemplo, Arial, Times, Courier, etc.). El trmino texto plano proviene de una traduccin literal del trmino ingls plain text, trmino que en lengua castellana significa texto simple o texto sencillo. Las aplicaciones destinadas a la escritura y modificacin de archivos de texto se llaman editores de texto. En el artculo podr encontrar varios ejemplos de editores. En sistemas Unix las convenciones de nombres de archivos son ms relajadas. La extensin .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 aplicacin. 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.
APERTURA DE ARCHIVOS DE TEXTO

La clase file tiene un mtodo llamado readline () que retorna toda una lnea del archivo de texto y deja posicionado el puntero de archivo en la siguiente lnea. Cuando llega al final del archivo readline retorna un string vaco. 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 lnea: archi=open('datos.txt','r') Linea=archi.readline ()
LECTURA DE ARCHIVOS DE TEXTO

El while se repite mientras el mtodo readline () no retorne un string vaco. Dentro del while procedemos a imprimir la lnea que acabamos de leer y leemos la siguiente (el mtodo readline () retorna el contenido de toda la lnea inclusive el salto de lnea \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 mtodo readlines() en lugar de readline(). El mtodo readlines() retorna una lista con cada lnea del archivo de texto. Recordemos que podemos procesar luego cada elemento de la lista recorrindola 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
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 mtodos que nos permiten escribir a archivos de texto. El primero que vamos a ver es el mtodo read (), que nos devuelve un int. Con el cdigo Unicode del carcter ledo, para poder convertir este cdigo en un carcter 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 smbolo 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 mtodo del BufferedReader que nos va a ser muy til es el mtodo readline (), este mtodo nos permite leer todo un archivo mucho ms rpido y nos es muy til cuando queremos obtener datos de un archivo de inicio ya que podemos leer una lnea 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 mtodo 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 rpido 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 mtodos: 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.
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, sera una buena prctica el validar si dicho fichero existe o no. Tambin podramos escribir sobre el fichero directamente. Ahora que esto lo haramos 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 artculo nos explica de forma detallada lo simple que esto resulta. Resumiendo, bastar utilizar el mtodo 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 mtodos muy sencillos. Este buffer necesitar saber cual es el fichero. Esto se lo proporcionamos desde la clase FileWriter. Recuerda que la filosofa 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 cdigo nos quedara algo as: 1. BufferedWriter bw = new BufferedWriter(new FileWriter(sFichero));
ARCHIVOS DE TEXTO Y PUNTEROS Para escribir texto nos apoyamos en el mtodo .write() del buffer. Muy sencillo. La verdad es que no se me ocurra que texto grabar sobre el fichero, a si que, al final, vamos a volcar 10 lneas iguales ayudndonos 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 mtodo .close(). Y lo otro, que toda la operativa de la clase java.io.* nos avisar de sus problemas de acceso a fichero, elevndonos una excepcin IOException. Que habr que capturar en alguna parte de nuestro cdigo.
OPERACIONES CON ARCHIVOS DE TEXTO

En Java, puede utilizar el objeto file para realizar operaciones bsicas de E/S de archivos, tales como crear, abrir, leer un archivo y escribir en el. Por ejemplo puede utilizar los mtodos de la clase File para realizar operaciones de E/S de archivos, tal como utilizar los mtodos 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 ejecucin del programa. Una vez finaliza la ejecucin o se apaga el computador los datos se pierden. Para evitar esto, la mayora de Lenguajes de Programacin permiten almacenar y recuperar informacin 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 ejecucin. Algunos ejemplos tpicos de excepciones es la divisin por cero, elevar cero al exponente cero, raz de nmeros negativos, al trabajar con archivos, cuando se intenta abrir un archivo para lectura que
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 'Divisin 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 mtodo 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 mtodo flush() del PrintWriter para escribir todo al archivo. Al terminar de usar el archivo tambin debemos recordar que debemos cerrarlo mediante el mtodo close() del PrintWriter. Esta operacin nos permite aadir nuevos datos al final de un archivo, pero sin modificar la ya existente Esta operacin 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 mtodos para lectura de datos desde un archivo: read(), readline(), readlines(). read(n): este mtodo devuelve una cadena con los primeros n caracteres del archivo. Si no recibe ningn argumento devuelve todo el contenido del archivo. Si el valor de n es mayor que el nmero de caracteres del archivo, devuelve los caracteres del archivo.
10
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 transicin a Java. Desafortunadamente, tantas similitudes hacen que no se repare en algunas diferencias que son vitales. La terminologa 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 seccin. C tiene tipos de datos bsicos y punteros. C++ modifica un poco este panorama y le aade los tipos referencia. Java tambin especifica sus tipos primitivos, elimina cualquier tipo de punteros y tiene tipos referencia mucho ms claros. Todo este maremgnum de terminologa provoca cierta consternacin, as que los prrafos que siguen intentan aclarar lo que realmente significan los trminos que se utilizan. Se conocen ya ampliamente todos los tipos bsicos 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 ms rgido. Adems, Java aade los tipos boolean y hace imprescindible el uso de este tipo booleano en sentencias condicionales. C y C++ permiten la declaracin y uso de punteros, que pueden ser utilizados en cualquier lugar. Esta tremenda flexibilidad resulta muy til, pero tambin es la causa de que se pueda colgar todo el sistema. La intencin principal en el uso de los punteros es comunicarse ms directamente con el hardware, haciendo que el cdigo se acelere. Desafortunadamente, este modelo de tan bajo nivel hace que se pierda robustez y seguridad en la programacin y hace muy difciles tareas como la liberacin automtica de memoria, la defragmentacin de memoria, o realizar programacin distribuida de forma clara y eficiente. Las referencias se incorporaron a C++ en un intento de manejar punteros de C de forma ms limpia y segura. Sin embargo, como no elimina los punteros, la verdad es que su propsito lo consigue a medias. Es ms, se podra decir que con las referencias C++, el lenguaje se vuelve ms complicado y no es ms 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 ejecucin sobre la
ARCHIVOS DE TEXTO Y PUNTEROS solucin basada en punteros, pero es ms por las deficiencias de los punteros que por las ventajas de las referencias. Pinsese en una referencia como si se tratase de la llave electrnica de la habitacin de un hotel. Vamos a utilizar precisamente este ejemplo del Hotel para demostrar el uso y la utilizacin que se puede hacer de las referencias en Java.
QUE ES UNA LISTA LIGADA

La Lista enlazada proporciona el mtodo 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. Obsrvese 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 bsqueda 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 sla direccin. En alguna aplicaciones es prctico 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.
12
QUE ES UN PUNTERO
Un puntero es una variable que contiene una direccin de memoria. Normalmente, esa direccin es la posicin de otra variable en la memoria. Si la variable p de tipo float, est en la direccin 1111 y la variable ptr en la direccin 1021, entonces, si el contenido de ptr es la direccin de p, es decir 1111, decimos que ptr es un apuntador a p.
p
ptr
1021
1111 45.23
1111
Algunas consideraciones para utilizar punteros o apuntadores:
Existen dos operadores especiales de punteros: & y *. El operador de direccin (&) devuelve la direccin de memoria de su operando. El operador de indireccin (*) devuelve el contenido de la direccin apuntada por el operando. Los punteros apuntan a un tipo de variable, el cual se define en la declaracin, 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 direccin & delante del nombre de una variable nos devuelve la direccin 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 indireccin *. Si usamos la ilustracin 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.
ARCHIVOS DE TEXTO Y PUNTEROS En conclusin, si ptr contiene la direccin 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 tambin el valor de la variable p. Concretamente si hacemos *ptr = 100; entonces, el valor de la variable p tambin es 100. Todo esto se da porque ptr a punta a p o de manera equivalente, porque ptr contiene la direccin de p. De manera general una declaracin 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; /* declaracin 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 posicin 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;
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, despus de la asignacin 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 cdigo hace lo siguiente, lee un nmero 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 mtodo, llamado Abrir, al cual le deben de pasar como parmetro la direccin del archivo, este mtodo 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();
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);
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 declaracin de asignacin 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.
17
QUE ES UN NODO
inf. sig sig Inicio
Null
inf.
sig
inf. sig
inf
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 (package private) ID java.lang.String
El conjunto de los hijos de este nodo El identificador de este nodo si el nodo es para evaluar a los perros o al conejo
(package private) identidad java.lang.String Indica (package private) nivel int (package private) valor int
El nivel al que pertenece este nodo 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
18
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 int revisarAvanzadaConejo()
caracteres
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


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
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
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
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

Adems 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 cdigo 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 cdigo anterior, la referencia next a un nodo Employee es un enlace.
23
ARCHIVOS DE TEXTO Y PUNTEROS Los cuatro conceptos de arriba nos llevan a la siguiente definicin: una lista enlazada es una secuencia de nodos que se interconectan mediante sus campos de enlace . En ciencia de la computacin se utiliza una notacin especial para ilustrar las listas enlazadas. En la siguiente imagen aparece una variante de esta notacin que utilizar a lo largo de esta seccin:
La figura anterior presenta tres nodos: A, B y C. Cada nodo se divide en reas de contenido (en naranja) y una o ms 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 ningn otro nodo. Aunque se pueden crear muchos tipos de listas enlazadas, las tres variantes ms 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:
24
Un algoritmo comn de las listas de enlace simple es la insercin 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 despus 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 pseudocdigo:
DECLARE CLASS Node DECLARE STRING name DECLARE Node next END DECLARE DECLARE Node top = NULL
Este pseudocdigo declara una clase auto-referenciada llamada Node con un campo no de enlace llamado name y un campo de enlace llamado next. Tambin 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 todava 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 ms 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 pseudocdigo 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 expansin. Por el contrario, los arrays requieren memoria extra si se necesita expandirlo (una vez que todos los elementos tienen datos no se pueden aadir datos nuevos a un array).
25
Ofrecen una insercin/borrado de elementos ms rpida que sus operaciones equivalentes en los arrays. Slo se tienen que actualizar los enlaces despus de identificar la posicin de insercin/borrado. Desde la perspectiva de los arrays, la insercin de datos requiere el movimiento de todos los otros datos del array para crear un elemento vaco. De forma similar, el borrado de un dato existente requiere el movimiento de todos los otros datos para eliminar el elementovaco.
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 ms rpido a los datos, medante ndices basados en enteros.
Las listas enlazadas son ms apropiadas cuando se trabaja con datos dinmicos. En otras palabras, inserciones y borrados con frecuencia. Por el contrario, los arrays son ms apropiados cuando los datos son estticos (las inserciones y borrados son raras). De todas formas, no olvide que si se queda sin espacio cuando aade tems a un array, debe crear un array ms 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 ms memoria, porque necesitar los elementos del array ms 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 coleccin per se sino de un mapeo, es la que define la interfaz Map<K,V>, 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 podramos tener un mapeo en el que las claves fueran los das de la semana y los valores, el nmero de lneas de cdigo que escribimos.
26
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
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 cnsola 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 excepcin 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 excepcin , ya que se va a crear o sobreescribir System.err.println("FileStreamsTest: " + e); } catch (IOException e) { // excepcin ms genrica 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
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;

// 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 despus 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) {
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 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 textimpri = new TextArea(20,40); textimpri.setBounds(150,220,310,190); donde se imprime la tabla //cuadro //cuadro
//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); insertar = new Button("Insertar"); largo , ancho insertar.setBounds(330,90,100,20); buscar = new Button("Buscar");
//no se //no
//x, y,
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,
32
CONCLUSION
Bueno estos temas nos servirn en la programacin, 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 tambin relacionado ala apertura de archivos de texto mediante cdigos y usar listas ligadas, punteros y nodos etc., por eso es muy importante el manejo de el lenguaje de programacin 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.scribd.com/doc/11410360/JavaListas LISTAS LIGADAS http://www.scribd.com/doc/12882782/ListasLigadas NODOS http://www.scribd.com/doc/135534535/Nodos_java PUNTEROS http://www.scribd.com/doc/114335434/Apuntadoresenjava
33

Archivos de Texto y Punteros en Java

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Archivos de Texto y Punteros en Java

Cargado por

Copyright:

Formatos disponibles

ARCHIVOS DE TEXTO Y PUNTEROS

LUGAR: SAN ANDRES TUXTLA VER.