ARCHIVOS

PROGRAMACIÓN ORIENTADA A OBJETOS III
08 DE OCTUBREDE 2017
INGENIERÍA EN DESARROLLO DE SOFTWARE
ARLO ENRIQUESOLÍSVILLA.
MATRICULA:AL10530393
MAESTRO:GILLERMO HERNANDEZ GARCÍA

UNADM ARLO ENRIQUE SOLÍSVILLA 2
Unidad 1 Archivos
Actividad 1. Flujo de Entrada y Salida

Conceptos de flujo de entrada y salida de datos en Java
A continuación se realizó la investigación sobre el flujo de entradas y salidas en lenguaje de Java de
la cual se sustrajo de los tutoriales de ORACLE directamente de los tutoriales de Java, la cual se realizó
una traducción de los diversos conceptos que son bastante extensos y comprender mejor el
funcionamiento del JDK 8, en lo particular sustraje lo más importante, respetando la sintaxis de los
ejemplos de los códigos con la finalidad de compilarlos y correrlos para ver su funcionamiento en el
IDE, y poder comprender mejor su operación.
I/O Streams (Flujos de E / S)
Un flujo de E / S o I/O Streams representa una fuente de entrada o un destino de salida. Un flujo puede representar
muchos tipos diferentes de fuentes y destinos, incluidos archivos de disco, dispositivos, otros programas y arreglos
de memoria.
Los flujos soportan muchos tipos diferentes de datos, incluyendo bytes simples, tipos de datos primitivos, caracteres
localizados y objetos. Algunas corrientes simplemente pasan datos; otros manipulan y transforman los datos de
maneras útiles.
No importa cómo funcionan internamente, todos los flujos presentan el mismo modelo simple a los programas que
los utilizan: Unflujo es una secuenciadedatos. Unprograma utilizaun flujode entrada para leer datos de una fuente,
un elemento a la vez:
Lectura de información en un programa.
Un programa utiliza un flujo de salida para escribir datos en un destino, un elemento a la vez:
Escribir información de un programa.
En esta lección, veremos flujos que pueden manejar todo tipo de datos, desde valores primitivos hasta objetos
avanzados.

La fuente de datos y el destino de los datos mostrados anteriormente pueden ser cualquier cosa que contenga,
genere o consuma datos. Obviamente esto incluye archivos de disco, pero un origen o destino también puede ser
otro programa, un dispositivo periférico, un socket de red o una matriz.
En la siguiente sección, vamos a utilizar el tipo más básico de arroyos, arroyos de bytes, para demostrar las
operaciones comunes deStream I / O. Para la entrada de muestra, utilizaremosel archivo de ejemplo xanadu.txt,
que contiene el siguiente verso:
En Xanadu Kubla Khan
Un decreto majestuoso:
Donde Alph, el río sagrado, corrió
A través de cavernas sin medida para el hombre
Hasta un mar sin sol.
Byte Streams (Secuencias de bytes)
Los programas utilizan byte streams (corrientes de bytes) para realizar entradas y salidas de bytes de 8
bits. Todas las clases de flujo de bytes se descienden de InputStream y OutputStream.
Hay muchas clases de flujo de bytes. Para demostrar cómo funcionan los flujos de bytes, nos centraremos en los
flujos de bytes de E / S del archivo, FileInputStream y FileOutputStream. Otros tipos de corrientes de
bytes se usan de la misma manera; difieren principalmente en la forma en que se construyen.
Using Byte Streams (Utilización de flujos de bytes)
Exploraremos FileInputStreamy FileOutputStreamexaminando un ejemplo de programa
llamado CopyBytes, que utiliza secuencias de bytes para copiar xanadu.txt, un byte a la vez.
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyBytes {
public static void main (String [] args) trhows IOException {
FileInputStream en = nulL;
FileOutputStream out = null;
try {
in = new FileInputStream ("xanadu.txt");
out = new FileOutputStream ("outagain.txt");
int c;
mientras que ((c = in.read ())! = -1) {
out.write (c);
}
} finally {
if (in! = null) {
cercar();
}
if (out! = null) {
out.close ();
}
}
}
}

CopyBytes pasa la mayor parte de su tiempo en un bucle simple que lee el flujo de entrada y escribe el flujo de
salida, un byte a la vez, como se muestra en la siguiente figura.
Entrada y salida simple de la corriente del byte.
Siempre cerrar flujos
Cerrar una corriente cuando ya no es necesario es muy importante - tan importante que CopyBytes utiliza
un finally bloque para garantizarque ambos flujos secerrarán inclusosi seproduceun error. Estaprácticaayuda
a evitar fugas graves de recursos.
Un error posible es que CopyBytes no pueda abrir uno o ambos archivos. Cuando esto sucede, la variable de flujo
correspondiente al archivo nunca cambia de su null valor (nulo). Es por eso CopyBytesque se asegura de
que cada variable de flujo contenga una referencia de objeto antes de invocar close.
Cuándo no usar secuencias de bytes
CopyBytes parece un programa normal, pero en realidad representa un tipo de E / S de bajo nivel que debe
evitar. Dado que xanadu.txt contiene datos de caracteres, el mejor enfoque es utilizar flujos de caracteres ,
como se analiza en la siguiente sección. También hay corrientes para tipos de datos más complicados. Los flujos
de bytes sólo deben utilizarse para las E / S más primitivas.
Entonces, ¿por qué hablar de arroyos de bytes? Debido a que todos los demás tipos de flujo se construyen en los
flujos de bytes.
Character Streams (Corrientes de personajes)
La plataforma Java almacena valores de caracteres utilizando convenciones Unicode. La E / S de flujo de caracteres
convierte automáticamente este formato interno en y desde el conjunto de caracteres local. En localidades
occidentales, el conjunto de caracteres local suele ser un superconjunto de 8 bits de ASCII.

Para la mayoría de las aplicaciones, las E / S con flujos de caracteres no son más complicadas que las E / S con
flujos de bytes. La entrada y la salida realizadas con las clases de flujo se traducen automáticamente desde y hacia
el conjunto de caracteres local. Un programa que utiliza secuencias de caracteres en lugar de streams de bytes se
adapta automáticamente al conjunto de caracteres local y está listo para la internacionalización, todo sin esfuerzo
adicional por parte del programador.
Si la internacionalización no es una prioridad, simplemente puede utilizar las clases de flujo de caracteres sin prestar
mucha atención a los problemas de conjunto de caracteres. Más adelante, si la internacionalización se convierte en
una prioridad, su programa puede adaptarse sin recodificación extensa. Consulte el rastro
de internacionalización para obtener más información.
CHARTER STREAM S THAT USE BYTE STREAM
Utilización de flujos de caracteres
Todas las clases de flujo de caracteres son descendientes de Reader y Writer. Como ocurre con los flujos de
bytes, hay clases de flujo de caracteres que se especializan en I / O de archivos: FileReader
y FileWriter. El CopyCharacters ejemplo ilustra estas clases.
import java.io.FileReader;
import java.io.FileWriter;
public class CopyCharacters {
public static void main (String [] args) lanza IOException {
FileReader inputStream = null;
FileWriter outputStream = null;
try {
inputStream = new FileReader ("xanadu.txt");
outputStream = new FileWriter ("characteroutput.txt");
int c;
while ((c = inputStream.read ())! = -1) {
outputStream.write (c);
}
} finally {
if (inputStream! = null) {
inputStream.close ();
}
if (outputStream! = null) {
outputStream.close ();
}
}
}
}
CopyCharacters es muy similar a CopyBytes. La diferencia más importante es que los CopyCharacters
usos FileReadery FileWriter para la entrada y salida en lugar de FileInputStream
y FileOutputStream. Nótese que tanto CopyBytes y CopyCharacters utilizan una int variable para
leer y escribir a partir de ella. Sin embargo, en CopyCharacters, la int variable contiene un valor de carácter
en sus últimos 16 bits; in CopyBytes, la int variable contiene un byte valor en sus últimos 8 bits.

Corrientes de caracteres que utilizan secuencias de bytes
Los flujos de caracteres suelen ser "envolturas" para los flujos de bytes. El flujo de caracteres utiliza el flujo de
bytes para realizar la E / S física, mientras que el flujo de caracteres maneja la traducción entre caracteres y
bytes. FileReader, por ejemplo, usar FileInputStream, mientras FileWriter usa FileOutputStream.
Existen dos flujos de "puente" de bytes a caracteres de propósito general: InputStreamReader
y OutputStreamWriter. Úselos para crear corrientes de caracteres cuando no hay clases de flujo de
caracteres preempaquetadas que satisfagan sus necesidades. La lección sockets en el rastro de red muestra cómo
crear flujos de caracteres de los flujos de bytes proporcionados por clases de socket.
Line-Oriented I/O (E / S orientada a la línea)
Las E / S de caracteres usualmente ocurren en unidades mayores que caracteres individuales. Una unidad común
es la línea: una cadena de caracteres con un terminador de línea al final. Un terminador de línea puede ser una
secuencia de retorno de carro / avance de línea ( "rn"), un solo retorno de carro ( "r"), o un solo avance de
línea ( "n"). El soporte de todos los terminadores de línea posibles permite a los programas leer archivos de
texto creados en cualquiera de los sistemas operativos más utilizados.
Modifiquemos el CopyCharacters ejemplo para usar la E / S orientada a líneas. Para hacer esto, tenemos que
usar dos clases que no hemos visto antes, BufferedReader y PrintWriter. Exploraremos estas clases con
mayor profundidad en I / O y formato en búfer . En este momento, sólo estamos interesados en su compatibilidad
con las E / S orientadas a líneas.
El CopyLines ejemplo invoca BufferedReader.readLine y realiza PrintWriter.println entradas y
salidas una línea a la vez.
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.PrintWriter;
public class CopyLines {
public static void main (String [] args) throws IOException {
BufferedReader inputStream = null;
PrintWriter outputStream = null;
try {
inputStream = new BufferedReader (new FileReader ("xanadu.txt"));
outputStream = new PrintWriter (new FileWriter
("characteroutput.txt"));
String l;
while ((l = inputStream.readLine ())! = null) {
outputStream.println (l);
}
} finally {
if (inputStream! = null) {
inputStream.close ();
}
if (outputStream! = null) {
outputStream.close ();
}
}
}
}

La invocación readLine devuelve una línea de texto con la línea. CopyLines sale cada línea usando println,
que agrega el terminador de línea para el sistema operativo actual. Esto puede no ser el mismo terminador de línea
que se utilizó en el archivo de entrada.
Buffered Streams (Flujos almacenados en búfer)
La mayoría de los ejemplos que hemos visto hasta ahora usan E / S o I/O en ingles sin buffer . Esto significa que
cada solicitud de lectura o escritura es manejada directamente por el SO subyacente. Esto puede hacer que un
programa sea mucho menos eficiente, ya que cada una de estas solicitudes a menudo activa el acceso al disco, la
actividad de la red o alguna otra operación relativamente costosa.
Para reducir este tipo de sobrecarga, la plataforma Java implementa búferes de E / S. Los flujos de
entrada almacenados en búfer leen datos de un área de memoria conocida como un búfer; la API de la entrada
nativa se llama sólo cuando el búfer está vacío. De forma similar, las secuencias de salida almacenadas en búfer
escriben datos en un búfer y la API de salida nativa se llama sólo cuando el búfer está lleno.
Un programa puede convertir un flujo sin búfer en un flujo almacenado en búfer utilizando el lenguaje de
empaquetado que hemos usado varias veces, donde el objeto de flujo no búfer se pasa al constructor para una clase
de flujo en búfer. A continuación, indicamos cómo puede modificar las invocaciones del constructor en
el CopyCharacters ejemplo para usar la I /O almacenada en búfer:
inputStream = new BufferedReader (new FileReader ("xanadu.txt"));
outputStream = new BufferedWriter (new FileWriter ("characteroutput.txt"));
Hay cuatro clases de flujo almacenadas en búfer usadas para envolver flujos sin buffer: BufferedInputStream
y BufferedOutputStream crear flujos de bytes almacenados en buffer, mientras que BufferedReader
y BufferedWriter crear flujos de caracteres almacenados en búfer.
Flushing Buffered Streams (Flujo de corrientes almacenadas en buffer)
A menudo tiene sentido escribir un buffer en puntos críticos, sin esperar a que se llene. Esto se conoce
como limpiar el búfer.
Algunas clases de salida en buffer admiten autoflush, especificado por un argumento de constructor
opcional. Cuando Autoflush está habilitado, ciertos eventos de clave hacen que el búfer se vacíe. Por ejemplo,
un PrintWriter objeto autoflush descarga el búfer en cada invocación de println or
format. Consulte Formateo para obtener más información sobre estos métodos.
Para vaciar un flujo manualmente, invoque su flush método. El flush método es válido en cualquier flujo de
salida, pero no tiene ningún efecto a menos que el flujo esté almacenado en búfer.
Escaneado y formato
La programación de E / S a menudo implica la traducción de y hacia los datos bien formateados humanos con los
que trabajan. Para ayudarle con estas tareas, la plataforma Java proporciona dos API. La API del escáner rompe la
entrada en fichas individuales asociadas con bits de datos. El API de formato ensambla los datos en formato bien
formateado y legible por el ser humano.

Scanning (Exploración)
Los objetos de tipo Scanner son útiles para descomponer la entrada formateada en fichas y traducir fichas
individuales según su tipo de datos.
BREAKING IMPUT INTO TOKENS Ruptura de entrada en fichas
De forma predeterminada, un escáner utiliza espacio en blanco para separar los tokens. (Los espacios en blanco
incluyen espacios en blanco, tabuladores y finales de línea. La lista completa, consulte la documentación
de Character.isWhitespace.) Para ver cómo funciona la exploración, vamos a ver ScanXan, un programa
que lee las palabras individuales en xanadu.txt y las imprime, uno por cada línea.
import java.io. *;
import java.util.Scanner;
public class ScanXan {
Scanner s = null;
while {
s = new Scanner (new BufferedReader (new FileReader ("xanadu.txt")));
while (s.hasNext ()) {
System.out.println (s.next ());
}
} finally {
if (s! = null) {
s. close();
}
}
}
}
Observe que ScanXan invoca Scanner el close método cuando se hace con el objeto de escáner. Aunque un
escáner no sea un flujo, debe cerrarlo para indicar que ha finalizado con su flujo subyacente.
La salida de se ScanXan ve así:
En
Xanadu
hizo
Kubla
Kan
UN
majestuoso
cúpula de placer
...
Para utilizar un separador de token diferente, invoque useDelimiter(), especificando una expresión
regular. Por ejemplo, suponga que desea que el separador de token sea una coma, opcionalmente seguido de
espacio en blanco. Usted invocaría,
s.useDelimiter (", s *");

TRASLATING INDIVIDUAL TOKENS Traducción de fichas individuales
El ScanXan ejemplo trata todos los tokens de entrada como String valores simples. Soporta tokens para todos
los tipos primitivos del lenguaje Java (excepto para char), así como BigInteger y BigDecimal. Además, los
valores numéricos pueden utilizar separadores de miles. Así, en un US entorno local, Scanner lee correctamente
la cadena "32,767" como representando un valor entero.
Tenemos que mencionar la configuración regional, porque los separadores de miles y los símbolos decimales son
específicos de la zona. Por lo tanto, el ejemplo siguiente no funcionaría correctamente en todas las localidades si no
especificamos que el escáner debe utilizar la US configuración regional. Eso no es algo que usted tiene que
preocuparse generalmente, porque sus datos de entrada vienen generalmente de fuentes que utilizan la misma
configuración local como usted. Pero este ejemplo es parte del Tutorial de Java y se distribuye en todo el mundo.
El ScanSum ejemplo lee una lista de doublé valores dobles y los agrega. Aquí se muestra en el siguiente codigo:
import java.io.BufferedReader;
import java.util.Scanner;
import java.util.Locale;
public class ScanSum {
Scanner s = null;
double sum = 0;
try {
s = new Scanner (new BufferedReader (new FileReader
("usnumbers.txt")));
s.useLocale (Locale.US);
while (s.hasNext ()) {
if (s.hasNextDouble ()) {
sum + = s.nextDouble ();
} else {
s.next ();
}
}
} finlly {
S close();
}
System.out.println (suma);
}
}
Y aquí está el archivo de entrada de la muestra, usnumbers.txt
8.5
32.767
3.14159
1.000.000.1
La cadena de salida es "1032778.74159". El período será un carácter diferente en algunas localidades, ya
que System.out es un PrintStream objeto, y esa clase no proporciona una forma de anular la configuración
regional predeterminada. Podríamos anular la configuración regional para todo el programa, o simplemente usar el
formato.

Formatting (Formateo)
Los objetos de flujo que implementan el formato son instancias de cualquiera PrintWriter, una clase de flujo de
caracteres o PrintStream una clase de flujo de bytes.
Nota: Los únicos objetos PrintStream que problemente necesite son: System.out
y System.err. (Consulte I / O desde la línea de comandos para obtener más información sobre estos objetos).
Cuando necesite crear un flujo de salida formateado, cree una instancia PrintWriter, no PrintStream.
Al igual que todos los bytes y objetos de secuencia de caracteres, las instancias de PrintStream
y PrintWriter implementar un conjunto estándar del método write para el byte simple y salida de
caracteres. Además, ambos PrintStream y PrintWriter implementan el mismo conjunto de métodos para
convertir datos internos en formato de salida. Se proporcionan dos niveles de formato:
 Print y println formato valores individuales de una manera estándar.
 format formatos casi cualquier número de valores basados en una cadena de formato string, con
muchas opciones para el formato preciso.
Los métodos print y println
Invocando print o println emitiendo un valor único después de convertir el valor utilizando el toString
método apropiado . Podemos ver esto en el Root ejemplo:
public class Root {
public static void main (String [] args) {
int i = 2;
double r = Math.sqrt (i);
System.out.print ("La raíz cuadrada de");
System.out.print (i);
System.out.print ("es");
System.out.print (r);
System.out.println (".");
i = 5;
r = Math.sqrt (i);
System.out.println ("La raíz cuadrada de" + i + "es" + r + ".");
}
}
Aquí está la salida de Root:
La raíz cuadrada de 2 es 1.4142135623730951.
Las variables i y r se formatean dos veces: la primera vez que utiliza el código en una sobrecarga de print, la
segunda vez por el código de conversión generado automáticamente por el compilador de Java, que también
utiliza toString. Puede formatear cualquier valor de esta manera, pero no tiene mucho control sobre los
resultados.

El método format
El método format formatea varios argumentos basado en un formato de cadena o String. La cadena de formato
consiste en texto estático incrustado con especificadores de formato; excepto para los especificadores de formato,
la cadena de formato se emite sin cambios.
Las cadenas de formato admiten muchas funciones. En este tutorial, sólo cubriremos algunos conceptos
básicos. Para obtener una descripción completa, consulte format string syntax la especificación de la API.
El Root2 ejemplo formatea dos valores con una sola invocación: format
public class Root2 {
int i = 2;
doble r = Math.sqrt (i);
System.out.format ("La raíz cuadrada de% d es% f.% N", i, r);
}
}
Aquí está la salida:
Al igual que los tres utilizados en este ejemplo, todos los especificadores de formato comienzan con a % y
terminan con una conversión de 1 o 2 caracteres que especifica el tipo de salida formateada generada. Las tres
conversiones utilizadas aquí son:
 d formatea un valor entero como un valor decimal.
 f formatea un valor de punto flotante como un valor decimal.
 n da salida a un terminador de línea específico de la plataforma.
Estas son algunas otras conversiones:
 x formatea un entero como un valor hexadecimal.
 s formatea cualquier valor como una cadena.
 tB formatea un entero como un nombre de mes específico de localidad.
Hay muchas otras conversiones.
Nota:
Excepto para %% y %n, todos los especificadores de formato deben coincidir con un argumento. Si no lo hacen, se
produce una excepción.
En el lenguaje de programación Java, el n escape siempre genera el carácter de avance de línea (u000A). No
lo utilice n a menos que quiera específicamente un carácter de avance de línea. Para obtener el separador de
línea correcto para la plataforma local, utilice %n.
Además de la conversión, un especificador de formato puede contener varios elementos adicionales que
personalizan aún más la salida formateada. He aquí un ejemplo Format, que utiliza todos los tipos posibles de
elementos.

public class Format {
System.out.format ("% f,% 1 $ + 020.10f% n", Math.PI);
}
}
Aquí está la salida:
3.141593, +00000003.1415926536
Los elementos adicionales son todos opcionales. La siguiente figura muestra cómo el especificador más largo se
descompone en elementos.
Elementos de un Especificador de Formato.
Los elementos deben aparecer en el orden mostrado. Trabajando desde la derecha, los elementos opcionales son:
 Precisión . Para valores de coma flotante, esta es la precisión matemática del valor formateado. Para s y
otras conversiones generales, este es el ancho máximo del valor formateado; el valor es truncado a la
derecha si es necesario.
 Ancho . El anchomínimo del valor formateado; el valor serellena si es necesario. Deforma predeterminada,
el valor se rellena con espacios en blanco.
 Los indicadores especifican opciones de formato adicionales. En elejemplo Format, el +indicador
especifica que el número siempre debe formatearse con un signo y el 0indicador especifica que 0es el
carácter de relleno. Otras banderas incluyen -(pad a la derecha) y ,(número de formato con separadores
de miles de locales específicos). Tenga en cuenta que algunos indicadores no se pueden utilizar con ciertos
otros indicadores o con ciertas conversiones.
 El índice de argumentos te permite hacer coincidir explícitamente un argumento designado. También
puede especificar <que coincida con el mismo argumento que el especificador anterior. Así, el ejemplo
podría haber dicho: System.out.format("%f, %<+020.10f %n", Math.PI);
I/O from the command line (E / S desde la línea de comandos)
Un programa a menudo se ejecuta desde la línea de comandos e interactúa con el usuario en el entorno de línea de
comandos. La plataforma Java soporta este tipo de interacción de dos maneras: a través de las corrientes estándar
ya través de la consola.
Flujos estándar
Los flujos estándar son una característica de muchos sistemas operativos. De forma predeterminada, leen la entrada
del teclado y escriben la salida en la pantalla. También admiten E / S en archivos y entre programas, pero esa
característica es controlada por el intérprete de línea de comandos, no por el programa.
La plataforma Java soporta tres flujos estándar de entrada, a la que se accede a través de System.in; Salida
estándar , a la que se accede a través de System.out; y Error Estándar , accesible a través

de System.err. Estos objetos se definen automáticamente y no es necesario abrirlos. La salida estándar y el error
estándar son ambos para la salida; tener salida de error por separado permite al usuario desviar la salida regular a
un archivo y todavía ser capaz de leer mensajes de error. Para obtener más información, consulte la documentación
de su intérprete de línea de comandos.
Puede esperar que los flujos estándar sean corrientes de caracteres, pero, por razones históricas, son corrientes de
bytes. System.out y System.err se definen como PrintStream objetos. Aunque técnicamente es un flujo
de bytes, PrintStream utiliza un objeto de flujo de caracteres interno para emular muchas de las características
de los flujos de caracteres.
Porel contrario, System.ines unflujo de bytes sinfunciones deflujo de caracteres. Parautilizarlaentradaestándar
como una secuencia de caracteres, envuelva System.inen InputStreamReader.
InputStreamReader cin = new InputStreamReader (System.in);
La consola
Una alternativa más avanzada a los flujos estándar es la consola. Este es un objeto único, predefinido de
tipo Console que tiene la mayoría de las características proporcionadas por los Streams estándar, y otros
además. La consola es particularmente útil para la entrada segura de contraseñas. El objeto Consola también
proporciona flujos de entrada y salidaquesoncorrientes de caracteres verdaderos, a través de sus métodos reader
y writer.
Antes de que un programa pueda utilizar la consola, debe intentar recuperar el objeto de consola
invocando System.console(). Si el objeto Consola está disponible, este método lo
devuelve. Si System.console devuelve NULL, las operaciones de consola no están permitidas, ya sea porque el
sistema operativo no las admite o porque el programa se ha iniciado en un entorno no interactivo.
El objeto de consola admite la entrada de contraseña segura a través de su readPassword método. Este método
ayudaa asegurar la entrada de contraseñadedos maneras. Enprimerlugar, suprimeel eco, por lo que la contraseña
no es visible en la pantalla del usuario. En segundo lugar, readPassword devuelve una matriz de caracteres, no
a String, por lo que se puede sobrescribir la contraseña, eliminándola de la memoria tan pronto como ya no sea
necesaria.
El Password ejemplo es un prototipo de programa para cambiar la contraseña de un usuario. Demuestra
varios Console métodos.
import java.io.Console;
import java.util.Arrays;
public class Password {
public static void main (String args []) throws IOException {
Console c = System.console ();
if (c == null) {
System.err.println ("No hay consola.");
System.exit (1);
}
String login = c.readLine ("Ingrese su Usuario:");
char [] oldPassword = c.readPassword ("Introduzca su antigua
contraseña:");
if (verify (login, oldPassword)) {
boolean noMatch;
do{

char [] newPassword1 = c.readPassword ("Introduzca su nueva
contraseña:");
char [] newPassword2 = c.readPassword ("Confirme su nueva
contraseña:");
noMatch =! Arrays.equals (newPassword1, newPassword2);
if (noMatch) {
c.format ("Las contraseñas no coinciden, vuelve a
intentarlo.% n");
} else {
change (login, newPassword1);
c.format ("Contraseña para% s cambiado.% n", inicio de
sesión);
}
Arrays.fill (newPassword1, '');
Arrays.fill (newPassword2, '');
} while (noMatch);
}
Arrays.fill (oldPassword, '');
}
// Método de cambio ficticio.
static boolean verify (String login, char [] password) {
// Este método siempre devuelve
// true en este ejemplo.
// Modificar este método para verificar
// contraseña de acuerdo a sus reglas.
devuelve verdadero;
}
// Método de cambio ficticio.
static void change (String login, char [] password) {
// Modificar este método para cambiar
// contraseña de acuerdo a sus reglas.
}
}
La Password clase sigue estos pasos:
1. Intente recuperar el objeto Consola. Si el objeto no está disponible, abortar.
2. Invoque Console.readLine para pedir y leer el nombre de inicio de sesión del usuario.
3. Invoque Console.readPassword para pedir y leer la contraseña existente del usuario.
4. Invoque verify para confirmar que el usuario está autorizado a cambiar la contraseña. (En este
ejemplo, verify es un método ficticio que siempre devuelve true.)
5. Repita los pasos siguientes hasta que el usuario ingrese la misma contraseña dos veces:
a. Invoque Console.readPassword dos veces para pedir y leer una nueva contraseña.
b. Si el usuario introdujo la misma contraseña ambas veces, invoque change para cambiarla. (Una
vez más, change es un método ficticio.)
c. Sobrescribir ambas contraseñas con espacios en blanco.
6. Sobrescribir la contraseña antigua con espacios en blanco.

Data Streams (Flujos de datos)
Flujos de datos apoyar binario I / O de los valores de tipos de datos primitivos
( boolean, char, byte, short, int, long, float, y double), así como valores de cadena. Todos los flujos de
datos implementan la interfaz DataInput o la interfaz DataOutput . Esta sección se centra en las
implementaciones más ampliamente utilizadas de estas interfaces, DataInputStream y DataOutputStream.
El DataStreams ejemplo demuestra los flujos de datos escribiendo un conjunto de registros de datos y luego
leyéndolos de nuevo. Cada registro consta de tres valores relacionados con un elemento de una factura, como se
muestra en la siguiente tabla:
Orden
en el
registr
o
Tipo de
datos
Descripció
n de los
datos
Método de salida Método de entrada
Valor
de la
muestr
a
1
doubl
e
Precio del
articulo
DataOutputStream.writeDoub
le
DataInputStream.readDoub
le
19.99
2 int
Unidad de
cuenta
DataOutputStream.writeInt DataInputStream.readInt 12
3
Strin
g
Descripció
n del
Artículo
DataOutputStream.writeUTF DataInputStream.readUTF
"Java
T-
Shirt"
Vamos a examinar el código crucial en DataStreams. En primer lugar, el programa define algunas constantes que
contienen el nombre del archivo de datos y los datos que se escribirán en él:
static final String dataFile = "invoceicedata";
static final double [] prices = {19.99, 9,99, 15,99, 3,99, 4,99};
static int final [] unidades = {12, 8, 13, 29, 50};
static final String [] descs = {
"Java T-shirt",
"Java Mug",
"Duke Juggling Dolls",
"Java Pin",
"Java key chain"
};
A continuación, un flujo de salida DataStreams se abre dado a que DataOutputStream sólo se puede
crear como un contenedor para un objeto de flujo de bytes existente, DataStreams proporciona un flujo de bytes
de salida de archivo almacenado en búfer.
out = new DataOutputStream (new BufferedOutputStream (
new FileOutputStream (dataFile)));
DataStreams escribe los registros y cierra el flujo de salida.

for (int i = 0; i <prices.length; i ++) {
out.writeDouble (prices [i]);
out.writeInt (units [i]);
out.writeUTF (descs [i]);
}
El writeUTF método escribe valores String en una forma modificada de UTF-8. Se trata de una codificación de
caracteres de ancho variable que sólo necesita un solo byte para caracteres occidentales comunes.
Ahora DataStreams vuelve a leer los datos. Primero debe proporcionar un flujo de entrada, y variables para
contener los datos de entrada. Al igual que DataOutputStream, DataInputStream debe ser construido
como una envoltura de una corriente de bytes.
in = new DataInputStream (new
BufferedInputStream (new FileInputStream (dataFile)));
doble price;
int unit;
String desc;
double total = 0.0;
Ahora DataStreams puede leer cada registro en el flujo, informando sobre los datos que encuentra.
try {
while(true) {
price = in.readDouble ();
unit = in.readInt ();
desc = in.readUTF ();
System.out.format ("Ordenó% d" + "unidades de% s en $%. 2f% n",
unit, desc, price);
total + = unit * price;
}
} catch (EOFException e) {
}
Observe que DataStreams detecta una condición de fin de archivo detectando EOFException, en lugar de
probar un valor de retorno no válido. Todas las implementaciones de DataInput métodos se utilizan
en EOFException lugar de valores de retorno.
También tenga en cuenta a write que cada uno especializado en DataStreamses exactamente igualado por el
especializado correspondiente read. Corresponde al programador asegurarse de que los tipos de salida y los tipos
de entrada coincidan de esta manera: El flujo de entrada consiste en datos binarios simples, sin nada que indique el
tipo de valores individuales o donde empiezan en el flujo.
DataStreams utiliza una técnica de programación muy mala: utiliza números de coma flotante para representar
valores monetarios. En general, el punto flotante es malo para valores precisos. Es particularmente malo para las
fracciones decimales, porque los valores comunes (como 0.1) no tienen una representación binaria.
El tipo correcto para utilizar para los valores de moneda
es java.math.BigDecimal. Desafortunadamente, BigDecimal es un tipo de objeto, por lo que no funcionará
con los flujos de datos. Sin embargo,BigDecimal trabajara con corrientes de objetos, que están cubiertos en la
siguiente sección.

Object Streams (Flujos de objetos)
Así como los flujos de datos soportan E / S de tipos de datos primitivos, las corrientes de objetos admiten E / S de
objetos. La mayoría de las clases estándar, aunque no todas, admiten la serialización de sus objetos. Aquellos que
implementan la interfaz de marcadores Serializable.
Las clases de flujo de objetos son ObjectInputStream y ObjectOutputStream. Estas clases
implementan ObjectInput y ObjectOutput, que son subinterfaces de DataInput y DataOutput. Esto
significa que todos los métodos primitivos de E / S de datos cubiertos en los flujos de datos también se implementan
en flujos de objetos. Así, una secuencia de objetos puede contener una mezcla de valores primitivos y de
objetos. El ObjectStreams ejemplo lo ilustra. ObjectStreams crea la misma aplicación que DataStreams,
con un par de cambios. En primer lugar, los precios son ahora BigDecimal objetos, para representar mejor los
valores fraccionarios. Ensegundolugar, un Calendar objeto seescribeen el archivo de datos, indicandouna fecha
de factura.
Si readObject()no devuelve el tipo de objeto esperado, intentar transmitirlo al tipo correcto puede arrojar
a ClassNotFoundException. En este ejemplo simple, eso no puede suceder, así que no intentamos captar la
excepción. En su lugar, notificamos al compilador que estamos conscientes del problema
agregándolo ClassNotFoundException a la cláusula Main del método throws.
Salida e introducción de objetos complejos
Los métodos writeObject y readObject sonsimples deusar, pero contienenuna lógicade gestiónde objetos
muy sofisticada. Esto no es importante para una clase como Calendar, que sólo encapsula valores primitivos. Pero
muchos objetos contienen referencias a otros objetos. Si se readObject trata de reconstituir un objeto de una
corriente, tiene que ser capaz de reconstituir todos los objetos a los que se refiere el objeto original. Estos objetos
adicionales pueden tener sus propias referencias, y así sucesivamente. En esta situación, writeObject atraviesa
toda la red de referencias de objetos y escribe todos los objetos de esa web en la secuencia. Por lo tanto, una sola
invocación writeObject puede hacer que un gran número de objetos se escriban en el flujo.
Esto se demuestra en la siguiente figura, donde writeObject se invoca para escribir un único objeto
denominado a . Este objeto contiene referencias a objetos b y c , mientras que b contiene referencias
a d y e . Invocando writeobject(a)escribe no sólo uno , sino todos los objetos necesarios para reconstituir a ,
por lo que los otros cuatro objetos en esta web se escriben también. Cuando a se lee de nuevo readObject, los
otros cuatro objetos se vuelven a leer también y se conservan todas las referencias de objetos originales.
I / O de múltiples objetos referidos
Podría preguntarse qué sucede si dos objetos en la misma secuencia contienen referencias a un único
objeto. ¿Ambos se refieren a un solo objeto cuando son leídos de nuevo? La respuesta es sí." Un flujo sólo puede
contener una copia de un objeto, aunque puede contener cualquier número de referencias a él. Por lo tanto, si

escribes explícitamente un objeto a una secuencia dos veces, realmente estás escribiendo sólo la referencia dos
veces. Por ejemplo, si el código siguiente escribe un objeto ob dos veces en una secuencia:
Object ob = new Object ();
out.writeObject (ob);
out.writeObject (ob);
Cada uno writeObject tiene que ser igualado por un readObject, por lo que el código que lee el flujo de
vuelta se verá algo como esto:
Object ob1 = in.readObject ();
Object ob2 = in.readObject ();
Esto resulta en dos variables, ob1 y ob2, que son referencias a un solo objeto.
Sin embargo, si un solo objeto se escribe en dos flujos diferentes, es efectivamente duplicado - un solo programa
de lectura de ambos arroyos de nuevo verá dos objetos distintos
File I/O (Featuring NIO.2)E / S de archivos (con NIO.2)
Nota: Este tutorial refleja el mecanismo de E / S de archivos introducido en la versión de JDK 7. La versión de Java
SE 6 del tutorial de E / S de archivos fue breve, pero puede descargar la versión de Java SE Tutorial 2008-03-14 del
tutorial que contiene el contenido de E / S de archivos anterior.
El java.nio.file es un paquete relacionado con java.nio.file.attribute que proporcionan un
soporte completo para E / S de archivos y para acceder al sistema de archivos predeterminado. Aunque la API tiene
muchas clases, debe centrarse en sólo unos pocos puntos de entrada. Verá que esta API es muy intuitiva y fácil de
usar.
El tutorial comienza preguntando qué es un path? A continuación, se introduce la clase Path , el punto de entrada
principal del paquete. Se explican los métodos de la clase Path relativos a las operaciones sintácticas . A
continuación, el tutorial pasa a la otra clase primaria del paquete, la clase Files, que contiene métodos que tratan
con las operaciones de archivo. En primer lugar, algunos conceptos comunes a muchas operaciones de archivo se
introducen. El tutorial cubre los métodos para comprobar , eliminar , copiar y mover archivos.
El tutorial muestra cómo los metadatos se gestiona, antes de pasar a presentar las E / S y el directorio de E / S . Se
explican los archivos de acceso aleatorio y se examinan los problemas específicos de
La clase Path
La clase Path, introducida en la versión de Java SE 7, es uno de los puntos de entrada primarios
del java.nio.file paquete. Si su aplicación utiliza E / S de archivos, deseará aprender acerca de las potentes
características de esta clase.

Nota: Si tiene un código pre-JDK7 que usa java.io.File, todavía puede aprovechar la Path funcionalidad de
la clase utilizando el File.toPath método. Consulte Código de E / S de archivos heredados para obtener más
información.
Como su nombre indica, la clase Path es una representación programática de una ruta en el sistema de
archivos. Un objeto Path contiene el nombre de archivo y la lista de directorios utilizados para construir la ruta, y
se utiliza para examinar, localizar y manipular archivos.
Una instancia Path refleja la plataforma subyacente. En el sistema operativo Solaris, a Path utiliza la sintaxis de
Solaris ( /home/joe/foo) y en Microsoft Windows, a Path utiliza la sintaxis de Windows
( C:homejoefoo). A Path no es independiente del sistema. No se puede comparar un Path sistema de
archivos Solaris y esperar que coincida Path con un sistema de archivos de Windows, incluso si la estructura de
directorios es idéntica y ambas instancias localizan el mismo archivo relativo.
Es posible que el archivo o directorio correspondiente al archivo Path no exista. Puede crear una instancia Path
y manipularla de varias maneras: puede anexarla, extraer fragmentos de la misma, compararla con otra ruta. En el
momento adecuado, puede utilizar los métodos de la clase Files para comprobar la existencia del archivo
correspondiente al Path, crear el archivo, abrirlo, eliminarlo, cambiar sus permisos, etc.
Operaciones con Path
La clase Path incluye varios métodos que se pueden utilizar para obtener información sobre la ruta, acceder a
elementos de la ruta, convertir la ruta a otras formas o extraer partes de una ruta. También hay métodos para hacer
coincidir la cadena de ruta de acceso y los métodos para eliminar redundancias en una ruta de acceso. Esta
lección aborda estos métodos Path, a veces llamados operaciones sintácticas, porque operan en la ruta misma y
no acceden al sistema de archivos.
Creating a Path Creación de una ruta de acceso
Una instancia Path contiene la información utilizada para especificar la ubicación de un archivo o directorio. En el
momento en que se define, a Path, se proporciona una serie de uno o más nombres. Puede incluirse un elemento
raíz o un nombre de archivo, pero ninguno es necesario. A Path puede consistir en un solo directorio o nombre de
archivo.
Puede crear fácilmente un Pathobjeto utilizando uno de los getmétodos siguientes de la Pathsclase auxiliar (nota el
plural):
Path p1 = Paths.get("/tmp/foo");
Path p2 = Paths.get(args[0]);
Path p3 = Paths.get(URI.create("file:///Users/joe/FileTest.java"));
El Paths.get método es abreviado para el siguiente código:
Path p4 = FileSystems.getDefault().getPath("/users/sally");
El ejemplo siguiente se crea /u/joe/logs/foo.logasumiendo que su directorio base es /u/joeo C:joelogsfoo.logsi
está en Windows.
Path p5 = Paths.get(System.getProperty("user.home"),"logs", "foo.log");

Recuperación de información sobre un trazado
Puede pensar en Pathcómo almacenar estos elementos de nombre como una secuencia. El elemento más alto de
la estructura de directorios se ubicaría en el índice 0. El elemento más bajo de la estructura de directorios se
ubicaría en el índice [n-1], donde nestá el número de elementos de nombre en el Path. Están disponibles métodos
para recuperar elementos individuales o una subsecuencia del Pathuso de estos índices.
Los ejemplos de esta lección utilizan la siguiente estructura de directorios.
Estructura del directorio de ejemplo
El siguiente fragmento de código define una instancia Path y luego invoca varios métodos para obtener información
sobre la ruta:
// None of these methods requires that the file corresponding
// to the Path exists.
// Microsoft Windows syntax
Path path = Paths.get("C:homejoefoo");
// Solaris syntax
Path path = Paths.get("/home/joe/foo");
System.out.format("toString: %s%n", path.toString());
System.out.format("getFileName: %s%n", path.getFileName());
System.out.format("getName(0): %s%n", path.getName(0));
System.out.format("getNameCount: %d%n", path.getNameCount());
System.out.format("subpath(0,2): %s%n", path.subpath(0,2));
System.out.format("getParent: %s%n", path.getParent());
System.out.format("getRoot: %s%n", path.getRoot());

Esta es la salida para Windows y el sistema operativo Solaris:
Método
invocado
Devuelve en
el sistema
operativo
Solaris
Devuelve en
Microsoft
Windows
Comentario
toString /home/joe/foo C:homejoefoo
Devuelve la representación de cadena de la Path. Si la ruta se creó
utilizando Filesystems.getDefault().getPath(String)o Paths.get(este
último es un método de conveniencia para getPath), el método
realiza una limpieza sintáctica menor. Por ejemplo, en un sistema
operativo UNIX, corregirá la cadena de
entrada//home/joe/fooa /home/joe/foo.
getFileName foo foo
Devuelve el nombre de archivo o el último elemento de la
secuencia de elementos de nombre.
getName(0) home home
Devuelve el elemento path que corresponde al índice
especificado. El elemento 0 es el elemento de trayectoria más
cercano a la raíz.
getNameCount 3 3 Devuelve el número de elementos de la ruta.
subpath(0,2) home/joe homejoe
Devuelve la subsecuencia de Path(no incluyendo un elemento raíz)
según lo especificado por los índices de inicio y fin.
getParent /home/joe homejoe Devuelve la ruta del directorio padre.
getRoot / C: Devuelve la raíz de la ruta.
El ejemplo anterior muestra la salida de una ruta absoluta. En el ejemplo siguiente, se especifica una ruta relativa:
// Solaris syntax
Path path = Paths.get("sally/bar");
or
// Microsoft Windows syntax
Path path = Paths.get("sallybar");
Aquí está la salida para Windows y el sistema operativo Solaris:
Método invocado Devuelve en el sistema operativo Solaris Devuelve en Microsoft Windows
toString sally/bar sallybar
getFileName bar bar
getName(0) sally sally
getNameCount 2 2
subpath(0,1) sally sally
getParent sally sally
getRoot null null
Eliminación de redundancias de una ruta de acceso
Muchos sistemas de archivos utilizan "." notación para denotar el directorio actual y ".." para denotar el directorio
padre. Es posible que tenga una situación en la que a Pathcontiene información de directorio redundante. Tal vez
un servidor esté configurado para guardar sus archivos de " /dir/logs/." registro en el directorio, y desea eliminar
la /.notación de " " trayecto de la ruta.
Los siguientes ejemplos incluyen redundancias:
/home/./joe/foo
/home/sally/../joe/foo

El método normalize elimina cualquier elemento redundante, que incluye cualquier " ." o " directory/.."
ocurrencia. Ambos ejemplos anteriores normalizan a /home/joe/foo.
Es importante tener en cuenta que normalizeno se comprueba en el sistema de archivos cuando se limpia un
camino. Es una operación puramente sintáctica. En el segundo ejemplo, si se sallytrataba de un enlace simbólico,
la eliminación sally/..podría dar lugar a una Pathque ya no localiza el archivo deseado.
Para limpiar una ruta mientras se asegura de que el resultado localiza el archivo correcto, puede utilizar el metodo
toRealPath. Este método se describe en la sección siguiente, Conversión de una ruta .
Converting a Path (Convertirun camino)
Puede utilizar tres métodos para convertir el archivo Path. Si necesita convertir la ruta a una cadena que se puede
abrir desde un navegador, puede utilizar toUri. Por ejemplo:
Path p1 = Paths.get("/home/logfile");
// Result is file:///home/logfile
System.out.format("%s%n", p1.toUri());
El metodo toAbsolutePath convierte una ruta a una ruta absoluta. Si el camino pasado es ya absoluto, devuelve el
mismo Pathobjeto. El metodo toAbsolutePath puede ser muy útil al procesar nombres de archivo introducidos por el
usuario. Por ejemplo:
public class FileTest {
public static void main(String[] args) {
if (args.length < 1) {
System.out.println("usage: FileTest file");
System.exit(-1);
}
// Converts the input string to a Path object.
Path inputPath = Paths.get(args[0]);
// Converts the input Path
// to an absolute path.
// Generally, this means prepending
// the current working
// directory. If this example
// were called like this:
// java FileTest foo
// the getRoot and getParent methods
// would return null
// on the original "inputPath"
// instance. Invoking getRoot and
// getParent on the "fullPath"
// instance returns expected values.
Path fullPath = inputPath.toAbsolutePath();
}
}
// Convierte la ruta de entrada
// a una ruta absoluta.
// Generalmente, esto significa prepender
// el funcionamiento actual

// directorio. Si este ejemplo
// fueron llamadosasí:
// java FileTest foo
// los métodosgetRoot y getParent
// devolverá null
// en el original "inputPath"
// instancia. Invocando getRoot y
// getParent en la ruta "fullPath"
// instance devuelve losvaloresesperados.
Ruta fullPath = inputPath.toAbsolutePath ();
El metodo toAbsolutePath convierte la entrada del usuario y devuelve un valor Path que devuelve valores útiles
cuando se le pregunta. El archivo no necesita existir para que este método funcione.
El metodo toRealPath devuelve la ruta real de un archivo existente. Este método realiza varias operaciones en uno:
 If true pasa a este método y el sistema de archivos admite enlaces simbólicos, este método resuelve
cualquier vínculo simbólico en la ruta.
 If Path es relativo, devuelve una ruta absoluta.
 If Path contiene elementos redundantes, devuelve una ruta con los elementos eliminados.
Este método genera una excepción si el archivo no existe o no se puede acceder. Puede detectar la excepción
cuando desea manejar cualquiera de estos casos. Por ejemplo:
try {
Path fp = path.toRealPath();
} catch (NoSuchFileException x) {
System.err.format("%s: no such" + " file or directory%n", path);
// Logic for case when file doesn't exist.
} catch (IOException x) {
System.err.format("%s%n", x);
// Logic for other sort of file error.
}

Joining Two Paths (Unir dos caminos)
Puede combinar rutas utilizando el método resolve. Se pasa una ruta parcial , que es una ruta que no incluye un
elemento raíz, y esa ruta parcial se añade a la ruta original.
Por ejemplo, considere el fragmento de código siguiente:
// Solaris
Path p1 = Paths.get("/home/joe/foo");
// Result is /home/joe/foo/bar
System.out.format("%s%n", p1.resolve("bar"));
or
// Microsoft Windows
Path p1 = Paths.get("C:homejoefoo");
// Result is C:homejoefoobar
System.out.format("%s%n", p1.resolve("bar"));
Creating a Path Between Two Paths (Creación de una ruta entre dos
rutas)
Un requisito común cuando se escribe código de E / S de archivo es la capacidad de construir una ruta desde una
ubicación en el sistema de archivos a otra ubicación. Puede cumplir esto con el metodo relativize. Este método
construye una ruta que se origina desde la ruta original y termina en la ubicación especificada por la ruta
pasada. La nueva ruta de acceso es relativa a la ruta original.
Por ejemplo, considere dos caminos relativos definidos como joey sally:
Path p1 = Paths.get("joe");
Path p2 = Paths.get("sally");
En ausencia de cualquier otra información, se supone que joey sallyson hermanos, es decir, los nodos que residen
en el mismo nivel en la estructura de árbol. Para navegar desde joehacia sally, se esperaría navegar primero un
nivel hasta el nodo padre y luego bajar a sally:
// Result is ../sally
Path p1_to_p2 = p1.relativize(p2);
// Result is ../joe
Considere un ejemplo un poco más complicado:
Path p1 = Paths.get("home");
Path p3 = Paths.get("home/sally/bar");
// Result is sally/bar
// Result is ../..
En este ejemplo, las dos trayectorias comparten el mismo nodo, home. Para navegar desde homea bar, primero
navega un nivel hacia abajo sally y luego un nivel más abajo a bar. La navegación desde bar hasta home requiere
subir dos niveles. No se puede construir una ruta relativa si sólo una de las rutas incluye un elemento raíz. Si
ambas rutas incluyen un elemento raíz, la capacidad de construir una ruta relativa depende del sistema.
El Copy ejemplo recursivo utiliza los métodos relativize y resolve.

Comparing TwoPaths Comparando dos caminos
La clase Path admite equals, lo que le permite probar dos rutas para la igualdad. Los métodos startsWith y le
endsWith permiten probar si una ruta comienza o termina con una cadena en particular. Estos métodos son fáciles
de usar. Por ejemplo:
Path path = ...;
Path otherPath = ...;
Path beginning = Paths.get("/home");
Path ending = Paths.get("foo");
if (path.equals(otherPath)) {
// equality logic here
} else if (path.startsWith(beginning)) {
// path begins with "/home"
} else if (path.endsWith(ending)) {
// path ends with "foo"
}
La clase Path implementa la interfaz Iterable. El método iterator devuelve un objeto que le permite iterar sobre los
elementos de nombre de la ruta. El primer elemento devuelto es el más cercano a la raíz en el árbol de
directorios. El fragmento de código siguiente itera sobre una ruta de acceso, imprimiendo cada elemento de
nombre:
Path path = ...;
for (Path name: path) {
System.out.println(name);
}
La clase Path también implementa la Comparable interfaz. Puede comparar objetos Path utilizando lo compare
Toque es útil para ordenar.También puede poner objetos Path en un archivo Collection. Para más información
sobre esta potente función, vea el seguimiento de Colecciones .
Cuando desee verificar que dos Pathobjetos busquen el mismo archivo, puede utilizar el metodo isSameFile.
Código de E / S de archivo heredado
Interoperabilidad con código heredado
Antes de la versión de Java SE 7, la clase java.io.File era el mecanismo utilizado para la E / S de archivos,
pero tenía varios inconvenientes.
 Muchos métodos no lanzaron excepciones cuando fallaron, por lo que fue imposible obtener un mensaje
de error útil. Por ejemplo, si falla la eliminación de un archivo, el programa recibirá un "error de
eliminación", pero no sabría si fue porque el archivo no existía, el usuario no tenía permisos o había algún
otro problema.
 El metodo rename no funcionó consistentemente en todas las plataformas.
 No había un apoyo real a los vínculos simbólicos.
 Se deseaba más compatibilidad con metadatos, como permisos de archivo, propietario de archivos y otros
atributos de seguridad.
 El acceso a los metadatos del archivo era ineficiente.
 Muchos del método File no escalaron. Solicitar una lista de directorios grande en un servidor podría
resultar en un bloqueo. Grandes directorios también podrían causar problemas de recursos de memoria, lo
que resulta en una denegación de servicio.
 No fue posible escribir código confiable que pudiera recorrer recursivamente un árbol de archivos y
responder apropiadamente si hubiera enlaces simbólicos circulares.

Tal vez se tiene un código heredado que utiliza java.io.File y le gustaría aprovechar
la java.nio.file.Path funcionalidad con un impacto mínimo en su código.
La java.io.File clase proporciona el toPath método, que convierte una instancia File de estilo antiguo a
una instancia java.nio.file.Path, de la siguiente manera:
Entrada de ruta = file.toPath ();
A continuación, puede aprovechar el rico conjunto de funciones disponibles para la clase Path.
Por ejemplo, suponga que tiene algún código que elimina un archivo:
file.delete ();
Puede modificar este código para utilizar el metodo Files.delete, de la siguiente manera:
Ruta fp = file.toPath ();
Files.delete (fp);
Por el contrario, el Path.toFile método construye un objeto java.io.File para un objeto Path objeto.
Mapeo de la funcionalidad java.io.File en java.nio.file
Debido a que la implementación de Java de E / S de archivos ha sido completamente re-arquitectada en la versión
de Java SE 7, no puede intercambiar un método por otro método. Si desea utilizar la rica funcionalidad que ofrece
el java.nio.file paquete, su solución más fácil es utilizar el File.toPath método sugerido en la sección
anterior. Sin embargo, si no desea usar ese enfoque o no es suficiente para sus necesidades, debe volver a escribir
su código de E / S de archivo.
No existe una correspondencia de uno a uno entre las dos API, pero la siguiente tabla le ofrece una idea general de
la funcionalidad de la java.io.File API en la java.nio.file API y le indica dónde puede obtener más
información.
Funcionalidad de java.io.File java.nio.file Funcionalidad Cobertura de Tutorial
java.io.File java.nio.file.Path La clase Path
java.io.RandomAccessFile La SeekableByteChannelfuncio
nalidad.
Archivos de acceso aleatorio
File.canRead, canWrite,
canExecute
Files.isReadable,, Files.is
Writabley Files.isExecutab
le.
En los sistemas de archivos
UNIX, se utilizael paqueteGestión
de metadatos(archivosyatributos
de almacén de archivos) para
comprobarlos nueve permisos de
archivo.
Comprobación de un archivo o
directorio
Administración de metadatos
File.isDirectory(),, File.
isFile()yFile.length()
Files.isDirectory(Path,
LinkOption...),, Files.isRe
gularFile(Path,
Gestión de metadatos

LinkOption...)yFiles.size(
Path)
File.lastModified() y File
.setLastModified(long)
Files.getLastModifiedTime
(Path,
LinkOption...) yFiles.setL
astMOdifiedTime(Path,
FileTime)
Los Filemétodos que
establecen diversos
atributos:setExecutable, set
Readable, setReadOnly,setW
ritable
Estos métodos son reemplazados
por
el Filesmétodo setAttribute
(Path, String, Object,
LinkOption...).
new File(parent,
"newfile")
parent.resolve("newfile") Operaciones de ruta
File.renameTo Files.move Mover un archivo o directorio
File.delete Files.delete Eliminación de un archivo o
directorio
File.createNewFile Files.createFile Creación de archivos
File.deleteOnExit Reemplazada por
la DELETE_ON_CLOSEopción
especificada en
el createFilemétodo.
Creación de archivos
File.createTempFile Files.createTempFile(Path
, String,
FileAttributes<?>),Files.c
reateTempFile(Path,
String, String,
FileAttributes<?>)
Creación de archivos
Creacióny escriturade unarchivo
mediante I / O de flujo
Lectura y escritura de archivos
mediante E / S de canal
File.exists Files.exists y Files.notExi
sts
Verificaciónde laexistenciade un
archivo o directorio
File.compareTo y equals Path.compareTo y equals Comparando dos caminos
File.getAbsolutePath y get
AbsoluteFile
Path.toAbsolutePath Convertir un camino
File.getCanonicalPath y ge
tCanonicalFile
Path.toRealPath o normalize Convertir una ruta de acceso
( toRealPath)
Eliminar redundancias de una
ruta de acceso ( normalize)
File.toURI Path.toURI Convertir un camino
File.isHidden Files.isHidden Recuperación de información
sobre el camino

File.list y listFiles Path.newDirectoryStream Listado de contenidos de un
directorio
File.mkdir y mkdirs Path.createDirectory Creación de un directorio
File.listRoots FileSystem.getRootDirecto
ries
Listado de los directorios raíz de
un sistema de archivos
File.getTotalSpace,File.g
etFreeSpace,File.getUsabl
eSpace
FileStore.getTotalSpace, Fi
leStore.getUnallocatedSpa
ce,FileStore.getUsableSpac
e,FileStore.getTotalSpace
Atributosdel almacénde archivos
Fuente consultada
https://docs.oracle.com/javase/tutorial/essential/io/index.html

ARCHIVOS

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a ARCHIVOS

Similar a ARCHIVOS (20)

Más de ARLO SOLIS

Más de ARLO SOLIS (6)

Último

Último (6)

ARCHIVOS