Archivo
El archivo es una representación abstracta de "Archivo" y "Directorio PathName".
El archivo se hereda directamente del objeto, implementando la interfaz Serializable y la interfaz comparable. Implementar la interfaz serializable significa que los objetos de archivo admiten operaciones de serialización. Implementar la interfaz comparable significa que los objetos de archivo pueden ser dimensionados; Los archivos se pueden almacenar directamente en conjuntos ordenados (como Treeset y Treemap).
1. Métodos comunes para crear nuevos directorios
Método 1: Cree un nuevo directorio basado en la ruta relativa.
El código de muestra es el siguiente (cree el nuevo directorio "Dir" en la ruta actual):
Archivo dir = nuevo archivo ("dir"); dir.mkdir (); Método 2: Cree un nuevo directorio basado en la ruta absoluta.
El código de muestra es el siguiente (cree el nuevo directorio "/home/skywang/dir"):
Archivo dir = nuevo archivo ("/home/skywang/dir"); dir.mkdirs (); Nota: El anterior es el código fuente del nuevo directorio "/Home/Skywang/Dir" en el sistema Linux. En Windows, si desea crear un nuevo directorio "D:/Dir", el código fuente es el siguiente:
Archivo dir = nuevo archivo ("d:/dir"); dir.mkdir (); Método 3
Uri uri = nuevo uri ("archivo:/home/skywang/dir"); Archivo dir = nuevo archivo (URI); sub.mkdir (); Nota: Similar al "Método 2", excepto que la ruta completa se pasa en "Método 2", mientras que la ruta completa se pasa en "Método 3" es el URI correspondiente a la ruta completa.
2. Varios métodos comunes para crear un nuevo subdirectorio. Por ejemplo, queremos crear un nuevo subdirectorio en el subdirectorio "Dir" del directorio actual. Hay varias formas:
Método 1
Archivo sub1 = nuevo archivo ("dir", "sub1"); sub1.mkdir (); Nota: La función del método anterior es "Dir/Sub1" en el directorio actual. ¡La premisa para que se ejecute normalmente es que el directorio de padres "Dir" de "Sub1" ya existe!
Método 2
Archivo sub2 = nuevo archivo (dir, "sub2"); sub2.mkdir ();
Nota: La función del método anterior es "Dir/Sub2" en el directorio actual. ¡La premisa para que se ejecute normalmente es que el directorio de padres "Dir" de "Sub2" ya existe!
Método 3
Archivo sub3 = nuevo archivo ("dir/sub3"); sub3.mkdirs (); Nota: La función del método anterior es "Dir/Sub3" en el directorio actual. No requiere que la DIR exista y puede funcionar normalmente; Si la ruta principal de "Sub3" no existe, el método mkdirs () creará automáticamente el directorio principal.
Método 4
Archivo sub4 = nuevo archivo ("/home/skywang/dir/sub4"); sub4.mkdirs (); Nota: La función del método anterior es crear un nuevo directorio "/home/skywang/dir/sub3". No requiere que la DIR exista, y puede funcionar normalmente; Si la ruta principal de "Sub4" no existe, el método mkdirs () creará automáticamente el directorio principal.
Método 5
Uri uri = nuevo uri ("archivo:/home/skywang/dir/sub5"); Archivo sub5 = nuevo archivo (URI); sub5.mkdirs (); Nota: Similar al "Método 4", excepto que la ruta completa se pasa en el "Método 4", mientras que la ruta completa se pasa en el "Método 5" y el URI correspondiente a la ruta completa se pasa.
3. Varios métodos comunes para crear archivos nuevos
Por ejemplo, queremos crear un nuevo archivo en el subdirectorio del directorio actual "DIR". Hay varios métodos 1
intente {archivo dir = new File ("Dir"); // Obtenga el objeto Archivo correspondiente al directorio "Dir" Archivo de archivo1 = nuevo archivo (dir, "file1.txt"); file1.createNewFile ();} catch (ioException e) {E.PrintStackTrace Nota: La función del código anterior es crear un nuevo archivo "File1.txt" en el directorio "Dir" (ruta relativa).
Método 2
intente {archivo file2 = nuevo archivo ("dir", "file2.txt"); file2.createenewfile ();} catch (ioException e) {E.PrintStackTRace Nota: La función del código anterior es crear un nuevo archivo "file2.txt" en el directorio "Dir" (ruta relativa).
Método 3
intente {archivo file3 = nuevo archivo ("/home/skywang/dir/file3.txt"); file3.createenewfile ();} catch (ioException e) {E.PrintStackTRace Nota: La función del código anterior es crear un nuevo archivo "/home/skywang/dir/file3.txt" (ruta absoluta). Este es un método basado en la ruta absoluta en Linux. En Windows, puede crear un nuevo archivo "d: /dir/file4.txt" a través del siguiente código.
intente {archivo archivo3 = nuevo archivo ("d: /dir/file4.txt"); file3.createenewfile ();} catch (ioException e) {E.PrintStackTRace Método 4
Pruebe {uri uri = new Uri ("file: /home/skywang/dir/file4.txt"); Archivo file4 = nuevo archivo (URI); file4.createenewfile ();} catch (ioException e) {E.PrintStackTrace ();} ilustrar:
Similar al "Método 3", excepto que la ruta completa se pasa en "Método 3", mientras que la ruta completa se pasa en "Método 4" es el URI correspondiente a la ruta completa.
4. Ejemplo de uso de la API de archivo
Para un uso detallado de API en el archivo, consulte el código de ejemplo (filetest.java):
import java.io.file; import java.io.ioException; import java.net.uri; import java.util.calendar; import java.text.simpledateformat; public class filetest {public static void main (string [] argumenta) {testfilestaticFields (); testFileDirapis (); } public static void testFilestaticFields () {// Imprimir separador de ruta ":" System.out.printf ("file.pathseparator =/"%s/"/n", file.pathseparator); // Imprimir separador de ruta ':' system.out.printf ("file.pathseparatorchar =/"%c/"/n", file.pathseparatorchar); // Imprima delimitador "/" System.out.printf ("file.separator =/"%s/"/n", file.separator); // Imprima delimitador '/' System.out.printf ("file.separatorchar =/"%c/"/n", file.separator); // Imprime delimitador '/' System.out.printf ("file.separatorchar =/"%c/"/n", file.separatorchar); } public static void testFileDirapis () {try {// Crear nuevo directorio "dir" archivo dir = nuevo archivo ("dir"); dir.mkdir (); // Método 1: Cree un nuevo directorio "Dir/Sub1". ¡El "Dir" de los padres ya debe existir! Archivo sub1 = nuevo archivo ("dir", "sub1"); sub1.mkdir (); // Método 2: cree un nuevo directorio "Dir/Sub2". ¡El "Dir" de los padres ya debe existir! Archivo sub2 = nuevo archivo (dir, "sub2"); sub2.mkdir (); // Método 3: cree un nuevo directorio "Dir/Sub3". MkDirs () creará automáticamente un directorio principal que no existe. Archivo sub3 = nuevo archivo ("dir/sub3"); sub3.mkdirs (); // Método 4: Cree un nuevo directorio "Dir/Sub4". Creado de acuerdo con "Path Absolute", los primeros 3 métodos se crean en base a "Ruta relativa". Cadena dirpath = dir.getabSolutePath (); // Obtenga la ruta absoluta de la cadena "Dir" sub4abspath = dirpath + file.separator + "sub4"; // file.separator es el archivo delimitador "/" sub4 = nuevo archivo (sub4abspath); sub4.mkdirs (); // Método 5: Cree un nuevo directorio "Dir/Sub5". Según la cadena URI URI_SUB5_PATH = "FILE:" + DirPath + File.separator + "Sub5"; Uri uri_sub5 = nuevo URI (URI_SUB5_PATH); Archivo sub5 = nuevo archivo (uri_sub5); sub5.mkdirs (); // Método 1: Cree un nuevo archivo "Dir/l1_normal.txt" archivo l1_normal = nuevo archivo (dir, "l1_normal.txt"); l1_normal.createNewFile (); // Método 2: Cree un nuevo archivo "Dir/.L1_Hide.txt". Archivo l1_hide = nuevo archivo ("dir", ".l1_hide.txt"); // En Linux, el archivo que comienza con "." es un archivo oculto. l1_hide.createenewfile (); // Método 3: Cree un nuevo archivo "Dir/L1_abs.txt". Cadena dirabspah = dir.getabSolutePath (); // Obtenga la ruta absoluta de la cadena DIR L1_ABS_PATH = DirabSpah+File.separator+"L1_abs.txt"; Archivo l1_abs = nuevo archivo (l1_abs_path); l1_abs.createenewfile (); //System.out.printf("l1_abs_path=%S/n ", l1_abs_path); //System.out.printf("l1_abs ruta =%s/n ", l1_abs.getabsolutepath ()); // Método 4: Cree un nuevo archivo "Dir/L1_uri.txt". Cree un nuevo archivo de acuerdo con la cadena URI URI_PATH = "FILE:" + DirabSpah + File.separator + "L1_uri.txt"; Uri uri_l1 = nuevo uri (uri_path); //System.out.printf("URI_L1=%S/N ", L1_ABS.GETABSOLUTEPATH ()); Archivo l1_uri = nuevo archivo (uri_l1); l1_uri.createenewfile (); // Cree un nuevo archivo "Dir/Sub/S1_Normal" Archivo S1_Normal = nuevo archivo (Sub1, "S1_Normal.txt"); s1_normal.createNewFile (); System.out.printf (" %30s = %s/n", "s1_normal.exists ()", s1_normal.exists ()); System.out.printf (" %30s = %s/n", "s1_normal.getName ()", s1_normal.getName ()); System.out.printf (" %30s = %s/n", "s1_normal.getParent ()", s1_normal.getParent ()); System.out.printf (" %30s = %s/n", "s1_normal.getpath ()", s1_normal.getpath ()); System.out.printf (" %30s = %s/n", "s1_normal.getabsolutePath ()", s1_normal.getabsolutePath ()); System.out.printf (" %30s = %s/n", "s1_normal.getCanonicalPath ()", s1_normal.getCanonicalPath ()); System.out.printf ("%30s =%s is/"%s/"/n", "s1_normal.lastModified ()", s1_normal.lastModified (), getModifytime (s1_normal.lastModified ())); System.out.printf (" %30s = %s/n", "s1_normal.touri ()", s1_normal.touri ()); // enumere "archivos" y "carpetas" en el directorio "Dir". // NOTA: Dir.ListFiles () solo atravesará el directorio Dir, ¡no los subdirectorios de DIR! System.out.println ("--- Lista de archivos y carpetas ----"); Archivo [] fs = dir.listFiles (); for (archivo f: fs) {string fname = f.getName (); Cadena absstr = f.isabsolute ()? "[Absoluto]": ""; String Hiddenstr = F.ishidden ()? "[Oculto]" : ""; Cadena dirstr = f.isDirectory ()? "[Directorio]": ""; String filestr = f.Isfile ()? "[Archivo]" : ""; System.out.printf ("%-30s%s%s%s%s/n", fname, filestro, dirstr, absstr, hiddenstr); }} catch (Exception e) {E.PrintStackTrace (); }} cadena estática privada getModifytime (Long Millis) {// Objetivo de calendario Calendario cal = calendario.getInstance (); // establece el tiempo en Millis Cal.SetTimeinmillis (Millis); // Obtenga el objeto formateado, formateará la fecha de acuerdo con "aaa yyyy-mm-dd hh: mm: ss" simpledateFormat sdf = new SimpleDateFormat ("yyyy-mm-dd hh: mm: ss"); //System.out.printf("time %s/n ", str); return sdf.format (cal.gettime ()); }} Ejecutar resultados (ejecutar resultados en el sistema Ubuntu 12.04, no Windows!):
File.pathseparator = ":" file.pathseparatorchar = ":" file.separator = "/" file.separatorchar = "/" s1_normal.exists () = true s1_normal.getName () = s1_normal.txt s1_normal.getparent () = dir/sub1 s1_normal.getpath () =) dir/sub1/s1_normal.txt s1_normal.getabsolutepath () = /home/skywang/wind_talker/workout/java/skywang/io/io/src/file/dir/sub1/s1_normal.txt s1_normal.getCanonicalpath () = = = = = /home/skywang/wind_talker/workout/java/skywang/io/io/src/file/dir/sub1/s1_normal.txt s1_normal.lastModified () = 1381730064000 es "2013-10-14 13:54:24" S1_Normal.Touri () =) archivo: /home/skywang/wind_talker/workout/java/skywang/io/io/src/file/dir/sub1/s1_normal.txt --- Listen archivos y carpetas ---- l1_uri.txt [archivo] sub1 [directorio] l1_abs.txt [archivo] sub5 [directorio] sub4 [directorio]. [Archivo] [Hidden] Sub3 [Directorio] Sub2 [Directorio] l1_normal.txt [archivo]
Resultados: Al ejecutar el programa, se creará un nuevo directorio "DIR" en el directorio donde se encuentra el archivo fuente, sus subdirectorios y subfiles. Como se muestra en la figura a continuación:
Filedescriptor
FileDeScriptor es un "descriptor de archivo".
FileDeScriptor se puede usar para representar archivos abiertos, enchufes abiertos, etc.
Para representar un archivo por FileDeScriptor: cuando FileDeScriptor representa un archivo, simplemente podemos considerar FileDeScriptor como el archivo. Sin embargo, no podemos operar en el archivo directamente a través de FileDeScriptor; Si necesitamos operar en el archivo a través de FileDeScriptor, necesitamos crear un FileOutputStream correspondiente a FileDeScriptor y luego operar en el archivo.
En, Out, ERR Introducción
(1) en - Descriptor para entrada estándar (teclado)
(2) fuera: el descriptor para la salida estándar (pantalla)
(3) ERR: los descriptores de salida de error estándar (pantalla) son similares en principio y uso. Realicemos una investigación en profundidad a lo largo.
1.1 El papel y el principio de fuera
Out es el descriptor para la salida estándar (pantalla). Pero, ¿qué hace?
Podemos entenderlo de una manera simple que representa la salida estándar (pantalla). Si queremos generar información a la pantalla, podemos operarla a lo largo; Sin embargo, OUT no proporciona una interfaz para salir de información a la pantalla (porque Out es esencialmente un objeto Filedescriptor, y FileDeScriptor no tiene una interfaz de salida). ¿Qué hacer?
Es muy simple. Creamos el "objeto de transmisión de salida" correspondiente a la salida y luego emitimos la información a la pantalla a través de la interfaz de salida, como Write () de la "transmisión de salida". El siguiente código:
intente {fileOutputStream out = new FileOutputStream (fileDescriptor.out); out.write ('a'); out.close ();} capt (ioexception e) {} Ejecute el programa anterior y se emitirá la letra 'A' en la pantalla.
Para facilitar nuestra operación, Java ha encapsulado durante mucho tiempo la "interfaz que puede obtener fácilmente información en la pantalla" para nosotros: a través de System.out, podemos generar información fácilmente a la pantalla.
Por lo tanto, podemos convertir de manera equivalente el programa anterior en el siguiente código:
System.out.print ('a'); Hablemos sobre los principios de los dos códigos anteriores para ver la definición de salida. Su definición está en FileDescriptor.java, y el código fuente correspondiente es el siguiente:
Public Final Clase FileDescriptor {private int fd; Public static final FileDescriptor out = new Filedescriptor (1); Private FileDescriptor (int fd) {this.fd = fd; useCount = new AtomicInteger (); } ...} De esto, se puede ver que
(1) Out es un objeto Filedescriptor. Se crea a través del Constructor FilEdescriptor (int fd).
(2) Operación FILEDESCRIPTOR (int fd): asigne valores al objeto FD (tipo int) y cree una nueva variable de conteo utilizando USECOUNT.
El objeto FD es una variable muy importante. "FD = 1" representa "salida estándar", "fd = 0" representa "entrada estándar" y "fd = 2" representa "salida de error estándar".
FileOutputStream out = new FileOutputStream (FileDescriptor.out);
Es para usar el constructor FileOutputStream (FileDescriptor FDobj) para crear el "objeto FileOutputStream correspondiente a FilEd.out".
Sobre cómo se define el sistema. Puede consultar "comprensión en profundidad de System.out.println (" Hello World ")"
A través del aprendizaje anterior, sabemos que podemos personalizar las secuencias de descriptores de archivos estándar [es decir, IN (entrada estándar), salida (salida de error estándar) y err (salida de error estándar)] para completar la función de entrada/salida; Sin embargo, Java ha encapsulado la interfaz correspondiente para nosotros, es decir, podemos usar System.in, System.out, System.err más convenientemente.
Además, también podemos personalizar los descriptores de archivos para "archivo", "socket", etc., y luego operarlos. Consulte el testWrite (), testread () y otras interfaces en el siguiente código de ejemplo.
2. Código de muestra
El código fuente es el siguiente (FileDescriptortest.java):
import java.io.printstream; import java.io.fileiledescriptor; import java.io.fileInputStream; import java.io.fileOutputStream; import java.io.ioException; clase pública Falledescriptest {String final estática privada FileName = "File.txt"; static final static static outText = "HI FileDescriptor"; public static void main (string [] args) {testWrite (); testread (); testStandfd (); //System.out.println(OutText); } /*** PROBLE PROGRAMA DE FileDescriptor.out** El efecto de este programa es equivalente a system.out.println (outText); */ private static void testStandfd () {// Cree la correspondiente printstream printStream out = new printStream (new FileOutputStream (FileDescriptor.out)); // Salida "HI FileDescriptor" en la pantalla out.println (outText); out.close (); } /*** FileDescriptor escribiendo el programa de muestra** (1) Para ilustrar, "Crear FileOutputStream por nombre de archivo" es equivalente a "Creación de FileOutputStream por descriptor de archivo" Objeto* (2) El programa creará un nuevo archivo "File.txt" en el directorio donde se encuentra "el archivo fuente", y el contenido del archivo es "AA". */ private static void testWrite () {try {// crea el objeto FileOutputStream correspondiente al archivo "file.txt" fileOutputStream out1 = new FileOutputStream (FileName); // Obtenga el "Descriptor de archivo" correspondiente al archivo "File.txt" FileDescriptor fDout = out1.getfd (); // Crear objeto "FileOutputStream" basado en el "Descriptor de archivo" FileOutputStream out2 = new FileOutputStream (FDOUT); out1.write ('a'); // escribir 'a' a "file.txt" a través de out1 out2.write ('a'); // escribir 'a' a "file.txt" a través de out2 if (fdout! = Null) system.out.printf ("fdout ( %s) es %s/n", fdout, fdout.valid ()); out1.close (); out2.close (); } catch (ioException e) {E.PrintStackTrace (); }} / *** FileDescriptor Read Sample Program** Para ilustrar, "Crear fileInputStream por nombre de archivo" es equivalente a "Crear FileInputStream por archivo Descriptor" objeto* / privado void testread () {intento {// Crear archivo FileInputStream correspondiente al archivo "File.txt" FileInputStream in1 = new FileInputam (FileNputSeam (FileNputam (FilEnput Name); // Obtenga el "Descriptor de archivo" correspondiente al archivo "File.txt" FileDescriptor fdin = in1.getfd (); // Crear objeto "FileInputStream" de acuerdo con el "Descriptor de archivo" FileInputStream in2 = new FileInputStream (FDIN); System.out.println ("in1.read ():"+(char) in1.read ()); System.out.println ("in2.read ():"+(char) in2.read ()); if (fdin! = null) system.out.printf ("fdin ( %s) es %s/n", fdin, fdin.valid ()); in1.close (); in2.Close (); } catch (ioException e) {E.PrintStackTrace (); }}} Resultados de ejecución:
fdout (java.io.filedescriptor@2b820dda) es trueIn1.read (): ain2.read (): afdin (java.io.filedescriptor@675b7986) es TrueHi Filedescriptor