Archivos de texto y punteros en java

ARCHIVOS DE TEXTO Y PUNTEROS

COLEGIO NACIONAL DE EDUCACION PROFESIONAL TECNICA

PLANTEL: DR GUILLERMO FIGEROA CARDENAS

MODULOPROGRAMACION 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


INDICE

INTRODUCCION........................................................................................................................................................3

ARCHIVOS DE TEXTO.............................................................................................................................................4

APERTURA DE ARCHIVOS DE TEXTO..............................................................................................................5LECTURA DE ARCHIVOS DE TEXTO.................................................................................................................6RECORRIDO DE UN ARCHIVO DE TEXTO........................................................................................................7ESCRIBIR EN UN ARCHIVO DE TEXTO.............................................................................................................8OPERACIONES CON ARCHIVOS DE TEXTO.....................................................................................................9CERRAR ARCHIVOS DE TEXTO........................................................................................................................10

PUNTEROS.................................................................................................................................................................11

QUE ES UNA LISTA LIGADA..............................................................................................................................12QUE ES UN PUNTERO..........................................................................................................................................13COMO SE CREA UN PUNTERO..........................................................................................................................14QUE ES UN NODO.................................................................................................................................................18COMO AGREGAR UN NODO..............................................................................................................................20COMO MODIFICAR UN NODO...........................................................................................................................22QUE ES UNA LISTA CIRCULAR DOBLEMENTE LIGADA............................................................................23

Listas Enlazadas frente a Arrays.........................................................................................................................25

CODIGOS....................................................................................................................................................................27

CONCLUSION...........................................................................................................................................................33

..........................................................................................................33


2


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


3


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.


4


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


5


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


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


7


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


8

http://www.google.com/search?hl=en&q=allinurl%3AFileWriter+java.sun.com&btnI=I'm%20Feeling%20Lucky

http://www.google.com/search?hl=en&q=allinurl%3ABufferedWriter+java.sun.com&btnI=I'm%20Feeling%20Lucky

http://www.google.com/search?hl=en&q=allinurl%3ABufferedWriter+java.sun.com&btnI=I'm%20Feeling%20Lucky

http://www.google.com/search?hl=en&q=allinurl%3AFile+java.sun.com&btnI=I'm%20Feeling%20Lucky

http://www.google.com/search?hl=en&q=allinurl%3AFile+java.sun.com&btnI=I'm%20Feeling%20Lucky

http://www.google.com/search?hl=en&q=allinurl%3AString+java.sun.com&btnI=I'm%20Feeling%20Lucky


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


9


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: print float(a)/b except: print 'División por cero no esta definida'

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.


10


PUNTEROSJava 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


11


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.


12


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.

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 *ptr1; /* apunta solo a variables tipo int */float *ptr; /* apunta solo a variables tipo float */char *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 a; ptr1 = &a;float p, q; 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


13

1111

1021

45.23

1111ptrp


hacemos q = *ptr; entonces q y p tienen el mismo valor, pero ptr no apunta a q, sino a p.

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;


14


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


15


BufferedReader Lev_Text = new BufferedReader(Carga_Escritura);String Llevo_Otro = new String();

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 = “”;}


16


Lev_Text.write(Conte);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.


17

inf. sig inf. sig inf. sig inf sig

Nodo1 Nodo2 Nodo3 Nodo4

Inicio

Null


QUE ES UN NODO

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) java.util.Vector

hijos El conjunto de los hijos de este nodo

(package private) java.lang.String

ID El identificador de este nodo

(package private) java.lang.String

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

(package private) int

nivel El nivel al que pertenece este nodo

(package private) int

valor El valor de este nodo

Constructor SummaryNodo() 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 java.lang.String

ordenaCadena(java.lang.String cadena) 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


19

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#revisarProfundidadPerros()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#revisarNivelConejo()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#revisarMovimientosConejo()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#revisarJugadasPerdedoras()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#revisarJugadasGanadoras()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#revisarAvanzadaConejo()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#ordenaCadena(java.lang.String)

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#getValor()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#getNivel()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#getIdentidad()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#getId()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#getHijos()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Cromosoma.html

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#evaluar(Cromosoma)

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#creaHijos()


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 NODONodopublic Nodo()Constructor vacio

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


20

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#toString()

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#setValor(int)

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#setNivel(int)

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#setIdentidad(java.lang.String)

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#setId(java.lang.String)

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#setHijos(java.util.Vector)

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Nodo.html#revisarSiYaGane()


tablero - El identificador del nodo ide - Si es para perros o conejo nivel - El nivel al que pertenece este nodotoStringpublic java.lang.String toString()Metodo que sirve para obtener la representacion String de este objeto Overrides: toString in class java.lang.Object

evaluarpublic int evaluar(Cromosoma cromosoma)Metodo que sirve para evaluar a este nodo Parameters: cromosoma - El cromosoma que contiene los factores de la formula

revisarProfundidadPerrospublic int revisarProfundidadPerros()Metodo para revisar si los perros se encuentran en su profundidad

revisarSiYaGanepublic int revisarSiYaGane()Metodo para revisar si el perro esta en una posicion ganadora inminente

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

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

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

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

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


21

http://www.lania.mx/~asanchez/IA/RasGenetico/api/Cromosoma.html


creaHijospublic void creaHijos()Metodo para crear los hijos de este nodo

ordenaCadenaprivate java.lang.String ordenaCadena(java.lang.String cadena)Metodo para ordenar una cadena de caracteres Parameters: cadena - La cadena a ordenar

COMO MODIFICAR UN NODOsetIdpublic void setId(java.lang.String id)Metodo para asignar el id de este Nodo Parameters: id - El nuevo id

setIdentidadpublic void setIdentidad(java.lang.String identidad)Metodo para asignar la identidad de este Nodo Parameters: identidad - La nueva identidad

setHijospublic void setHijos(java.util.Vector hijos)Metodo para asignar los hijos de este Nodo Parameters: hijos - Los nuevos hijos

setValorpublic void setValor(int valor)Metodo para asignar el valor de este Nodo Parameters: valor - El nuevo valor

setNivelpublic void setNivel(int nivel)Metodo para asignar el nivel de este Nodo Parameters: nivel - El nuevo nivel


22


getHijospublic java.util.Vector getHijos()Metodo para obtener los hijos de este Nodo

getValorpublic int getValor()Metodo para obtener el valor de este Nodo

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


23


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:


24


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 nextEND 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).


25


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


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


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


28


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;


29


// 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 java.awt.*;import java.net.*;import java.io.*;import java.awt.event.*;import 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) {


30


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); //cuadro

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); //cuadro

para escribir cadenas a buscar

textimpri = new TextArea(20,40);textimpri.setBounds(150,220,310,190); //area

donde se imprime la tabla

textver.setText("Introduzca una cadena arriba y haga click en el boton insertar ");

textimpri.setEditable(false); //no se puede escribir

textver.setEditable(false); //no se puede escribir

textinser.setEditable(true);textbus.setEditable(true);

insertar = new Button("Insertar"); //x, y, largo , ancho

insertar.setBounds(330,90,100,20);

buscar = new Button("Buscar");


31


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); //desabiliterbuscar.setEnabled(false);cierra.setEnabled(true);

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 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 TEXTOhttp://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

NODOShttp://www.scribd.com/doc/135534535/Nodos_java

PUNTEROShttp://www.scribd.com/doc/114335434/Apuntadoresenjava


33

http://www.scribd.com/doc/114335434/Apuntadoresenjava

http://www.scribd.com/doc/135534535/Nodos_java

http://www.scribd.com/doc/12882782/ListasLigadas

http://www.scribd.com/doc/11410360/JavaListas

http://www.magusoft.com/trials/open_file=?archivos_texto

http://www.wikipedia.com/searchresults=?archivos_texto.html

Archivos de texto y punteros en java

Documents

Transcript of Archivos de texto y punteros en java