1. Codificación de documentos
paquete com.study.io;/*** Encodado de archivo de prueba*/public class EncodeDeMo {/*** @param args*@throws Exception*/public static void main (String [] args) lanza la excepción {String s = "estudio ABC Well"; byte [] bytes1 = s.getByB del proyecto (aquí está UTF-8) para (byte b: bytes1) {// convertir bytes (a int) para mostrar system.out.print (integer.tohexString (b & 0xff)+""); // & 0xff es para eliminar los primeros 24 0s y dejar solo los últimos ocho dígitos} system.out.println ();/*utf-8 codifica, eliminar los primeros. byte in English */byte[] bytes2 = s.getBytes("utf-8");//There will be an exception displayed here, so we throw this exception for (byte b : bytes2) {System.out.print(Integer.toHexString(b & 0xff)+" ");}System.out.println();/*gbk encoding occupies 2 bytes, and 1 byte en inglés */byte [] bytes3 = s.getBytes ("gbk"); // habrá una excepción que se mostrará aquí, por lo que lanzaremos esta excepción para (byte b: bytes3) {system.out.print (integer.toHexString (b & 0xff)+"");} system.println ();/ *Utf-16be encoded cheates 2 2 bytes*/byte [] bytes4 = s.getBytes ("utf-16be"); // Habrá una excepción que se mostrará aquí, por lo que lanzaremos esta excepción para (byte b: bytes4) {system.out.Print (integer.toHexString (b & 0xff)+"");} system.pintln ();/*When byte lel leltence, si tu byte, si tu byte, es un byte, es un byte leltence, es un ciclo, si tu byte, es un byte, es un byte shoding, es un ciclo, es un ciclo, si tu byte, es un byte lelughence, es un ciclo, es cierto, cuando tu byte, es un byte. want to turn the byte sequence into a string, you also need to use this encoding method, otherwise garbled code will appear*/String str1=new String(bytes4);//At this time, the project's default encoding will be used to convert, and garbled code may appear System.out.println(str1);//You need to use the byte sequence encoding to convert String str2=new String (bytes4, "utf-16be"); system.out.println (str2);}} analizar:
* 1. Explicación de "& 0xff":
* 0xff representa hexadecimal (decimal es 255), y se expresa como binario, que es "1111111111".
* Entonces el y el carácter representa el número de bits (return 1 cuando lo mismo es 1, de lo contrario regresa 0)
* 2. Byte Byte e int Type Conversion:
* Integer.ToHexString (B & 0xff) Aquí, B y 0xff de tipo de byte se realizan primero, y luego Integer.toHexString obtiene la cadena hexadecimal
* Se puede ver que el resultado de B & 0xff sigue siendo un int, entonces, ¿por qué necesita realizar una operación con 0xff? Integer directo.tohexstring (b);, no se puede forzar el byte para convertirse? La respuesta no es posible.
* La razón es: 1. El tamaño de Byte es de 8 bits y el tamaño de int es de 32 bits; 2. Formulario de complemento de Java Two
* El parámetro de Integer.ToHexString es int. Si y 0xff no se realizan, entonces cuando un byte se convertirá en int, ya que int es 32 bits y byte solo tiene 8 bits, se llenará en este momento. . . . . .
* Por lo tanto, cuando se involucran un byte y 0xff, el byte se convertirá primero en una cirugía plástica, de modo que los 24 bits altos en el resultado siempre se despejarán por 0, por lo que el resultado siempre es lo que queremos.
* 3.Utf-8 Codificación: China ocupa 3 bytes e inglés ocupa 1 byte
* Codificación de GBK: los chinos ocupan 2 bytes y el inglés ocupa 1 byte
* Java usa codificación de doble byte (es decir, un personaje en Java representa dos bytes) y es una codificación UTF-16BE. Chino ocupa 2 bytes, el inglés ocupa 2 bytes
*
* 4. Cuando su secuencia de byte es una determinada codificación, si desea convertir la secuencia de bytes en una cadena, también debe usar este método de codificación, de lo contrario se producirá un código confuso.
* 5. Los archivos de texto son secuencias de bytes. Puede ser cualquier secuencia codificada de bytes.
* Si creamos un archivo de texto directamente en una máquina china, entonces el archivo solo reconoce la codificación ANSI (por ejemplo, crea un archivo de texto directamente en la computadora)
2. Uso de la clase de archivo
paquete com.study.io; import java.io.file;/*** Uso de la clase de archivo*/public class FileDemo {/*Java.io.file La clase representa un archivo o directorio. La clase de archivo solo se usa para representar la información de un archivo o directorio (nombre, tamaño, etc.) y no se puede usar para acceder al contenido del archivo. */public static void main (string [] args) {file file = new File ("d: // 111"); // Al crear un objeto de archivo, debe usar cortes dobles para especificar el directorio, porque "/" es un carácter de escape/*el separador en el medio del directorio se puede usar con slashes dobles, traseros traseros o archivo. Archivo ("d:"+file.separator); // system.out.println (file.exists ()); // exists () determina si un archivo o carpeta existe si (! File.exists ()) {// si el archivo no existe file.mkdir (); // crea una carpeta mkdir () y mkdirs () crea un multicia multicia a múltiples directorio} else {file.delete (); // eliminar un archivo o carpeta} // detectar si es un directorio iSdirectory, return true si es un directorio, return falsesystem.out.println (file.isDirectory ()); // Muestre si es un archivo isFilessystem.out.println (file.issil ()); Archivo file2 = nuevo archivo ("d: // 222", "123.txt"); // común api: system.out.println (archivo); // imprima el contenido de file.ToString () system.out.println (file.getabsolutePath ()); // System.out.println (file2.getName ()); System.out.println (file.getParent ()); // Obtenga la ruta absoluta matriz System.out.println (file2.getParentFile (). GetAbSolutePath ());}} Resultados de ejecución:
ilustrar:
Java.io.file La clase representa un archivo o directorio
La clase de archivo solo se usa para representar información (nombre, tamaño, etc.) de un archivo o directorio y no se puede usar para acceder al contenido del archivo.
API de uso común:
1. Cree un objeto de archivo: archivo archivo = nuevo archivo (ruta de cadena); Nota: file.seperater (); Obtenga el delimitador del sistema, como: "/".
2. Si boolean file.exists (); existe.
3.file.mkdir (); o file.mkdirs (); Cree un directorio o directorio de niveles múltiples.
4.file.isDirectory () determina si se trata de un directorio
file.isfile () determina si se trata de un archivo.
5.File.Delete (); Eliminar archivo o directorio.
6.File.CreateNewFile (); crear un nuevo archivo.
7.file.getName () Obtiene el nombre del archivo o la ruta absoluta del directorio.
8.file.getAbSolutePath () obtiene el camino absoluto.
9.file.getParent (); Obtenga el camino absoluto de los padres.
1. Traverse el directorio
paquete com.study.io; import java.io.file; import java.io.ioexception;/*** La clase de herramienta de archivo*enumera las operaciones comunes de la clase de archivos, como: filtrar, recorrer, etc.*/public classeutils {/*** Enumera todos listDirectory (file dir) lanza ioexception {if (! dir.exists ()) {// exists () se usa para determinar si un archivo o directorio ha lanzado nuevo ilegalargumentException ("dir:"+dir+"no existe");} if (! dir.isDirectory ()) {// es el método () método que se usa para determinar el objeto de la clase de archivo de la región del archivo de la clase de archivo. IlegalArgumentException (dir+"no un directorio");}/*string [] filenames = dir.list (); // list () El método se utiliza para enumerar los subdirectorios y archivos en el directorio actual (es directamente el nombre de los subdirectorios y no contiene los contenidos en los subdirectorios), y se devuelve la matriz de cadena (String String: FileMames). {System.out.println (String);}*/// Si desea atravesar el contenido en el subdirectorio, debe construir el objeto de archivo para operaciones recursivas. El archivo proporciona un apifile que devuelve directamente el objeto Archivo. listFiles = dir.listFiles (); // Devuelve una abstracción del subdirectory directo (archivo) if (listFiles! = null && listFiles.length> 0) {para (archivo archivo: listFiles) {/*System.out.println(file);*/if(file.isDirectory())))//recursive( listDirectory (archivo);} else {System.out.println (archivo);}}}}}} Clase de prueba:
Public Class FileUtilStest {public static void main (string [] args) lanza ioexception {fileUtils.listDirectory (nuevo archivo ("d: // iostudy"));}} Resultados de ejecución:
3. Uso de la clase RandomAccessFile
RandomAccessFile: Java proporciona acceso a contenido de archivos, que se puede usar para leer archivos o escribir archivos.
RandomAccessFile admite acceso aleatorio a archivos y puede acceder a cualquier ubicación del archivo.
Tenga en cuenta el modelo de archivo Java:
Resultados de ejecución:
1
12
[65, 66, 127, -1, -1, -1, 127, -1, -1, -1, -42, -48]
7f
FF
FF
FF
7f
FF
FF
FF
d6
d0
4. Byte Stream (FileInputStream, FileOutputStream)
Las transmisiones IO se pueden dividir en transmisiones de entrada y transmisiones de salida.
Aquí se puede dividir en la corriente de byte y la corriente de personajes.
Ejemplo de código:
paquete com.study.io; import java.io.bufferedInputStream; import java.io.bufferedOutputPutStream; import java.io.file; import java.io.fileInputStream; import java.io.fileOutputStream; importación de java.io.io.ioException;/*** IOLA CLASE* ❤FILE INPUT y CORTACIÓN DE SECURITO:* FileRstream; Datos en archivos* FileOutputStream-> Implementación del método de escribir datos de byte en archivos* ❤ ❤ Data Ingrese y transmisión de salida:* dataOutputStream/datainputStream: extender la función "stream", puede leer int, largos y otros tipos de datos más int, largos y otros datautputStream writeint ()/writedul BufferedOutputStream* Estos dos bits de clase de transmisión IO proporcionan operaciones con buffers. En general, al abrir un archivo para las operaciones de escritura o lectura, se agregará el búfer. This stream mode improves the performance of IO* For example: Putting input into a file from an application is equivalent to pouring a cylinder of water into another cylinder: FileOutputStream--->write() method is equivalent to "transferring" the water over DataOutputStream-->writeXxx() method is more convenient, equivalent to "transferring" the water over BufferedOutputStream--->write method is more convenient, equivalent to putting a Primero coloque el cubo (es decir, el área del amortiguación), y luego verterlo en otro cilindro del cubo. El rendimiento se mejora*/public class Ioutil {/*** Lea el contenido del archivo especificado y lo emita a la consola en hexadecimal* y cada línea de 10 bytes se rompa* @param filename* single-byte Reading no es adecuado para archivos grandes, y los archivos grandes son muy ineficientes*/public static void PrintThex (string fileName) lanza IOException {//: los archivos grandes son un archivo muy ineficiente*/public static Void PrintThex (String FileName) lanza IOEXCECTION {// COMPLE EL FILE AL FILE ANTENTA ANTENCIALES AL ARCHIVO MUY ineficiente. in = new FileInputStream (nombre de archivo); int b; int i = 1; while ((b = in.read ())! =-1) {/* 0xff se reemplaza con un sistema de 2 dígitos, lo que significa 8 1s. De esta manera, los 8 bits inferiores del personaje realmente se toman. * OXF es 15. Los números menores de 15 se convertirán en un número hexadecimal. * Your code hopes to be two fixed hexadecimal numbers, so when only one is generated, you need to add 0*/if(b <= 0xf){//Integer.toHexString(b) before the unit number is supplemented with 0System.out.print("0");}//Integer.toHexString(b) converts integer b into a hexadecimal string System.out.print (integer.tohexString (b)+""); if (i ++%10 == 0) {system.out.println ();}} in.close (); // La lectura de archivos debe cerrarse después de leer y escribir}/*** La lectura por lotes es eficiente para archivos grandes y también es la forma más utilizada de los archivos* @param fileNeMe* @throws ioException*/public votos estatales Void PrinthExbytreray (string fileMe). IoException {fileInputStream in = new FileInputStream (FileName); byte [] buf = new Byte [8* 1024];/* Batch Leer Bytes desde adentro y ponerlos en la matriz de byte de BUF,* comenzar desde la posición 0, y poner a lo la máximo in.read (buf, 0, buf.length); // Leer a la vez, lo que indica que la matriz de bytes es lo suficientemente grande int j = 1; for (int i = 0; i <bytes; i ++) {system.out.print (integer.toHexString (buf [i] & 0xff)+""); if (j ++%10 == 0) {system.out.println ();}}*/int bytes = 0; int j = 1; while ((bytes = = en &0xff*/if(j++%10==0){System.out.println();}}}in.close();}/*** File copy, byte batch read* @param srcFile* @param destFile* @throws IOException*/public static void copyFile(File srcFile, File destFile) throws IOException {if (? FileOutputStream (DestFile); // Cuando el archivo no existe, se creará directamente; Si existe, elimínelo y cree byte [] buf = nuevo byte [8 * 1024]; // lote lee y escriba int b; while ((b = in.read (buf, 0, buf.length))! = -1) {//read(buf,0,buf.length) La lectura con parámetros devuelve la longitud total de bytes; Cuando todos se leen es -1; out.write (buf, 0, b); out.flush (); // Es mejor agregar} in.close (); out.close ();}/*** para copiar el archivo y usar la transmisión de byte buffered* @param srcfile* @param destfile* @throws ioexception*/public static void copyfileByBuffer (archivo srcfile, archivo) lanzamiento IoException {if (! Srcfile.exists ()) {tire new IlegalArGumentException ("archivo:"+srcfile+"no existen");} if (! Srcfile.isfile ()) {tire newArgumentException (srcfile+"no un archivo");} buffedinputstam bis = new BuffederinputsterStream (new BuffeDing (New BuffeDing (New Bufferedinputer (New BufferedinputTerputper (SRCFILE+"NO A FILE");} BuffedinputStream Bis = New BuffederDinputTreamsTREAM (NEW BUFFEREDIN GUNTERGER (NEW BUFTERED GUNTERTING FileInputStream (srcfile)); bufferedOutputStream bos = new BufferedOutputStream (new FileOutputStream (DestFile)); int c; while ((c = bis.read ())! =-1) {bos.write (c); bos.flush (); // fresco el buffer} bis.close (); bos.close ();} BOBEDERING PARA FILE COPY* @param srcfile* @param destfile* @throws ioexception*/public static void copyfileByByte (file srcfile, file destfile) lanza ioexception {if (! srcfile.exist existir ");} if (! srcfile.isfile ()) {Throw New IlegalArGumentException (srcfile+" no un archivo ");} fileInputStream in = new FileStream (srcFile); fileOutPutStream out = new FileOutPutStream (DestFile); int c; while (c = in.read ()) Devuelve el contenido de Byte Read; Cuando todas las lecturas se devuelven, es -1; out.write (c); out.flush ();} in.close (); out.close (); out.close ();}} Clase de prueba:
paquete com.study.io; import java.io.file; import java.io.ioexception; import org.junit.test; public class Ioutiltest {@TestPublic Void testPrinthex () {try {Ioutil.printhex ("d: //Javaio//fileutils.java");} Catch (Ioutilception) {E.PrintStackTrace ();}}@testPublic void testprintThexByByTearray () {try {long start = system.currentTimemillis (); // La diferencia de tiempo entre la hora actual y la medianoche del 1 de enero de 1970 (medido en milisegundos) //Ioutil.printthexbybytearray("e://javaio//fileutils.java") ;//ioutil.printhex("e://javaio//1.mp3");ioutil.printhexbybytearray("e://javaio//1.mp3");sysystem.out.pintln éger. System.CurrentTimemillis (); System.out.println (end - start);} catch (ioException e) {E.PrintStackTrace ();}}@testPublic void testCopyFile () {try {ioutil.CopyFile (nuevo archivo ("d: //Javaio//1.txt"), nuevo Archivo ("d: //javaio//1copy.txt"));} catch (ioException e) {E.PrintStackTrace ();}}@testPublic void testCopyFileByBuffer () {try {long start = system.currentTimemillis ();/*iOutil.copyfileByte (newe Archivo ("e: //javaio//1.mp3"), nuevo archivo ("e: //javaio//2.mp3"));*/// más de 20,000 miliseConds/*ioutil.copyfileByBuffer (nuevo archivo ("e: //javaio//1.mp3"), nuevo archivo ("e: //javaioiio/13./3./3./3."); MilliseConds*/ioutil.CopyFile (nuevo archivo ("e: //javaio//1.mp3"), nuevo archivo ("e: //javaio//4.mp3")); // 7ms long end = system.currentTimemillis (); system.out.println (end - inicio);} Catch (iOexception E) {E.PrintTimillis (); syste.Println (end - inicio);} Catch (IOException E) {E.PrintTimillis (); syste.Println (end - inicio);} Catch (iOexception E) {E.PrintTimillis (); syste.Println (end - inicio);} Catch (iOexception E) {E.PrintTimillis ();};};}; }} 5. Transmisión del personaje
package com.study.io;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;public class IsrAndOswDemo {public static void main(String[] args)throws IOException {FileInputStream in = new FileInputStream ("e: //javaio//utf8.txt"); inputStreamReader isr = new InputStreamReader (in, "UTF-8"); // Encodificación de proyecto predeterminada. Al operar, debe escribir el formato de codificación del archivo en sí. FileOutputStream out = new FileOutputStream ("e: //javaio//utf81.txt"); outputStreamWriter OSW = new OutputStreamWrither (OUT, "UTF-8");/*int c; while c;/*lote leído, coloque la matriz de caracteres del búfer, comience desde la posición 0 y coloque el búfer. Longitud como máximo. El número de caracteres devueltos es el número de caracteres de lectura*/while ((c = isr.read (buffer, 0, buffer.length))! =-1) {cadena s = nuevo String (buffer, 0, c); system.out.print (s); osw.write (buffer, 0, c); osw.flush ();} isr.close (); osw.close (); osw.close ();}}Archivo Leer y escribir flujo de transmisión de caracteres (FileReader/FileWriter)
Filtrar para transmisiones de personajes
6. Serialización y deserialización de objetos
Ejemplo:
Aviso: