REPUBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA EDUCACION UNIVERSITARIA

INSTITUTO UNIVERSITARIO POLITECNICO SANTIAGO MARIO
MATURIN MONAGAS

Autor:
____________
_____________

Maturn, Mayo del 2016

ndice

Contenido
Introduccin........................................................................................................ 3
Flujos en Java...................................................................................................... 4
Entrada y salida.................................................................................................. 4
La salida estndar............................................................................................... 4
Salida de datos: System.out............................................................................ 4
Salida de errores: System.err...........................................................................4
La entrada de datos............................................................................................ 5
Creacin en JAVA................................................................................................. 5
Lectura................................................................................................................ 5
Escritura.............................................................................................................. 6
Archivos y directorios en JAVA............................................................................. 6
Serializacin de un Objeto.................................................................................. 9
Interfaz grfica en JAVA....................................................................................... 9
Distribucin de componentes (layouts)...........................................................9
AWT y Swing.................................................................................................... 9
Distribuciones Relativas................................................................................. 10
Conclusin........................................................................................................ 11
Bibliografa........................................................................................................ 12

Introduccin
El flujo de datos podramos suponer que es como un rio. El agua en
movimiento es el flujo, su contenido son los datos. Lo que permite que esos datos
viajen de un origen a un destino es el agua en movimiento, es decir, el flujo. En el
caso de la captura, desde un programa Java, de datos introducidos por un usuario
mediante teclado, el origen es el teclado, el destino, el programa Java y los datos,
lo tecleado por el usuario.

Flujos en Java
Los flujos surgen por la necesidad de las aplicaciones Java de interaccionar
con el exterior, para controlar el intercambio de informacin entre un programa y
los dispositivos de almacenamiento o de comunicacin, Java utiliza la nocin de
(objeto) flujo o stream.

Entrada y salida
La entrada y salida son flujos de datos que actan como canales de
comunicacin permitiendo la interaccin entre un programa y su entorno en el
sistema. En Java podemos tener acceso a estos flujos de datos desde la clase
java.lang.System.

La salida estndar
Est asociado por defecto a la terminal del sistema, es decir que el
resultado de los datos enviados a la salida se observa en pantalla a menos que su
destino sea modificado. Existen dos salidas con diferentes propsitos, una es la
propiamente denominada salida estndar la cual se utiliza para la salida regular de
datos, y la otra es la salida estndar de errores la cual se utiliza para la salida de
errores.

Salida de datos: System.out

La salida estndar de datos para uso normal (abreviada y en ingls: StdOut)
esta representada por un objeto PrintStream llamado out. La clase PrintStream es
una implementacin especial de FilterOutputStream y por lo tanto tambin de la
clase base OutputStream, de modo que mostrar datos en pantalla es tan sencillo
como referirnos a la variable out e invocar el mtodo void println(String x).

Salida de errores: System.err

Esta es otra salida estndar pero con el fin de ser utilizada para errores
(abreviada y en ingls: StdErr). Al igual que StdOut, tambin es representada por
un objetoPrintStream que en este caso se llama err. Los mtodos que podemos
invocar aqu son los mismos vistos anteriormente.
No parece muy til utilizar out y err si su destino es el mismo, o al menos en
el caso de la consola del sistema donde las dos salidas son representadas con el
mismo color y no notamos diferencia alguna. En cambio en la consola de varios
IDEs como NetBeans o Eclipse la salida de err se ve en un color diferente.

La entrada de datos
(Abreviada y en ingls: StdIn) est representada por un objeto InputStream.
La clase InputStream es la clase base en el paquetejava.io para manejar los flujos
entrantes de bytes (8-bit). En la mayora de los casos no queremos leer
directamente en bytes un flujo de datos, sino que esperamos un formato humano.
Aunque en esta ocasin no contaremos desde el principio con mtodos tan
prcticos como void println(String x)

Creacin en JAVA
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.*;).

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

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)

Archivos y directorios en JAVA

Un archivo es un grupo de datos estructurados que son almacenados en
algn medio de almacenamiento y pueden ser usados por las aplicaciones
(programas). La forma en que una computadora organiza, da nombre, almacena y
manipula los archivos se denomina sistema de archivos y suele depender del
Sistema Operativo y del medio de almacenamiento (disco duro, disco externo,
memorias USB, etc)
La caracterstica principal de los archivos es el Nombre y su extensin, El
nombre es la identificacin del archivo y su extensin indica el tipo de archivo al
que corresponde, la extensin generalmente es de tres caracteres, por ejemplo:

Nombre.doc: es que un archivo tipo documento (de Microsoft Word).

Nombre.mp3: es un archivo de msica.
Nombre.xls: es un archivo de hoja de clculo (Microsoft Excel).
Nombre.txt: es un archivo de texto.

La forma de interactuar con los sistemas de archivos locales se realiza a travs de

la clase File, esta clase proporciona muchas utilidades relacionadas con archivos y
con la obtencin de informacin bsica sobre esos archivos.

Crear un directorio con archivo nuevo:

// crear directorio:
try {
File directorio = new File("C:\\Nueva carpeta");
directorio.mkdirs();
new PrintStream(new File(directorio+"\\prueba.txt")).println("Esto es una
prueba de carpeta y archivo nuevo");
} catch(Exception e) {}

Mover archivos de una carpeta a otra:

Funcin FileMove:
public static void fileMove(String sourceFile, String destinationFile) {
System.out.println("Desde: " + sourceFile);
System.out.println("Hacia: " + destinationFile);
try {
File inFile = new File(sourceFile);
File outFile = new File(destinationFile);
FileInputStream in = new FileInputStream(inFile);
FileOutputStream out = new FileOutputStream(outFile);
int c;
while ((c = in.read()) != -1)
out.write(c);
in.close();
out.close();
File file = new File(sourceFile);
if (file.exists()) {
file.delete();
}
} catch (IOException e) {System.err.println("Hubo un error de
entrada/salida!!!");}
}

// Llamar la clase FileMove:

fileMove("C:\\Nueva carpeta1\\imagen1.JPG", "D:\\Nueva
carpeta1\\imagen1.JPG");
Copiar archivos de una carpeta a otra:
Funcin copyFile:
public void copyFile(File s, File t)
{
try{
FileChannel in = (new FileInputStream(s)).getChannel();
FileChannel out = (new FileOutputStream(t)).getChannel();
in.transferTo(0, s.length(), out);
in.close();
out.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
// Llamar la funcin copyFile:
File fIn = new File("C:\\Nueva carpeta1\\Imagen1.JPG");
File fOut = new File("C:\\Nueva carpeta2\\Imagen1.JPG");
copyFile(fIn, fOut);
Estos son los cdigos base de aqu en adelante puedes agregar la clase
chooser para examinar y capturar de manera grfica los archivos con los que
deseas trabajar, Adems recomiendo proteger los bloques de cdigo
con try{, catch{}

Serializacin de un Objeto
En ocasiones necesitamos almacenar el estado de un objeto dentro de un
dispositivo de almacenamiento, pero el manejar el archivo y escribir cada atributo
del objeto es una tarea cansada, pero java tiene una clase que nos ayuda a
guardar el estado del objeto tal y como lo mantenemos en la ejecucin del
programa. Esta clase es conocida como Serializable.
La serializacin de un objeto consiste en obtener una trama de bytes que
represente el estado de un objeto, donde podr ser escrito dentro de un archivo, o

bien, para ser enviado a travs de una red. Una caracterstica importante es que
esto hace posible la persistencia de objetos, es decir, el estado de un objeto se
almacena para su uso posterior.

Interfaz grfica en JAVA

Llamamos Interfaz Grfica GUI (Graphical User Interface) al conjunto de
componentes grficos que posibilitan la interaccin entre el usuario y la aplicacin.
Es decir ventanas, botones, combos, listas, cajas de dilogo, campos de texto, etc.
Primero tenemos que disear la aplicacin, programarla y por ltimo los
eventos que se generan a medida que el usuario interacta con la Interfaz.
Los componentes son objetos de las clases que heredan de la clase
base componente como Button, List, TextField, TextArea, Label, etc.
En una GUI los componentes son contenidos en Contenedores o
containers. Un Containes es un objeto cuya clase hereda de Container(clase que a
su vez es subclase de Component) y tiene la responsabilidad de contener
Componentes.
Generalmente una GUI se monta sobre un Frame. Est sera el Container
principal que contendr a los componentes de la Interfaz Grfica, un Container
podra contener a otros containers.

Distribucin de componentes (layouts)

Los containers contienen componentes y estos son acomodados dentro del
espacio visual del container respetando una cierta distribucin que llamaremos
layout.

AWT y Swing
Java provee dos API's con las que podemos trabajar para desarrollar GUIs,
la ms bsica es AWT (Abstrct Window Toolkit). Las ms desarrolladas se hacen
con Swing, las cuales son ms identificables ya que todas comienzan con "J", por
ejemplo: JButton, JTextField, JTextArea, JPanel y JFrame son clases de Swing.
Todo el manejo de eventos y layouts es exactamente el mismo para AWT y
Swing.

Distribuciones Relativas
Los layouts determinan el criterio con el que se vaan a distribuir los
componentes dentro del container

FlowLayout : Distribuye los componentes uno al lado del otro en la parte

superior del container. Por defecto provee una alineacin centrada, pero tambin
puede alinear a la izquierda o derecha.
BorderLayout: Divide el espacio del container en 5 regiones: NORTH, SOUTH,
EAST, WEST y CENTER, admite un nico componente por regin
GridLayout: Divide el espacio del container en una grilla de n filas por m
columnas, en donde las celdas son de igual tamao
GridBagLayout: Divide el espacio del container en una grilla donde cada
componente puede ocupar varias filas y columnas. Adems permite distribuir el
espacio interno de cada celda.

Conclusin

Con Java existe la posibilidad de crear o disear software y poder ser

ejecutado en diferentes plataformas donde se requiere, sin la necesidad de estar
modificndolo. Adems de esto, es una herramienta diseada con muchos
elementos parecidos a C++ pero en una versin mejorada, ms sencilla de
manejar, con menos complejidad y con barreras de seguridad en su lenguaje y
ejecucin.
JAVA posee un cdigo independiente que es el que permite poderlo usar en
distintas plataformas, sin que cambie la esencia del software diseado, esto quiere
decir que ser el mismo programa en cualquier plataforma. Por ejemplo que
puedes desarrollar un software en un sistema operativo como Windows y despus
ejecutarlo en Linux, sin necesidad de compilar en la otra plataforma. Se dice que
es portable, ya que el cdigo que genera el proceso de compilacin no es
ejecutable, sino que es un cdigo intermedio (bytecodes) el que no est amarrado
a una plataforma especfica, sino que es independiente.

Bibliografa

Cesar Minauro. (07 de Noviembre del 2012). Flujos en Java. https://prezi.com.

[Fecha de consulta 28 de Mayo del 2016].
Disponible en https://prezi.com/sr6cgnwebcks/flujos-en-java/

Ricardo Moya. (08 de Abril del 2015). Lectura y escritura de ficheros en java, con
ejemplos. http://jarroba.com/. [Fecha de consulta 28 de Mayo del 2016].
Disponible en http://jarroba.com/lectura-escritura-ficheros-java-ejemplos/

Rodrigo Asensio. (28 de Mayo del 2010). Como Borrar Directorios En Java.
http://www.rodrigoasensio.com/. [Fecha de consulta 28 de Mayo del 2016]
Disponible en http://www.rodrigoasensio.com/2010/05/como-borrar-directorios-enjava/

Israel Parra. (16 de Febrero del 2016). Manejo de archivos y directorios con
Java. http://escribojava.blogspot.com/. [Fecha de consulta 28 de Mayo del 2016].
Disponible
en
http://escribojava.blogspot.com/2012/02/manejo-de-archivos-ydirectorios-con.html

Michelle Torres. (01 de Septiembre del 2014). Serializable: serializacin de

objetos en java. http://michelletorres.mx/. [Fecha de consulta 28 de Octubre del
2016].
Disponible en http://michelletorres.mx/serializable-serializacion-de-objetos-en-java/