1. Encodage de documents
package com.study.io;/*** Test file encoding*/public class EncodeDemo {/*** @param args* @throws Exception */public static void main(String[] args) throws Exception {String s="Study ABC well";byte[] bytes1=s.getBytes();//This is to convert a string into a character array, and the byte sequence converted into the default encoding of the project (here is UTF-8) for (byte b : bytes1) {//Convert bytes (to int) to display System.out.print(Integer.toHexString(b & 0xff)+" ");//& 0xff is to remove the first 24 0s and leave only the last eight digits}System.out.println();/*utf-8 encoding occupies 3 bytes, and 1 octet en anglais * / octet [] bytes2 = s.getBytes ("utf-8"); // il y aura une exception affichée ici, donc nous organisons cette exception pour (byte b: bytes2) {System.out.print (Integer.tohexString (b & 0xff) + "");} System.out.println (); / * gbk Encoding occupe 2 bytes, et 1 bytet (); / * gbk ENCODING ENCODING 2 BYT.TUSTLN (); / * gbk Entarting en anglais * / octet [] bytes3 = s.getBytes ("gbk"); // il y aura une exception affichée ici, nous allons donc lancer cette exception pour (byte b: bytes3) {System.out.print (entier. 2 octets * / octet [] bytes4 = s.getBytes ("utf-16be"); // il y aura une exception affichée ici, donc nous lancerons cette exception pour (byte b: bytes4) {System.out.print (Integer.tohexString (b & 0xff) + "");} System.out.print si Vous voulez transformer la séquence d'octets en une chaîne, vous devez également utiliser cette méthode d'encodage, sinon le code brouillé apparaîtra * / string str1 = new String (bytes4); // à l'heure String (bytes4, "UTF-16BE"); System.out.println (str2);}} analyser:
* 1. Explication de «& 0xff»:
* 0xFF représente l'hexadécimal (décimal est 255) et est exprimé en binaire, qui est "111111111".
* Alors le & le caractère représente le nombre de bits (retour 1 lorsque le même est 1, sinon renvoyez 0)
* 2. Conversion de type octet octet et int:
* Integer.tohexstring (b & 0xff) ici, b et 0xff de type d'octet sont d'abord effectués, puis entier.tohexstring obtient la chaîne hexadécimale
* On peut voir que le résultat de B & 0xFF est toujours un INT, alors pourquoi avez-vous besoin d'effectuer une opération avec 0xFF? Direct Integer.tohexstring (b);, ne peut pas forcer l'octet à être converti? La réponse n'est pas possible.
* La raison en est la suivante: la taille du byte est de 8 bits et la taille de l'INT est de 32 bits; 2. Java's Two Compment Form
* Le paramètre d'Integer.tohexstring est int. Si & 0xff n'est pas effectué, alors lorsqu'un octet sera converti en int, car INT est 32 bits et que l'octet n'a que 8 bits, il sera rempli à ce moment. . . . . .
* Par conséquent, lorsqu'un octet et 0xff sont impliqués, l'octet sera d'abord converti en chirurgie plastique, de sorte que les 24 bits élevés dans le résultat seront toujours éliminés par 0, donc le résultat est toujours ce que nous voulons.
* 3.UTF-8 Encodage: chinois occupe 3 octets et l'anglais occupe 1 octet
* Encodage GBK: chinois occupe 2 octets et l'anglais occupe 1 octet
* Java utilise un codage à deux octets (c'est-à-dire qu'un personnage en Java représente deux octets) et est un codage UTF-16BE. Chinois occupe 2 octets, l'anglais occupe 2 octets
*
* 4.
* 5. Les fichiers texte sont des séquences d'octets. Il peut s'agir de n'importe quelle séquence codée d'octets.
* Si nous créons un fichier texte directement sur une machine chinoise, le fichier ne reconnaît que l'encodage ANSI (par exemple, créez un fichier texte directement sur l'ordinateur)
2. Utilisation de la classe de fichiers
package com.study.io; Importer java.io.file; / *** Utilisation de la classe de fichiers * / classe publique FileDemo {/*java.io.file La classe représente un fichier ou un répertoire. La classe de fichiers est uniquement utilisée pour représenter les informations d'un fichier ou d'un répertoire (nom, taille, etc.) et ne peut pas être utilisée pour accéder au contenu du fichier. * / public static void main (String [] args) {file file = new File ("d: // 111"); // Lors de la création d'un objet de fichier, vous devez utiliser Double Slashes pour spécifier le répertoire, car "/" est un caractère d'évasion / * Le séparateur au milieu du répertoire peut être utilisé avec Double Slashes, File1 = File1 = Nouveau File ("d:" + file.separator); // system.out.println (file.exists ()); // existant () détermine si un fichier ou un dossier existe if (! File.exists ()) {// Si le fichier n'existe pas de fichier.mkdir (); // créer un dossier mkdir (), et mkdirs () crée un multi-alevel répertoire} else {file.delete (); // supprimer un fichier ou un dossier} // détecter s'il s'agit d'un répertoire isdirectory, return true s'il s'agit d'un répertoire, renvoie falsesystem.out.println (file.isdirectory ()); // affiche s'il s'agit d'un fichier isfileSystem.out.println (file.fishisfile (); File file2 = new File ("d: // 222", "123.txt"); // API Common: System.out.println (fichier); // imprime le contenu de file.tostring () System.out.println (file.getabsolupath ()); // Get the AbsUlue Path System.out.println (file.get name ()); // Get the File. System.out.println (file2.getName ()); System.out.println (file.getParent ()); // Obtenez le chemin Absolute Parent System.out.out.println (file2.getParentFile (). GetAbSolutePath ());}} Résultats en cours:
illustrer:
La classe Java.io.File représente un fichier ou un répertoire
La classe de fichiers est uniquement utilisée pour représenter des informations (nom, taille, etc.) d'un fichier ou d'un répertoire et ne peut pas être utilisée pour accéder au contenu du fichier.
API couramment utilisées:
1. Créer un objet de fichier: fichier file = new File (String path); Remarque: file.seperater (); Obtenez le délimiteur système, tel que: "/".
2. Si boolean file.exists (); existe.
3.File.mkdir (); ou file.mkDirs (); Créez un répertoire ou un répertoire à plusieurs niveaux.
4.File.isDirectory () détermine s'il s'agit d'un répertoire
file.isfile () détermine s'il s'agit d'un fichier.
5.File.Delete (); Supprimer le fichier ou le répertoire.
6.File.CreateEnewFile (); créer un nouveau fichier.
7.File.getName () obtient le nom de fichier ou le chemin absolu du répertoire.
8.File.getAbsoluTepath () obtient le chemin absolu.
9.File.getParent (); Obtenez le chemin absolu des parents.
1. Traverser le répertoire
Package com.study.io; Importer java.io.file; Importer java.io.ioexception; / *** Classe d'outils de fichiers * répertorie les opérations communes de la classe de fichiers, telles que: filtrage, traversée, etc. listDirectory(File dir) throws IOException{if(!dir.exists()){//exists() method is used to determine whether a file or directory has throw new IllegalArgumentException("Dir: "+dir+" does not exist");}if(!dir.isDirectory()){//isDirectory() method is used to determine whether the object of the File class is a directory throw new IllégalArgumentException (dir + "pas un répertoire");} / * string [] filenames = dir.list (); // list () La méthode est utilisée pour répertorier les sous-répertoires et les fichiers dans le répertoire actuel (c'est directement le nom de la sous-directory {System.out.println (String);} * /// Si vous souhaitez traverser le contenu dans le sous-répertoire, vous devez construire l'objet de fichier pour les opérations récursives. Le fichier fournit un apifile qui renvoie directement l'objet de fichier. listfiles = dir.listfiles (); // renvoie une abstraction du sous-répertoire direct (fichier) if (listfiles! = null && listfiles.length> 0) {for (fichier file: listfiles) {/*System.out.println(file) ;*/if listDirectory (fichier);} else {System.out.println (fichier);}}}}}} Classe de test:
classe publique FileUtilstest {public static void main (String [] args) lève ioException {fileUtils.listDirectory (nouveau fichier ("d: // iostudy"));}} Résultats en cours:
3. Utilisation de la classe RandomAccessFile
RandomAccessFile: Java donne accès au contenu des fichiers, qui peut être utilisé pour lire des fichiers ou écrire des fichiers.
RandomAccessFile prend en charge l'accès aléatoire aux fichiers et peut accéder à n'importe quel emplacement du fichier.
Remarque le modèle de fichier Java:
Résultats en cours:
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)
Les flux IO peuvent être divisés en flux d'entrée et en flux de sortie.
Ici, il peut être divisé en flux d'octets et en flux de caractères.
Exemple de code:
package com.study.io; import java.io.bufferedInputStream; importer java.io.bufferedoutputStream; import java.io.file; import java.io.fileInputStream; import java.io.fileoutputStream; import java.io.ioException; / *** io outils class * ❤ ❤ ❤ ❤ ❤ ❤ ❤ ❤ ❤ ❤ ❤file Entrée et stream de sortie: Données sur les fichiers * FileOutputStream -> Implémentation de la méthode d'écriture des données d'octets dans les fichiers * ❤Data Entrée et flux Stream: * DataOutStream / DatainputStream: Extension de la fonction "Stream", vous pouvez lire Int, long, caractères et autres types de données plus int, long et autres types * DataoutStream WriteInt BufferedOutputStream * Ces deux bits de classe de flux IO fournissent des opérations avec des tampons. Généralement, lors de l'ouverture d'un fichier pour les opérations d'écriture ou de lecture, une mise en mémoire tampon sera ajoutée. Ce mode de flux améliore les performances de IO * par exemple: mettre les entrées dans un fichier d'une application équivaut à verser un cylindre d'eau dans un autre cylindre: FileOutputStream ---> write () est équivalent à "transfert" de l'eau sur DataOutputStream -> writexxx () Méthode est plus pratique, équivalente à "transférer l'aquare Scoop dans le seau en premier (c'est-à-dire la zone tampon), puis la verser dans un autre cylindre du seau. Les performances sont améliorées * / public classe Ioutil {/ *** Lisez le contenu du fichier spécifié et le publiez sur la console en hexadécimal * et toutes les fichiers de 10 octets * @param nom de fichier * à un seul octet ne convient pas aux fichiers volumineux, et les fichiers volumineux sont très inefficaces * / public static natic Printhex (nom de filent de file) lance ioexception {// opérate le fichier de putain de putain de by) ioexception {// opération du fichier de by atem) throws ioexception œuvre {// opération du fichier de by atem) throws ioexception œuvre {// opération dans le fichier de putain de put dans = new FileInputStream (nom de fichier); int b; int i = 1; while ((b = in.read ())! = - 1) {/ * 0xff est remplacé par un système à 2 chiffres, ce qui signifie 8 1s. De cette façon, les 8 bits inférieurs du personnage sont réellement pris. * L'OXF est de 15 ans. Les nombres de moins de 15 seront convertis en nombre hexadécimal. * Votre code espère être deux nombres hexadécimaux fixes, donc quand un seul est généré, vous devez ajouter 0 * / if (b <= 0xf) {// Integer.tohexstring (b) avant que le numéro d'unité ne soit complété par 0System.out.print ("0");} // integer System.out.print (Integer.tohexString (b) + ""); if (i ++% 10 == 0) {System.out.println ();}} in.close (); // La lecture du fichier doit être fermée après la lecture et l'écriture} / *** La lecture par lots est efficace pour les grands fichiers et est également le moyen le plus utilisé pour lire les fichiers * @param filename * @throws ioException * / public static printhexbyby IoException {fileInputStream dans = new FileInputStream (nom de fichier); octet [] buf = new byte [8 * 1024]; / * Batch Read octets from in in in in in in in in in in in the octet back of Buf, * commencer à partir de la 0e position, et a mis à la plupart Buf.length * Le retour est le nombre d'octets lus * // * int bytes = in.read (buf, 0, buf.length); // lu en même temps, indiquant que le tableau d'octet est suffisamment grand int j = 1; pour (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 (bytestes = in.read(buf,0,buf.length))!=-1){for(int i = 0; i < bytes;i++){System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");/*** & 0xff:byte type 8 bits, int type 32 bits, in order to avoid data conversion errors, clear the high 24 bits by & 0xff * / if (j ++% 10 == 0) {System.out.println ();}}} dans.close ();} / *** Copie de fichier, Byte Batch Read * @param srcfile * @param destfile * @throws ioException * / public static Void CopyFile (fichier srcfile, fichier destfile) throw (! srcfile.exists ()) {lancer un nouveau illégalargumentException ("fichier:" + srcfile + "not exist");} if (! srcfile.sisfile ()) {lancez un nouveau fichier illégalException (srcfile + "pas un fichier");} fileInStream in = newinputStreamStream (srcfile); FileUtStream dans = new FileInputStream FileOutputStream (destFile); // Lorsque le fichier n'existe pas, il sera créé directement; S'il existe, supprimez-le et créez des octets [] buf = new octet [8 * 1024]; // lisant et écrivez int b; while ((b = in.read (buf, 0, buf.length))! = -1) {//read(buf,0,buf.length) La lecture avec les paramètres renvoie la longueur totale des octets; Lorsque tous sont lus, c'est -1; out.write (buf, 0, b); out.flush (); // Il est préférable d'ajouter} in.close (); out.close ();} / *** pour copier le fichier et utiliser le flux Byte tamponné * @param srcfile * @param destfile * @throws ioexception * / public static copyfilebuffer (file srcfile, file destfile) IoException {if (! Srcfile.exists ()) {lancez de nouveaux illégalargumentException ("fichier:" + srcfile + "not exist");} if (! Srcfile.isfile ()) {lancez new illégalargumentException (srcfile + "pas un fichier");} bubiteredInputStream bis = new BridgeredInStream (New FileInputStream (srcfile)); BufferedOutputStream bos = new BufferedOutputStream (new FileOutputStream (destFile)); int c; while ((c = bis.read ())! = - 1) {bos.write (c); bos.flush (); // Fresque le tampon} bis.close (); bos.close ();} buffering for file copy* @param srcFile* @param destFile* @throws IOException*/public static void copyFileByByte(File srcFile,File destFile)throws IOException{if(!srcFile.exists()){throw new IllegalArgumentException("File:"+srcFile+"Not exister ");} if (! srcfile.isfile ()) {Throw New illégalArgumentException (srcfile +" pas un fichier ");} fileInputStream in = new FileInputStream (srcfile); fileoutputStream out = new FileoutputStream (destfile); int c; while (c = in.read ()! = - 1); Les paramètres renvoient le contenu de l'octet de lecture; Lorsque toutes les lectures sont toutes retournées, c'est -1; out.write (c); out.flush ();} in.close (); out.close (); out.close ();}} Classe de test:
package com.study.io; import java.io.file; import java.io.ioexception; import org.junit.test; public classe ioutilTest {@TestPublic void testprinthex () {try {ioutil.printhex ("d: //javaio//fileutiles.java");} capture (ioexception e) {e.printStackTrace ();}} @ testpublic void testprinthexByTearray () {try {long start = System.currenttimemillis (); // la différence de horaire entre l'heure actuelle et minuit le 1er janvier 1970 (mesurée en millisecondes) //Ioutil.printhexbytearray("e://javaio//fileutils.java") ;//ioutil.printhex("e://javaio//1.mp3") ;ioutil.printhexbytearray. System.Currenttimemillis (); System.out.println (end - start);} catch (ioException e) {e.printStackTrace ();}} @ testpublic void testCopyFile () {try {ioutil.copyfile (nouveau fichier ("d: //javaio//1.txt"), new File ("d: //javaio//1copy.txt"));} catch (ioException e) {e.printStackTrace ();}} @ testpublic void testCopyFileBuffer () {try {long start = System.currenttimemillis (); / * ioutil.copyfilebyte (new Fichier ("e: //javaio//1.mp3"), nouveau fichier ("e: //javaio//2.mp3")); * // plus de 20 000 millisecondes / * ioutil.copyfilebybuffer (nouveau fichier ("e: //javaio//1.mp3"), nouveau fichier ("e: //javaio//3.mp3"); millisecondes * / ioutil.copyfile (nouveau fichier ("e: //javaio//1.mp3"), nouveau fichier ("e: //javaio//4.mp3")); // 7ms long = System.currenttimemilis (); system.out.println (end - start);} catch (ioException e) {e.printfrace ();} catch (ioException e) {E.printSack ();); }} 5. Stream de caractère
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 israndoswdemo {public static Main (string [] args) lance ioexception {Fidrein STATIC MAIN (String [] args) lance ioexception {Fidrein STATIC MAIN (String [] args) lance ioexception {Fidrey Void Main (String [] args) lance Ioexception {Fichier STATIC MAIN (String [] Args) lance Ioexception {Fichier STATIQUE EN = STRING [] Args) lance IoException {Fichier STATIQUE EN = NORME [STRING) FileInputStream ("e: //javaio//utf8.txt"); inputStreamReader ISR = new InputStreamReader (in "utf-8"); // Encoding du projet par défaut. Lorsque vous fonctionnez, vous devez écrire le format d'encodage du fichier lui-même. FileoutputStream out = new FileOutputStream ("e: //javaio//utf81.txt"); outputStreamWriter OSW = new OutputStreamWriter (out, "utf-8"); / * int c; while ((c = isr.read ())! = - 1) {system.out.print ((char) c);} * * / char [] buffer = new char [8 * 1024]; int c; / * lisant le lot, mettez le tableau des caractères de tampon, commencez à partir de la 0e position et placez le tampon.Length au maximum. Le nombre de caractères renvoyés est le nombre de caractères de lecture * / while ((c = isr.read (tampon, 0, tampon.length))! = - 1) {String s = new String (Buffer, 0, C); System.out.print (S); OSW.Write (Buffer, 0, C); OSW.Flush ();} Isr.Close (); OSW.Close (); OSW.Close ();}}File Read and Write Stream of Character Stream (FileReader / FileWriter)
Filtre pour les flux de caractères
6. sérialisation et désérialisation des objets
Exemple:
Avis: