breve java / S de archivos

A, clase File

java.io.FileClase se presenta un extracto nombres de archivo y la ruta de directorio indican, que se utiliza principalmente para crear archivos y directorios, encontrar y eliminar archivos.

1.1 Constructor

public File(String pathname); // 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
public File(String parent, String child); // 从父路径名字符串和子路径名字符串创建新的 File实例。
public File(File parent, String child); // 从父抽象路径名和子路径名字符串创建新的 File实例。

1,2 método común

/// API
// 获取功能
public String getAbsolutePath(); // 返回此File的绝对路径名字符串。
public String getPath(); // 将此File转换为路径名字符串。
public String getName(); // 返回由此File表示的文件或目录的名称。
public long length(); // 返回由此File表示的文件的长度。若File对象表示目录，则返回值未指定。
// 判断功能
public boolean exists(); // 此File表示的文件或目录是否实际存在。
public boolean isDirectory(); // 此File表示的是否为目录。
public boolean isFile(); // 此File表示的是否为文件。
// 创建删除功能
public boolean createNewFile();  // 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
public boolean delete(); // 删除由此File表示的文件或目录。
public boolean mkdir(); // 创建由此File表示的目录。
public boolean mkdirs(); // 创建由此File表示的目录，包括任何必需但不存在的父目录
// 目录的遍历
public String[] list(); // 返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles(); // 返回一个File数组，表示该File目录中的所有的子文件或目录。

1.3 Ejemplos

• Imprimir múltiples niveles de directorio recursivo

public static void printDir(File dir) {
    // 获取子文件和目录
    File[] files = dir.listFiles();
    // 循环打印
    for (File file : files) {
        // 判断
        if (file.isFile()) {
            // 是文件,输出文件绝对路径
            // if (file.getName().endsWith(".java")) // 筛选后缀是 .java 的文件
            System.out.println("文件名:" + file.getAbsolutePath());
        } else {
            // 是目录,输出目录绝对路径
            System.out.println("目录:" + file.getAbsolutePath());
            // 继续遍历,调用printDir,形成递归
            printDir(file);
        }
    }
}

• Usar filtros de archivos java.io.FileFilterde interfaz de archivo de filtro:

public static void printDir2(File dir) {
    // Lambda表达式优化
    // File[] files = dir.listFiles(f -> f.getName().endsWith(".java") || f.isDirectory());
    File[] files = dir.listFiles(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
            return pathname.getName().endsWith(".java") || pathname.isDirectory();
        }
    });
    // 循环打印
    for (File file : files) {
        // 判断
        if (file.isFile()) {
            System.out.println("文件名:" + file.getAbsolutePath());
        } else {
            printDir2(file);
        }
    }
}

java clases de manejo de archivos nueva 7 introduce varias utiliza en lugar de la operación de archivo del archivo de clase de E / S: la serie de Java NIO de tutoriales

import java.nio.file.DirectoryStream;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;

En segundo lugar, la E / S básica: flujo de bytes, un flujo de caracteres

padre superior de E / S que se

	flujo de entrada	flujo de salida
flujo de bytes	Flujo de entrada	Flujo de salida
flujo de caracteres	Lector	Escritor

flujo de 2.1 bytes

Todos los datos de archivos (texto, imágenes, vídeo, etc.) durante el almacenamiento, se almacenan en forma de dígitos binarios son un un byte. Por lo tanto, cualquier archivo puede ser transmitido byte de datos de flujo.

2.1.1 bytes OutputStream flujo de salida

java.io.OutputStreamUna clase abstracta es una corriente de salida de bytes superclase de todo, la información de bytes escritos en el destino especificado. Se define el flujo de salida método funcionalidad básica común de bytes.

public void close();
public void flush();
public void write(byte[] b);
public void write(byte[] b, int off, int len);
public abstract void write(int b);

2.1.2 FileOutputStream 类

java.io.FileOutputStreamflujo de salida de archivo de clase para escribir datos en un archivo.

public FileOutputStream(File file);
public FileOutputStream(String name);

1. Byte Comentario: métodos de escritura;
2. Cada vez que el programa se ejecuta, crea un objeto flujo de salida, la información se eliminará en el archivo de destino. Los constructores también pueden pasar un boolean appendparámetro que indica adicionales de escritura.
3. envoltura de escritura:fos.write("\r\n".getBytes());

2.1.3 flujo de entrada de bytes InputStream

java.io.InputStreamUna clase abstracta es una superclase de todo el flujo de entrada de bytes, el byte de información se puede leer en la memoria. Define el método básico funcionalidad común de flujo de entrada de bytes.

public void close();
public abstract int read();
public int read(byte[] b);

2.1.4 clase FileInputStream

java.io.FileInputStreamflujo de entrada archivo de clase de bytes leídos desde el archivo.

FileInputStream(File file);
FileInputStream(String name);

1. bytes de lectura: método de lectura, cada vez que un byte de datos se puede leer, ascendido a tipo int, el final del archivo se lee, devuelve -1;
2. Leer matrices de bytes: Cuando se lee (byte [] b), b es la longitud de cada byte de lectura a la matriz, devuelven el número de bytes válidos leer, leer a la final, devuelve -1.

flujo de 2,2 caracteres

Algunos personajes como los caracteres chinos pueden ocupar varios bytes de almacenamiento. Así Java para proporcionar algunas clases de flujo de caracteres para leer y escribir datos en unidades de caracteres, diseñado para archivos de texto mango.

2.2.1 carácter flujo de salida escritor

java.io.WriterUna clase abstracta es una superclase de todas las clases utilizadas para escribir una secuencia de caracteres.

void write(int c);
void write(char[] cbuf);
abstract void write(char[] cbuf, int off, int len);
void write(String str);
void write(String str, int off, int len);
void flush();
void close();

2.2.2 clase FileWriter

java.io.FileWriterClase es escribir caracteres en el fichero de la clase de conveniencia. La codificación de caracteres por defecto del sistema y la memoria intermedia de bytes por defecto está configurado.

FileWriter(File file);
FileWriter(String fileName);

1. caracteres escritos: método de escritura;
2. ras: vaciar el búfer;
3. Cerrar: primero vaciar el búfer, entonces el sistema de notificación para liberar recursos.

flujo de caracteres, sólo se puede manipular archivos de texto, imágenes no se puede utilizar archivos que no son de texto, vídeos, etcétera. Otro flujo de caracteres usando un flujo de bytes cuando simplemente leer o escribir en un archivo de texto

2.2.3 Lector de carácter flujo de entrada

java.io.ReaderUna clase abstracta se utiliza para leer streams de caracteres superclase de todas las clases.

public void close();
public int read();
public int read(char[] cbuf);

2.2.4 clase FileReader

java.io.FileReaderClase es una clase de conveniencia lectura de archivos de carácter. La codificación de caracteres por defecto del sistema y la memoria intermedia de bytes por defecto está configurado.

FileReader(File file);  
FileReader(String fileName);

1. Lee caracteres: método read (), se pueden leer datos cada vez que un personaje, para mejorar tipo int, al final del archivo se lee, devuelve -1;
2. Leer usando matriz de caracteres: leer (char [] cbuf) , la longitud de cada carácter b se lee en una matriz y devuelve el número de caracteres válidos para leer,
   leer a la final, devuelve -1.

Cuando se crea un objeto de flujo de entrada de archivo, si no el archivo, tiros FileNotFoundException, cuando se crea un objeto de flujo de salida de archivo, si no el archivo se crea automáticamente.

try-con-recursos

En tercer lugar, el búfer de la secuencia, conmutaciones, arroyos serializados imprimir corrientes

Fluya 3.1 búfer

corriente tamponada, también conocido como flujo alto, es de cuatro básica FileXxxflujo de mejora, la corriente es 4, según la clasificación de tipo de datos.

• flujo de bytes BufferedInputStreambúfer: ,BufferedOutputStream
• Carácter buffer de BufferedReaderflujo: ,BufferedWriter

El principio básico del búfer de la secuencia, es cuando se crea un objeto de secuencia, crea un sistema incorporado en la matriz del separador tamaño predeterminado del búfer mediante la lectura y la escritura, para reducir el número de sistema IO, para mejorar la eficiencia de la lectura y la escritura.

búfer de la secuencia de bytes 3.1.1

constructor:

public BufferedInputStream(InputStream in); // 创建一个新的缓冲输入流。
public BufferedOutputStream(OutputStream out); // 创建一个新的缓冲输出流。

flujo de bytes tampón de lectura y el método básico es el mismo flujo.

3.1.2 flujo de búfer carácter

constructor

public BufferedReader(Reader in); // 创建一个新的缓冲输入流。
public BufferedWriter(Writer out); // 创建一个新的缓冲输出流。

El método básico es consistente con el flujo de caracteres buffer de carácter ordinario se llama flujo. método único:

/// BufferedReader：
public String readLine(); // 读一行文字
/// BufferedWriter：
public void newLine(); // 写一行行分隔符,由系统属性定义符号

3.2 conmutaciones

3.2.1 InputStreamReader 类

Conmutaciones java.io.InputStreamReader, es una subclase del lector, el puente está fluyendo desde el flujo de bytes de caracteres. Se lee bytes utilizando el juego de caracteres especificado y lo decodifica en un personaje. Cuyo conjunto de caracteres puede especificarse por su nombre, o acepte el conjunto de caracteres por defecto de la plataforma.

InputStreamReader(InputStream in); // 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName); // 创建一个指定字符集的字符流

3.2.1 OutputStreamWriter 类

Conmutaciones java.io.OutputStreamWriter, es una subclase de escritor, el puente es el flujo de bytes que fluye del carácter. Utilizando el conjunto de caracteres codificación de bytes especificado. Cuyo conjunto de caracteres puede especificarse por su nombre, o acepte el conjunto de caracteres por defecto de la plataforma.

OutputStreamWriter(OutputStream in); // 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName); // 创建一个指定字符集的字符流。

3.3 serialización

Java proporciona un mecanismo de serialización de objetos. Un objeto puede ser representado por una secuencia de bytes, el byte que contiene la secuencia 对象的数据, 对象的类型y 对象中存储的属性otra información. Después de una secuencia de bytes escribe en el archivo, el archivo correspondiente a la información almacenada en un objeto persistente.

Por el contrario, la secuencia de bytes también se puede leer desde una copia de archivos, reorganizado, se deserialized. 对象的数据, 对象的类型Y la 对象中存储的属性información se puede utilizar para crear objetos en memoria.

3.3.1 ObjectOutputStream 类

java.io.ObjectOutputStreamClase, el tipo de datos primitivos de objetos Java escribe en un archivo, objeto de almacenamiento duradero.
constructor:

public ObjectOutputStream(OutputStream out); // 创建一个指定OutputStream的ObjectOutputStream

/// 示例：
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

1. Para serializar un objeto, dos condiciones se deben cumplir

• La clase debe implementar java.io.Serializablela interfaz, Serializable es una interfaz de marcador, la clase no implementa esta interfaz no hace ninguna serialización estado o deserialización lanza NotSerializableException.
• Todas las propiedades de la clase deben ser serializables. Si una propiedad no tiene que ser serializado, entonces la propiedad debe estar marcado transitoria, utilizando las transientmodificaciones de palabras clave

2. métodos de escritura de objetos

public final void writeObject (Object obj); // 将指定的对象写出

3.3.2 clase ObjectInputStream

java.io.ObjectInputStreamDeserializar la corriente, antes del uso de la secuencia de datos original ObjectOutputStream restaurar objetos.

constructor:

public ObjectInputStream(InputStream in); // 创建一个指定InputStream的ObjectInputStream。

Si usted puede encontrar un objeto de archivo de clase, podemos deserializar operación, ObjectInputStream a leer método de objeto llamada:

public final Object readObject (); // 读取一个对象

Para la JVM puede deserializar objeto, debe ser capaz de encontrar los archivos de clase de la clase. Si no puede encontrar este tipo de archivo de clase, a continuación, lanzar una ClassNotFoundExceptionexcepción.

Además, cuando la JVM deserializar objetos para encontrar los archivos de clase, pero los archivos de clase han cambiado después de un objeto serializado, entonces la operación se producirá un error de deserialización, lanzar una InvalidClassExceptionexcepción. Esta excepción se produce por las siguientes razones:

• Tal número de versión de serie del número de versión del descriptor de la clase que lea de la corriente no coincide
• Esta clase contiene el tipo de datos desconocido
• No Parámetros tales construcciones no son método accesible

SerializableInterfaz para requerir clase de serialización que proporciona un número de versión de serie. serialVersionUIDEl número de versión objeto de verificar que la secuencia de la versión de la clase objetivo y el partido correspondiente. Ejemplo:

public class Employee implements java.io.Serializable {
    // 加入序列版本号
    private static final long serialVersionUID = 1L;
    public String name;
    public String address;
    // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值
    public int eid;
    
    public void addressCheck() {
        System.out.println("Address check : " + name + " ‐‐ " + address);
    }
}

3.4 flujos de impresión

Por lo general, la salida impresa en la consola, y el método es llamar al método de impresión println completado, los dos métodos se derivan de java.io.PrintStreamla clase que se puede imprimir fácilmente el valor de varios tipos de datos, es una salida conveniente.

3.4.1 clase PrintStream

constructor:

public PrintStream(String fileName); // 使用指定的文件名创建一个新的打印流。

• System.out es un tipo PrintStream, pero son los requisitos de flujo del sistema, la impresión en la consola.
  Podemos cambiar fluye:

public class PrintDemo {
    public static void main(String[] args) throws IOException {
        // 调用系统的打印流,控制台直接输出97
        System.out.println(97);
        // 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
        // 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
        // 调用系统的打印流, ps.txt中输出97
        System.out.println(97);
    }
}

---

Además, el blog sumar dos más completa:

Jane libro: leer esto, Java IO no es difícil de

CSDN: Java8 la fuente de E / S - una configuración global