Prefacio
A partir de este artículo, comenzaremos a aprender el sistema Java IO, que esencialmente está leyendo y escribiendo archivos. Suena simple, pero no es fácil. El sistema IO de Java ha estado mejorando y mejorando, y ha diseñado una gran cantidad de clases. Solo al comprender el significado de estos tipos que se están diseñando y sus respectivos escenarios de aplicación podemos mejorar la comprensión del archivo IO.
Entonces, el primer paso es resolver el problema de cómo representar un archivo. En el mundo de Java, "todo es un objeto", y cómo corresponder a un archivo o directorio de disco real a un objeto Java es nuestro problema principal.
El archivo se usa en Java para abstraer un archivo, ya sea un archivo normal o un directorio, puede corresponder a un objeto de archivo. Creo que todos deben ser precisos para posicionar el tipo de archivo: simplemente representa abstractamente un archivo o directorio en el disco, y en realidad se basa en una clase de sistema de archivos local independiente de la plataforma, y el archivo no puede realizar ninguna operación de lectura y escritura en el contenido del archivo que representa (es decir, lo que hace la secuencia).
Construir una instancia de archivo
Antes de presentar el método del constructor de instancia de archivo, debemos echar un vistazo a sus varios miembros importantes de atributos.
Sistema de archivos final estático privado fs = defaultFilesystem.getFilesystem ();
Este es el miembro más central de la clase de archivo, que se representa como la API del sistema de archivos del sistema actual. Todas las operaciones emitidas al disco se basan en esta propiedad.
ruta de cadena final privada;
La ruta representa el nombre de ruta completo de la instancia actual. Si la instancia del archivo actual representa un directorio, entonces el valor de la ruta es el nombre completo del directorio. Si representa un archivo puro, entonces el valor de esta ruta es igual a la ruta completa del archivo + el nombre del archivo.
Public static final Char separatorchar = fs.getseparator (); Public Static Final Char PathseParatorChar = fs.getPathSeParator ();
SeparatorChar representa el separador entre directorios, y PathSeParatorChar representa el separador en diferentes rutas. Estos dos valores son diferentes en diferentes plataformas de sistema. Por ejemplo, los valores de estas dos bajo ventanas son: "" y ";", donde la prohibición se usa para separar múltiples rutas diferentes.
La clase de archivo proporciona cuatro constructores diferentes para instancias de un objeto de archivo, pero solo tres se usan más comúnmente. También nos centramos en aprender los primeros tres constructores.
Archivo público (String PathName)
Esta es la forma más común de instanciar un objeto de archivo. El valor de PathName puede ser un directorio o un nombre de archivo simple. Por ejemplo:
Archivo archivo = nuevo archivo ("c: // users // yanga // escritorio"); archivo file1 = nuevo archivo ("c: //users//yanga//desktop//a.txt"); archivo file2 = nuevo archivo ("a.txt");Por supuesto, también puede especificar explícitamente una ruta de los padres:
Archivo público (String Parent, String Child)
Dentro del constructor, el programa emplomará una ruta de archivo completa para nosotros, por ejemplo:
Archivo archivo = nuevo archivo ("c: // usuarios // yanga // escritorio", "a.txt"); archivo file1 = nuevo archivo ("c: // users // yanga // escritorio", "java");El tercer constructor es esencialmente el mismo que el segundo, excepto que agrega un proceso de encapsulación de la instancia de archivo principal:
Archivo público (File Parent, String Child)
No se explicarán situaciones similares. No hemos profundizado en la implementación específica interna de estos constructores aquí. No es que sea simple. En cambio, el archivo se basa demasiado en el sistema de archivos local y la implementación de muchos métodos no se puede ver directamente. Por lo tanto, para el aprendizaje del archivo, es suficiente para ser competente para dominarlo, y la implementación específica no se puede aprender en profundidad por el momento.
Obtener información relacionada con el nombre del archivo o la ruta
El método GetName se puede usar para obtener el nombre del archivo:
public String getName () {int index = path.lastIndexOf (separatorChar); if (index <prefixlength) return rath.substring (prefixlength); return rath.substring (índice + 1);}¿Recuerdas lo que representa nuestro separatorchar?
Se representa como un separador de ruta, el símbolo "" en Windows se almacena en el atributo de ruta y el nombre de ruta completo de la instancia de archivo actual, por lo que todos los caracteres después del último ocurrencia deben ser nuestro nombre de archivo.
Por supuesto, debe haber descubierto que para archivos puros, este método puede devolver el nombre simple del archivo, mientras que para un directorio, el valor de retorno será el nombre del directorio más reciente. Por ejemplo:
Archivo archivo = nuevo archivo ("c: //users//yanga//desktop//a.txt"); system.out.println (file.getName ()); archivo file1 = nuevo archivo ("c: // users // yanga // escritorio"); system.out.println (file1.getName ());La salida no te sorprenderá:
a.txtdesktop
El método GetParent se utiliza para devolver el directorio principal del archivo actual. Ya sea que sea un archivo simple o un directorio, eventualmente tendrá su directorio principal (por supuesto, los archivos temporales generados por la máquina virtual no son, por supuesto,).
public String getParent () {int index = path.lastIndexOf (separatorChar); if (index <prefixlength) {if ((prefixlength> 0) && (path.length ()> prefixlength)) return Path.substring (0, prefixlength); regresar nulo; } return rath.substring (0, índice);}La implementación del método es muy simple, por lo que no entraré en detalles.
El método GetPath puede devolver el nombre de archivo completo de la instancia de archivo actual:
public String getPath () {ruta de retorno;}Las siguientes son algunas operaciones relacionadas relacionadas con los directorios, que son relativamente simples de implementar. Aquí hay una breve lista:
Aquí debemos explicar alguna explicación de GetCanonicalPath, ¿qué es un camino estándar, y hay alguna diferencia entre un camino absoluto?
En términos generales, "../" significa el directorio anterior del directorio donde se encuentra el archivo de origen, "../../" significa el directorio anterior del directorio donde se encuentra el archivo fuente, y así sucesivamente. El método GetAbsolutePath no realiza tales operaciones de conversión, mientras que el método GetCanonicalPath reconoce estos caracteres especiales y toma la semántica adecuada.
Por ejemplo:
Archivo archivo = nuevo archivo ("..// a.txt"); system.out.println (file.getabsolutepath ()); system.out.println (file.getCanonicalPath ());Resultado de salida:
C:/usuarios/yanga/escritorio/java/workspace2017/testfile /../ a.txt
C: /users/yanga/desktop/java/workspace2017/a.txt
El primero usará "../a.txt" como parte del nombre de la ruta del archivo, mientras que el segundo puede reconocer que "../a.txt" significa que "a.txt" se encuentra en el directorio superior del directorio actual. Esta es la mayor diferencia entre los dos, adecuado para diferentes situaciones.
Obtenga la información del atributo del archivo
La operación de esta parte del archivo es realmente muy simple, no es más que algunas preguntas sobre los permisos de archivo, ya sea legible, ya sea que sea Writable, ya sea un archivo oculto, etc. Echemos un vistazo a estos métodos en detalle en detalle:
Cabe señalar que el método de longitud puede devolver correctamente el número total de bytes del archivo para un archivo puro, pero para un directorio, el valor de retorno será un valor "no especificado", que no es el número total de bytes de todos los archivos en el directorio y cero, pero es solo un valor no especificado, que no tiene sentido.
Operación de archivo
El funcionamiento de los archivos no es más que "adición, eliminación, modificación y búsqueda". Echemos un vistazo juntos.
Por supuesto, cuando se trata de las dos nuevas operaciones simples de creación y eliminación, la clase de archivo también proporciona las llamadas operaciones de "consulta", que necesitamos aprender con cuidado. Por ejemplo:
public String [] list () {SecurityManager Security = System.getSecurityManager (); if (Security! = Null) {Security.Checkread (ruta); } if (isInvalid ()) {return null; } return fs.list (this);}Este método recuperará todos los nombres simples de "archivos puros" y "directorio" en el directorio representado por la instancia actual. Por ejemplo:
Archivo archivo = nuevo archivo ("c: // users // yanga // escritorio"); string [] list = file.list (); for (string str: list) {system.out.println (str);}El resultado de salida del programa imprimirá los nombres simples de todos los archivos en el directorio de escritorio de mi computadora, por lo que no se lo mostraré.
Una cosa a tener en cuenta es que si nuestra instancia de archivo no corresponde a un directorio sino a un archivo simple, la lista devolverá NULL.
A continuación, veamos un método para recuperar archivos de directorio:
public String [] list (FileNameFilter Filter) {String Names [] = list (); if ((nombres == null) || (filtre == null)) {return names; } List <String> V = New ArrayList <> (); for (int i = 0; i <names.length; i ++) {if (filtre.accept (this, nombres [i])) {v.add (nombres [i]); }} return v.toarray (nueva cadena [v.size ()]);}Este método es en realidad una versión sobrecargada de la lista, que le permite pasar en un filtro para filtrar solo los archivos y directorios que necesitamos al buscar directorios.
Pero la definición de la interfaz FileNameFilter es tan simple:
Interfaz pública FileNameFilter {boolean Acept (archivo dir, nombre de cadena);}Solo necesita anular este método de aceptación. Cada vez que la lista para bucle obtiene un archivo o directorio, intentará llamar primero a este método de filtrado. Si pasa el filtrado, el nombre simple del archivo actual se agregará a la colección de retorno.
Por lo tanto, la reescritura de este método de aceptación determina qué archivos pueden pasar el filtrado y cuál no. Veamos un ejemplo:
Los archivos en la carpeta de prueba en mi escritorio son los siguientes:
Archivo archivo = nuevo archivo ("c: // usuarios // yanga // escritorio // prueba"); String [] list = file.list (new FileNameFilter () {@Override public boolean Acept (archivo dir, name de cadena) {// El objeto de archivo actual representado por dir // name es el nombre simple del elemento del archivo actualmente atravesado (! Name.endswith (". Txt")) return false; else return real;}); for (string str: list) {system.out.println (str); }Aquí, usamos la clase interna anónima para crear una instancia de subclase de FileNameFilter y luego implementar su método de aceptación. La implementación específica es muy simple, filtrando todos los directorios y elimina los nombres simples de todos los archivos simples.
El resultado final de salida es el siguiente:
3.txt
4.Txt
Por supuesto, también hay dos métodos de lista "mutados" en la clase de archivo, como:
Ya no devuelven los nombres simples de "archivos puros" y "directorios" en el directorio de destino, sino que devuelven el objeto de archivo correspondiente. De hecho, no es nada. El directorio de destino + un nombre simple puede construir estas instancias de archivo.
Por lo tanto, esencialmente, el método de la lista no atraviesará todos los archivos en el directorio de destino, es decir, los archivos en el subdirectorio del directorio de destino no se accederán ni atravesará.
Por lo tanto, debe pensar en cómo atravesar todos los archivos en el directorio de destino, incluidos los archivos profundos en los subdirectorios de primer nivel. La respuesta se dará al final del artículo.
Los siguientes dos métodos están relacionados con la creación de carpetas:
Ambos se basan en la instancia de archivo actual para crear carpetas. Con respecto a sus diferencias, veamos primero un código:
Archivo archivo = nuevo archivo ("c: // users // yanga // escritorio // test2"); system.out.println (file.mkdir ()); archivo file2 = nuevo archivo ("c: // users // yanga // escritorio // test3 // hello"); system.println (file2.mkdir ());Entre ellos, Test2 y Test3 no existen hasta que se ejecute el programa.
El resultado de salida es el siguiente:
verdadero
FALSO
¿Por qué este último no creó?
Esto se debe al hecho de que el método MKDIR solo puede crear una carpeta a la vez, lo que causará falla de creación si el directorio principal o superior del directorio dado existe un directorio no creado.
El método MKDIRS se utiliza para resolver esta situación. Creará todos los directorios no creados en la ruta de destino, vea el código:
Archivo archivo3 = nuevo archivo ("c: // usuarios // yanga // escritorio // test3 // hello // 231"); system.out.println (file3.mkdirs ());Incluso si nuestra carpeta Test3 no existe, después de que se ejecuta el programa, se creará las tres carpetas Test3, Hello y 231.
Además, el archivo también tiene un método para crear archivos temporales. Los llamados archivos temporales son: existen durante el tiempo de ejecución y se destruyen cuando la máquina virtual se apaga. Puedes estudiarlo tú mismo. Es relativamente simple de usar, por lo que no entraré en detalles aquí.
En este punto, hemos aprendido aproximadamente el archivo de tipo de archivo. Creo que todos sienten más o menos que el diseño de representar archivos y directorios puros usando el mismo tipo parece un poco confuso e irrazonable. Sé que JDK1.7 Sun ha lanzado archivos y ruta para separar archivos y directorios, y aprenderemos más sobre esto en los artículos futuros.
Todos los códigos, imágenes y archivos en el artículo se almacenan en la nube en mi github:
(https://github.com/singleyam/overview_java)
También puede elegir descargar localmente.
Resumir
Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.