Arreglo

Un arreglo es una secuencia de datos primitivos o de objetos, todos del

mismo tipo, unidos bajo un identificador comn.

Unidimensionales (Vectores)
Tambin llamado vector, almacena datos indicando un ndice.

Ejm: nm.[i]

Bidimensionales (Matrices)

Almacena datos en forma de una matriz. Para acceder a cada posicin de

un elemento dentro de un arreglo hay que indicar 2 ndices.
Ejm: m[i][j].

Multidimensionales:

Son arreglos que tienen ms de dos dimensiones. Por cada dimensin del
arreglo se tiene que utilizar un ndice para ubicar exactamente a un
elemento en particular.
Todos los datos fluyen a travs del ordenador desde una entrada
hacia una salida. Este flujo de datos se denomina tambin stream. Hay un
flujo de entrada (input stream) que manda los datos desde el exterior
(normalmente el teclado) del ordenador, y un flujo de salida (output stream)
que dirige los datos hacia los dispositivos de salida (la pantalla o un
archivo).

El Proceso Datos Consta De Tres Pasos

Abrir el flujo de datos

Mientras exista ms informacin (leer o escribir ) los datos
Cerrar el flujo de datos

Las Jerarquas De Clases

En el lenguaje Java los flujos de datos se describen mediante clases
que forman jerarquas segn sea el tipo de dato char Unicode de 16 bits o
byte de 8 bits. A su vez, las clases se agrupan en jerarquas segn sea su
funcin de lectura o de escritura.
La caracterstica de internacionalizacin del lenguaje Java es la razn
por la que existe una jerarqua separada de clases para la lectura y escritura
de caracteres.
Todas estas clases se encuentran en el paquete java.io, por lo que al
principio del cdigo fuente tendremos que escribir la sentencia
Import java.io.*;
Char Unicode, 16 bits
Reader y Writer son las clases bases de la jerarqua para los flujos de
caracteres. Para leer o escribir datos binarios tales como imgenes o
sonidos, se emplea otra jerarqua de clases cuyas clases base son
InputStream y OutputStream.
Lectura
Las clases Reader e InputStream son similares aunque se refieren a
distintos tipos de datos, lo mismo ocurre con Writer y OutputSream.
Por ejemplo, Reader proporciona tres mtodos para leer un carcter char o
un array de caracteres
int read()
int read(char buf[])
int read(char buf[], int offset, int len)
InputStream proporciona mtodos similares para leer un byte o un array de
bytes.
Lectura De Un Fichero De Texto En Java
Podemos abrir un fichero de texto para leer usando la clase FileReader. Esta
clase tiene mtodos que nos permiten leer caracteres. Sin embargo, suele
ser habitual querer las lneas completas, bien porque nos interesa la lnea

completa,

bien

para

ella. FileReader no

poder

contiene

analizarla
mtodos

luego

que

nos

extraer
permitan

campos
leer

de

lneas

completas, pero s BufferedReader. Afortunadamente, podemos construir

un BufferedReader a partir del FileReader de la siguiente forma:

1
2
3
4
5

File archivo = new File ("C:\\archivo.txt");

FileReader fr = new FileReader (archivo);
BufferedReader br = new BufferedReader(fr);
...
String linea = br.readLine();

La apertura del fichero y su posterior lectura pueden lanzar

excepciones que debemos capturar. Por ello, la apertura del fichero y la
lectura debe meterse en un bloque try-catch.
Adems, el fichero hay que cerrarlo cuando terminemos con l, tanto
si todo ha ido bien como si ha habido algn error en la lectura despus de
haberlo abierto. Por ello, se suele poner al try-catch un bloque finally y
dentro de l, el close() del fichero.
El siguiente es un cdigo completo con todo lo mencionado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.io.*;
class LeeFichero
{
public static void main(String [] arg)
{
File archivo = null;
FileReader fr = null;
BufferedReader br = null;
try
{

// Apertura del fichero y creacion de BufferedReader para poder

// hacer una lectura comoda (disponer del metodo readLine()).
archivo = new File ("C:\\archivo.txt");
fr = new FileReader (archivo);
br = new BufferedReader(fr);
// Lectura del fichero
String linea;
while((linea=br.readLine())!=null)
System.out.println(linea);
}
catch(Exception e)

e.printStackTrace();
}finally{
// En el finally cerramos el fichero, para asegurarnos
// que se cierra tanto si todo va bien como si salta

25
26
27
28
29
30
31
32
33
34
35
36

// una excepcion.
try{
if( null != fr )

fr.close();
}
}catch (Exception e2)

}
}

e2.printStackTrace();

Como opcin para leer un fichero de texto lnea por lnea, podra
usarse la clase Scanner en vez del FileReader y el BufferedReader.

int read()
int read(byte buf[])
int read(byte buf[], int offset, int len)
La primera versin lee un byte como entero del flujo de entrada,
devuelve 1 si no hay ms datos que leer. La segunda versin, lee un array
de bytes devolviendo el nmero de bytes ledos. La tercera versin, lee
tambin, un array de bytes, pero nos permite especificar, la posicin de
comienzo del array en la que se empiezan a guardar los bytes, y el mximo
nmero de bytes que se van a leer.
Dichas clases definen otras funciones miembro que no estudiaremos
de momento.
Escritura
La clase Writer proporciona tres mtodos para escribir un carcter
char o un array de caracteres
int write(int c)
int write(char buf[])
int write(char buf[], int offset, int len)
La clase OutputStream proporciona mtodos similares

int write(int c)

int write(byte buf[])

int write(byte buf[], int offset, int len)

El siguiente cdigo escribe un fichero de texto desde cero. Pone en l 10

lneas

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import java.io.*;
public class EscribeFichero
{
public static void main(String[] args)
{
FileWriter fichero = null;
PrintWriter pw = null;
try
{
fichero = new FileWriter("c:/prueba.txt");
pw = new PrintWriter(fichero);
for (int i = 0; i < 10; i++)
pw.println("Linea " + i);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// Nuevamente aprovechamos el finally para
// asegurarnos que se cierra el fichero.
if (null != fichero)
fichero.close();
} catch (Exception e2)

}
}

e2.printStackTrace();

Si queremos aadir al final de un fichero ya existente, simplemente

debemos poner un flag a true como segundo parmetro del constructor
de FileWriter.

Clase File

Se usa para obtener informacin sobre archivos y directorios.

Adems la clase File permite crear y eliminar archivos y directorios.

Un objeto de la clase Java File representa un archivo o directorio.

CONSTRUCTORES
La clase proporciona los siguientes constructores para crear objetos
File:

public File(String nombreFichero|path);

public File(String path, String nombreFichero|path);
public File(File path, String nombreFichero|path);
La ruta o path puede ser absoluta o relativa.

Clase Buffer
java.lang.Object
java.nio.Buffer
extends Object
A container for data of a specific primitive type.

A buffer is a linear, finite sequence of elements of a specific primitive

type. Aside from its content, the essential properties of a buffer are its

capacity, limit, and position:

A buffer's capacity is the number of elements it contains. The

capacity of a buffer is never negative and never changes.

A buffer's limit is the index of the first element that should not be
read or written. A buffer's limit is never negative and is never greater

than its capacity.

A buffer's position is the index of the next element to be read or
written. A buffer's position is never negative and is never greater than
its limit.

There is one subclass of this class for each non-boolean primitive type.
Clase Vector
Los arrays en Java son suficientes para guardar tipos bsicos de
datos, y objetos de una determinada clase cuyo nmero conocemos de
antemano. Algunas veces deseamos guardar objetos en un array pero no

sabemos cuntos objetos vamos a guardar. Una solucin es la de crear un

array cuya dimensin sea ms grande que el nmero de elementos que
necesitamos guardar. La clase Vector nos proporciona una solucin
alternativa a este problema. Un vector es similar a un array, la diferencia
estriba en que un vector crece automticamente cuando alcanza la
dimensin inicial mxima. Adems, proporciona mtodos adicionales para
aadir, eliminar elementos, e insertar elementos entre otros dos existentes.
Para usar la clase Vector hemos de poner al principo del archivo del
cdigo fuente la siguiente sentencia import
import java.util.*;
Cuando creamos un vector u objeto de la clase Vector, podemos especificar
su dimensin inicial, y cuanto crecer si rebasamos dicha dimensin.
Vector vector=new Vector (20, 5);
Tenemos un vector con una dimensin inicial de 20 elementos. Si
rebasamos dicha dimensin y guardamos 21 elementos la dimensin del
vector crece a 25.
Al segundo constructor, solamente se le pasa la dimensin inicial.
Vector vector=new Vector (20);
Si se rebasa la dimensin inicial guardando 21 elementos, la
dimensin del vector se duplica. El programador ha de tener cuidado con
este constructor, ya que si se pretende guardar un nmero grande de
elementos se tiene que especificar el incremento de la capacidad del vector,
si no se quiere desperdiciar intilmente la memoria el ordenador.
Con el tercer constructor, se crea un vector cuya dimensin inicial es 10.
Vector vector=new Vector ();
La dimensin del vector se duplica si se rebasa la dimensin inicial,
por ejemplo, cuando se pretende guardar once elementos.