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 1

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

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

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

INFORMATICA 4202
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.close()
def leertxt():
archi=open('datos.txt','r')
linea=archi.readline()
while linea!="":
print linea
archi.close()
creartxt()
grabartxt()
leertxt()
Luego de de abrir el archivo para lectura procedemos a leer la primera línea:
Linea=archi.readline ()

INFORMATICA 4202
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
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.close()
def leertxtenlista():
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():
lineas=archi.readlines()
for li in lineas:
print li
archi.close()

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

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

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

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

INFORMATICA 4202
PUNTEROS
Java se asemeja mucho a C y C++. Esta similitud, evidentemente intencionada, es la
mejor herramienta para los programadores, ya que facilita en gran manera su transición
a Java. Desafortunadamente, tantas similitudes hacen que no se repare en algunas
diferencias que son vitales.
La terminología utilizada en estos lenguajes, a veces es la misma, pero hay grandes

diferencias subyacentes en su significado, como se ha recalcado a lo largo de esta
sección.
C tiene tipos de datos básicos y punteros. C++ modifica un poco este panorama y le
añade los tipos referencia. Java también especifica sus tipos primitivos, elimina
cualquier tipo de punteros y tiene tipos referencia mucho más claros.
Todo este maremágnum de terminología provoca cierta consternación, así que los
párrafos que siguen intentan aclarar lo que realmente significan los términos que se
utilizan.
Se conocen ya ampliamente todos los tipos básicos de datos: datos base, integrados,
primitivos e internos; que son muy semejantes en C, C++ y Java; aunque Java
simplifica un poco su uso a los desarrolladores haciendo que el chequeo de tipos sea
bastante más rígido. Además, Java añade los tipos boolean y hace imprescindible el
uso de este tipo booleano en sentencias condicionales.
C y C++ permiten la declaración y uso de punteros, que pueden ser utilizados en

cualquier lugar. Esta tremenda flexibilidad resulta muy útil, pero también es la causa de
que se pueda colgar todo el sistema.
La intención principal en el uso de los punteros es comunicarse más directamente con

el hardware, haciendo que el código se acelere. Desafortunadamente, este modelo de
tan bajo nivel hace que se pierda robustez y seguridad en la programación y hace muy
difíciles tareas como la liberación automática de memoria, la defragmentación de
memoria, o realizar programación distribuida de forma clara y eficiente.
Las referencias se incorporaron a C++ en un intento de manejar punteros de C de

forma más limpia y segura. Sin embargo, como no elimina los punteros, la verdad es
que su propósito lo consigue a medias. Es más, se podría decir que con las referencias
C++, el lenguaje se vuelve más complicado y no es más poderoso que antes
.
Las referencias deben ser inicializadas cuando se declaran y no se pueden alterar
posteriormente. Esto permite incrementar la eficiencia en tiempo de ejecución sobre la
INFORMATICA 4202
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.

INFORMATICA 4202
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.
p
ptr 1021 1111
1111 45.23
Algunas consideraciones para utilizar punteros o apuntadores:
Existen dos operadores especiales de punteros: & y *. El operador de dirección (&)

devuelve la dirección de memoria de su operando. El operador de indirección (*)
devuelve el contenido de la dirección apuntada por el operando.
Los punteros apuntan a un tipo de variable, el cual se define en la declaración, por

ejemplo;
int *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
hacemos q = *ptr; entonces q y p tienen el mismo valor, pero ptr no apunta a q, sino a
p.
INFORMATICA 4202
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;

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

try{
FileReader Carga_Escritura = new FileReader(Dir);
BufferedReader Lev_Text = new BufferedReader(Carga_Escritura);
String Llevo_Otro = new String();
INFORMATICA 4202
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);
INFORMATICA 4202
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.

INFORMATICA 4202
QUE ES UN NODO
inf. sig inf. sig inf. sig inf

sig
Inicio
Null
Nodo1 Nodo2 Nodo3

Nodo4
Esta clase representa un nodo en el arbol de busqueda de los tableros del juego de los
Perros y el Conejo
Field Summary
(package private) hijos
java.util.Vector El conjunto de los hijos de este nodo
(package private) ID
java.lang.String El identificador de este nodo
(package private) identidad
java.lang.String Indica si el nodo es para evaluar a los perros o al conejo
(package private) nivel
int El nivel al que pertenece este nodo
(package private) valor
int El valor de este nodo
Constructor Summary
Nodo()
Constructor vacio
Nodo(java.lang.String tablero, java.lang.String ide,
int nivel)
Obtenemos una instancia de Nodo a partir de su
identificador, si es perro o conejo y el nivel al que pertenece

INFORMATICA 4202
Method Summary
void creaHijos()
Metodo para crear los hijos de este nodo
int evaluar(Cromosoma cromosoma)
Metodo que sirve para evaluar a este nodo
java.util.Vector getHijos()
Metodo para obtener los hijos de este Nodo
java.lang.String getId()
Metodo para obtener el id de este Nodo
java.lang.String getIdentidad()
Metodo para obtener la identidad de este Nodo
int getNivel()
Metodo para obtener el nivel de este Nodo
int getValor()
Metodo para obtener el valor de este Nodo
private ordenaCadena(java.lang.String cadena)
java.lang.String Metodo para ordenar una cadena de caracteres
int revisarAvanzadaConejo()
Metodo para revisar cuantas posibilidades tiene el conejo de
avanzar
int revisarJugadasGanadoras()
Metodo para revisar si el nodo es una buena posicion para
presionar y ganar
int revisarJugadasPerdedoras()
Metodo para revisar si el nodo es una jugada mala
int revisarMovimientosConejo()
Metodo para contar cuantos posibles movimientos tiene el
conejo
int revisarNivelConejo()
Metodo para revisar si el conejo no se encuentra en una
posicion peligrosa
int revisarProfundidadPerros()
Metodo para revisar si los perros se encuentran en su
profundidad

INFORMATICA 4202
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
INFORMATICA 4202
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
INFORMATICA 4202
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
INFORMATICA 4202
public java.util.Vector getHijos()

Metodo para obtener los hijos de este Nodo
getValor
public int getValor()
Metodo para obtener el valor de este Nodo
getNivel
public int getNivel()
Metodo para obtener el nivel de este Nodo
QUE ES UNA LISTA CIRCULAR DOBLEMENTE LIGADA
Además de los arrays, otra de las estructuras de datos muy utilizada es la lista
enlazada. Esta estructura implica cuatro conceptos: clase auto-refenciada, nodo,
campo de enlace y enlace.
• Clase auto-referenciada: una clase con al menos un campo cuyo tipo de

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

Employee.
• Nodo: un objeto creado desde una clase auto-referenciada.

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

INFORMATICA 4202
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:

INFORMATICA 4202
Un algoritmo común de las listas de enlace simple es la inserción de nodos. Este

algoritmo está implicado de alguna forma porue tiene mucho que ver con cuatro casos:
cuando el nodo se debe insertar antes del primer nodo; cuando el nodo se debe
insertar después del último nodo; cuando el nodo se debe insertar entre dos nodos; y
cuando la lista de enlace simple no existe. Antes de estudiar cada caso consideremos
el siguiente pseudocódigo:
DECLARE CLASS Node

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

Node, se asigna su referencia a top, se inicializa su campo no de enlace, y se
asigna NULL a su campo de enlace. El siguiente pseudocódigo realiza estas
tareas:
• top = NEW Node
•
• top.name = "A"
• top.next = NULL
Listas Enlazadas frente a Arrays
Las listas enlazadas tienen las siguiente ventajas sobre los arrays:
• No requieren memoria extra para soportar la expansión. Por el contrario, los

arrays requieren memoria extra si se necesita expandirlo (una vez que todos los
elementos tienen datos no se pueden añadir datos nuevos a un array).

INFORMATICA 4202
• 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.

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

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

INFORMATICA 4202
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;

INFORMATICA 4202
// 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) {

INFORMATICA 4202
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");

INFORMATICA 4202
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); //desabiliter
buscar.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,

INFORMATICA 4202
CONCLUSION
Bueno estos temas nos servirán en la programación, ya que es muy importante

aprender a programar nuestras propias aplicaciones tales como los juegos u otros
programas que nos pueden servir en nuestra vida cotidiana y también relacionado ala
apertura de archivos de texto mediante códigos y usar listas ligadas, punteros y nodos
etc., por eso es muy importante el manejo de el lenguaje de programación java en
nuestra vida como programador,
ARCHIVOS DE TEXTO
http://www.wikipedia.com/searchresults=?archivos_texto.html
ABRIR ,EDITAR Y CERRAR ARCHIVOS DE TEXTO
http://www.magusoft.com/trials/open_file=?archivos_texto
LISTAS
http://www.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

INFORMATICA 4202

Archivos de Texto y Punteros en Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Archivos de Texto y Punteros en Java

Uploaded by

Copyright:

Available Formats

ARCHIVOS DE TEXTO Y PUNTEROS

COLEGIO NACIONAL DE EDUCACION PROFESIONAL

PLANTEL: DR GUILLERMO FIGEROA CARDENAS

PSP: IBER ALEJANDRO PUCHETA SOLIS

ALUMNO: ROBERTO ANTONIO COTO IXTEPAN

GRUPO: 4202 INFORMATICA

LUGAR: SAN ANDRES TUXTLA VER.

PROGRAMACION ORIENTADA A OBJETOS 1

PROGRAMACION ORIENTADA A OBJETOS 2

También veremos su apertura en un código java, llenado, su recorrido, el cerrado de la

Un algoritmo común de las listas de enlace simple es la inserción de nodos. Este

PROGRAMACION ORIENTADA A OBJETOS 3

Las aplicaciones destinadas a la escritura y modificación de archivos de texto se llaman

En sistemas Unix las convenciones de nombres de archivos son más relajadas. La

PROGRAMACION ORIENTADA A OBJETOS 4

APERTURA DE ARCHIVOS DE TEXTO

Luego de de abrir el archivo para lectura procedemos a leer la primera línea:

PROGRAMACION ORIENTADA A OBJETOS 5

LECTURA DE ARCHIVOS DE TEXTO

Utilizamos el método readlines() en lugar de readline(). El método readlines()

Recordemos que podemos procesar luego cada elemento de la lista

PROGRAMACION ORIENTADA A OBJETOS 6

RECORRIDO DE UN ARCHIVO DE TEXTO

El bitstream que creamos al guardar un archivo podemos leerlo mediante la clase

Al igual que cuando utilizamos el PrintWriter debemos cerrar el archivo al terminarlo de

f.canRead(): Devuelve un boolean verdadero en caso de que se pueda leer el archivo,

PROGRAMACION ORIENTADA A OBJETOS 7

f.deleteOnExit(): Borra el archivo al terminar el programa, muy útil cuando necesitamos

ESCRIBIR EN UN ARCHIVO DE TEXTO

Resumiendo, bastará utilizar el método exists() de la clase File.

1. String sFichero = "fichero.txt";

Recuerda que la filosofía de acceso a la lectura y escritura a los ficheros, siempre es la

El código nos quedaría algo así:

1. BufferedWriter bw = new BufferedWriter(new FileWriter(sFichero));

PROGRAMACION ORIENTADA A OBJETOS 8

1. for (int x=0;x<10;x++)

OPERACIONES CON ARCHIVOS DE TEXTO

Archivos (Ficheros) y Excepciones

Son errores que ocurren en tiempo de ejecución. Algunos ejemplos típicos de

PROGRAMACION ORIENTADA A OBJETOS 9

Try: except: Ejemplo:

CERRAR ARCHIVOS DE TEXTO

Es muy importante recordar que debemos cerrar el archivo al terminar de utilizarlo, ya

Al terminar de usar el archivo también debemos recordar que debemos cerrarlo

PROGRAMACION ORIENTADA A OBJETOS 10

La terminología utilizada en estos lenguajes, a veces es la misma, pero hay grandes

C y C++ permiten la declaración y uso de punteros, que pueden ser utilizados en

La intención principal en el uso de los punteros es comunicarse más directamente con

Las referencias se incorporaron a C++ en un intento de manejar punteros de C de

Piénsese en una referencia como si se tratase de la llave electrónica de la habitación

QUE ES UNA LISTA LIGADA

PROGRAMACION ORIENTADA A OBJETOS 12

Algunas consideraciones para utilizar punteros o apuntadores:

Existen dos operadores especiales de punteros: & y *. El operador de dirección (&)

Los punteros apuntan a un tipo de variable, el cual se define en la declaración, por

int *ptr1; /* apunta solo a variables tipo int */

int a; ptr1 = &a;

El valor apuntado por un puntero se obtiene con el operador de indirección *. Si

En conclusión, si ptr contiene la dirección de memoria de la variable p, entonces ptr

De manera general una declaración de un puntero consiste en un tipo base(int, char,

COMO SE CREA UN PUNTERO

Se pueden declarar apuntadores a una estructura:

xxx *ptr3; /* apuntador al tipo de estructura xxx */

int ptr1; / apunta solo a variables tipo int */

xxx ptr3; / apuntador al tipo de estructura xxx */