Après le travail, la technologie utilisée évolue avec les évolutions du projet, parfois C#, parfois Java, et bien sûr quelques autres technologies fragmentées. Dans l'ensemble, C# prend plus de temps, suivi de Java. Je n'ai aucune préférence pour les langues. Une langue qui peut fonctionner est une bonne langue. Et d’un point de vue orienté objet, je pense qu’il n’y a pour moi aucune différence entre C# et Java.
Cet article passe principalement en revue le contenu lié aux opérations d'E/S en Java. Les E/S sont également une fonctionnalité de base des langages de programmation. Les E/S en Java sont divisées en deux types, l'une est à lecture séquentielle et l'autre est à lecture aléatoire.
Examinons d'abord la lecture séquentielle. Il existe deux façons d'effectuer une lecture séquentielle. L'une est InputStream/OutputStream, qui est un flux d'entrée et de sortie qui fonctionne sur les octets ; l'autre est Reader/Writer, qui fonctionne sur les caractères. flux de l’opération.
Ci-dessous, nous dessinons la structure de InputStream
FileInputStream : exploite des fichiers, souvent utilisés avec BufferedInputStream
PipedInputStream : peut être utilisé pour la communication inter-thread
ObjectInputStream : peut être utilisé pour la sérialisation d'objets
ByteArrayInputStream : utilisé pour traiter l'entrée de tableaux d'octets
LineNumberInputStream : peut afficher le numéro de ligne actuel et peut être modifié dans le programme
Voici la structure de OutputStream
PrintStream : fournit des interfaces similaires à print et println pour produire des données
Voyons comment utiliser Stream pour gérer les entrées et les sorties.
Lire des fichiers à l'aide d'InputStream
Copiez le code comme suit :
Utilisez FileInputStream pour lire les informations sur le fichier
public static byte[] readFileByFileInputStream (fichier fichier) lance IOException
{
Sortie ByteArrayOutputStream = new ByteArrayOutputStream();
FileInputStream fis = null ;
essayer
{
fis = nouveau FileInputStream(fichier);
octet[] tampon = nouvel octet[1024];
int octetsRead = 0 ;
while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
{
sortie.write(buffer, 0, bytesRead);
}
}
attraper (exception ex)
{
System.out.println("Une erreur se produit lors de la lecture " + file.getAbsoluteFile());
}
enfin
{
if (fis !=null) fis.close();
if (output !=null) sortie.close();
}
retourner la sortie.toByteArray();
}
Lecture de fichiers à l'aide de BufferedInputStream
Copiez le code comme suit :
public static byte[] readFileByBufferedInputStream (fichier fichier) lève une exception
{
FileInputStream fis = null ;
BufferedInputStream bis = null ;
Sortie ByteArrayOutputStream = new ByteArrayOutputStream();
essayer
{
fis = nouveau FileInputStream(fichier);
bis = nouveau BufferedInputStream(fis);
octet[] tampon = nouvel octet[1024];
int octetsRead = 0 ;
while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
{
sortie.write(buffer, 0, bytesRead);
}
}
attraper (exception ex)
{
System.out.println("Une erreur se produit lors de la lecture " + file.getAbsoluteFile());
}
enfin
{
if (fis != null) fis.close();
if (bis != null) bis.close();
if (output != null) sortie.close();
}
return output.toByteArray();
}
Copier des fichiers à l'aide de OutputStream
Copiez le code comme suit :
Copier des fichiers à l'aide de FileOutputStream
public static void copyFileByFileOutputStream (fichier fichier) lance IOException
{
FileInputStream fis = null ;
FileOutputStream fos = null ;
essayer
{
fis = nouveau FileInputStream(fichier);
fos = new FileOutputStream(file.getName() + ".bak");
octet[] tampon = nouvel octet[1024];
int octetsRead = 0 ;
while((bytesRead = fis.read(buffer,0,buffer.length)) != -1)
{
fos.write(buffer, 0, bytesRead);
}
fos.flush();
}
attraper (exception ex)
{
System.out.println("Une erreur se produit lors de la copie " + file.getAbsoluteFile());
}
enfin
{
if (fis != null) fis.close();
if (fos != null) fos.close();
}
}
Copiez le code comme suit :
Copier des fichiers à l'aide de BufferedOutputStream
public static void copyFilebyBufferedOutputStream (fichier fichier) lance IOException
{
FileInputStream fis = null ;
BufferedInputStream bis = null ;
FileOutputStream fos = null ;
BufferedOutputStream bos = null ;
essayer
{
fis = nouveau FileInputStream(fichier);
bis = nouveau BufferedInputStream(fis);
fos = new FileOutputStream(file.getName() + ".bak");
bos = nouveau BufferedOutputStream(fos);
octet[] tampon = nouvel octet[1024];
int octetsRead = 0 ;
while((bytesRead = bis.read(buffer, 0, buffer.length)) != -1)
{
bos.write(buffer, 0, bytesRead);
}
bos.flush();
}
attraper (exception ex)
{
System.out.println("Une erreur se produit lors de la copie " + file.getAbsoluteFile());
}
enfin
{
if (fis != null) fis.close();
if (bis != null) bis.close();
if (fos != null) fos.close();
if (bos != null) bos.close();
}
}
Le code ici gère les exceptions de manière très incomplète. Nous donnerons un code complet et rigoureux plus tard.
Jetons un coup d'œil à la structure de Reader
Le Reader correspond ici essentiellement au InputStream.
La structure de Writer est la suivante
Regardons quelques exemples d'utilisation de Reader ou Writer
Utiliser Reader pour lire le contenu du fichier
Copiez le code comme suit :
Utilisez BufferedReader pour lire le contenu du fichier
public static String readFile (String file) lance IOException
{
BufferedReader br = null ;
StringBuffer sb = new StringBuffer();
essayer
{
br = nouveau BufferedReader (nouveau FileReader (fichier));
Ligne de chaîne = null ;
while((line = br.readLine()) != null)
{
sb.append(ligne);
}
}
attraper (exception ex)
{
System.out.println("Une erreur se produit lors de la lecture de " + fichier);
}
enfin
{
if (br != null) br.close();
}
return sb.toString();
}
Copier des fichiers à l'aide de Writer
Copiez le code comme suit :
Copier des fichiers à l'aide de BufferedWriter
public static void copyFile (fichier de chaîne) lance IOException
{
BufferedReader br = null ;
BufferedWriter p.c. = null ;
essayer
{
br = nouveau BufferedReader (nouveau FileReader (fichier));
bw = new BufferedWriter(new FileWriter(file + ".bak"));
Ligne de chaîne = null ;
while((line = br.readLine())!= null)
{
bw.write(ligne);
}
}
attraper (exception ex)
{
System.out.println("Une erreur se produit lors de la copie de " + fichier);
}
enfin
{
if (br != null) br.close();
if (bw != null) bw.close();
}
}
Voyons comment effectuer un accès aléatoire aux fichiers. RandomAccessFile est principalement utilisé en Java pour effectuer des opérations aléatoires sur les fichiers.
Créer un fichier de taille fixe
Copiez le code comme suit :
Créer des fichiers de taille fixe
public static void createFile (fichier de chaîne, taille int) lance IOException
{
Fichier temp = nouveau fichier (fichier);
RandomAccessFile raf = new RandomAccessFile(temp, "rw");
raf.setLength(taille);
raf.close();
}
Écrire des données aléatoires dans un fichier
Copiez le code comme suit :
Insérer des données aléatoires dans un fichier
public static void writeFile (String file, byte[] content, int startPos, int contentLength) lance IOException
{
RandomAccessFile raf = nouveau RandomAccessFile (nouveau fichier (fichier), "rw");
raf.seek(startPos);
raf.write(content, 0, contentLength);
raf.close();
}
Examinons ensuite quelques autres opérations courantes
Déplacer des fichiers
Copiez le code comme suit :
Déplacer des fichiers
public statique booléen moveFile (String sourceFile, String destFile)
{
Source du fichier = nouveau fichier (fichier source);
if (!source.exists()) throw new RuntimeException("le fichier source n'existe pas.");
Fichier dest = nouveau fichier (destFile);
if (!(new File(dest.getPath()).exists())) new File(dest.getParent()).mkdirs();
return source.renameTo(dest);
}
Copier des fichiers
Copiez le code comme suit :
Copier des fichiers
public static void copyFile (String sourceFile, String destFile) lance IOException
{
Source du fichier = nouveau fichier (fichier source);
if (!source.exists()) throw new RuntimeException("Le fichier n'existe pas.");
if (!source.isFile()) throw new RuntimeException("Ce n'est pas un fichier.");
if (!source.canRead()) throw new RuntimeException("Le fichier ne peut pas être lu.");
Fichier dest = nouveau fichier (destFile);
si (dest.exists())
{
if (dest.isDirectory()) throw new RuntimeException("La destination est un dossier.");
autre
{
dest.delete();
}
}
autre
{
Fichier parentFolder = new File(dest.getParent());
if (!parentFolder.exists()) parentFolder.mkdirs();
if (!parentFolder.canWrite()) throw new RuntimeException("La destination ne peut pas être écrite.");
}
FileInputStream fis = null ;
FileOutputStream fos = null ;
essayer
{
fis = nouveau FileInputStream(source);
fos = nouveau FileOutputStream(dest);
octet[] tampon = nouvel octet[1024];
int octetsRead = 0 ;
while((bytesRead = fis.read(buffer, 0, buffer.length)) != -1)
{
fos.write(buffer, 0, bytesRead);
}
fos.flush();
}
capture (IOException ex)
{
System.out.println("Une erreur se produit lors de la copie " + sourceFile);
}
enfin
{
if (fis != null) fis.close();
if (fos != null) fos.close();
}
}
copier le dossier
Copiez le code comme suit :
copier le dossier
public static void copyDir (String sourceDir, String destDir) lance IOException
{
Source du fichier = nouveau fichier (sourceDir);
if (!source.exists()) throw new RuntimeException("La source n'existe pas.");
if (!source.canRead()) throw new RuntimeException("La source n'a pas pu être lue.");
Fichier dest = nouveau fichier (destDir);
if (!dest.exists()) dest.mkdirs();
Fichier[] arrFiles = source.listFiles();
pour (int i = 0; i < arrFiles.length; i++)
{
si (arrFiles[i].isFile())
{
Lecteur BufferedReader = new BufferedReader(new FileReader(arrFiles[i]));
BufferedWriterwriter = new BufferedWriter(new FileWriter(destDir + "/" + arrFiles[i].getName()));
Ligne de chaîne = null ;
while((line = reader.readLine()) != null)writer.write(line);
écrivain.flush();
lecteur.close();
écrivain.close();
}
autre
{
copyDir(sourceDir + "/" + arrFiles[i].getName(), destDir + "/" + arrFiles[i].getName());
}
}
}
supprimer le dossier
Copiez le code comme suit :
supprimer le dossier
public static void del (String filePath)
{
Fichier fichier = nouveau fichier (filePath);
if (file == null || !file.exists()) return;
si (fichier.isFile())
{
fichier.delete();
}
autre
{
Fichier[] arrFiles = fichier.listFiles();
si (arrFiles.length > 0)
{
pour (int i = 0; i < arrFiles.length; i++)
{
del(arrFiles[i].getAbsolutePath());
}
}
fichier.delete();
}
}
Obtenir la taille du dossier
Copiez le code comme suit :
Obtenir la taille du dossier
public statique long getFolderSize (répertoire de chaîne)
{
taille longue = 0 ;
Fichier fichier = nouveau fichier (rép);
if (!file.exists()) throw new RuntimeException("le répertoire n'existe pas.");
if (file.isFile()) return file.length();
autre
{
String[] arrFileName = fichier.list();
pour (int i = 0; i < arrFileName.length; i++)
{
size += getFolderSize(dir + "/" + arrFileName[i]);
}
}
taille de retour ;
}
Diviser les gros fichiers en plusieurs petits fichiers
Copiez le code comme suit :
Divisez les gros fichiers en plusieurs fichiers plus petits
public static void splitFile (String filePath, unité longue) lance IOException
{
Fichier fichier = nouveau fichier (filePath);
if (!file.exists()) throw new RuntimeException("le fichier n'existe pas.");
taille longue = fichier.length();
if (unité >= taille) return ;
int count = taille % unité == 0 ? (int)(taille/unité) : (int)(taille/unité) + 1;
Chaîne newFile = null ;
FileOutputStream fos = null ;
FileInputStream fis =null ;
octet[] tampon = nouvel octet[(int)unité];
fis = nouveau FileInputStream(fichier);
débutPos long = 0 ;
Chaîne countFile = filePath + "_Count" ;
PrintWriterwriter = new PrintWriter(new FileWriter( new File(countFile)));
écrivain.println(filePath + "/t" + taille);
pour (int i = 1; i <= count; i++)
{
nouveauFichier = cheminfichier + "_" + i ;
startPos = (i - 1) * unité ;
System.out.println("Création " + newFile);
fos = nouveau FileOutputStream (nouveau fichier (nouveau fichier));
int bytesRead = fis.read(buffer, 0, buffer.length);
si (octetsRead != -1)
{
fos.write(buffer, 0, bytesRead);
writer.println(newFile + "/t" + startPos + "/t" + bytesRead);
}
fos.flush();
fos.close();
System.out.println("StartPos:" + i*unit + "; EndPos:" + (i*unit + bytesRead));
}
écrivain.flush();
écrivain.close();
fis.close();
}
Fusionner plusieurs petits fichiers en un seul gros fichier
Copiez le code comme suit :
Fusionner plusieurs petits fichiers en un seul gros fichier
public static void linkFiles (String countFile) lance IOException
{
Fichier fichier = nouveau fichier (countFile);
if (!file.exists()) throw new RuntimeException("Le fichier de comptage n'existe pas.");
Lecteur BufferedReader = nouveau BufferedReader (nouveau FileReader (fichier));
Ligne de chaîne = reader.readLine();
String newFile = line.split("/t")[0];
taille longue = Long.parseLong(line.split("/t")[1]);
RandomAccessFile raf = new RandomAccessFile(newFile, "rw");
raf.setLength(taille);
FileInputStream fis = null ;
octet[] tampon = null ;
while((line = reader.readLine()) != null)
{
String[] arrInfo = line.split("/t");
fis = nouveau FileInputStream(nouveau fichier(arrInfo[0]));
buffer = nouvel octet[Integer.parseInt(arrInfo[2])];
long startPos = Long.parseLong(arrInfo[1]);
fis.read(buffer, 0, Integer.parseInt(arrInfo[2]));
raf.seek(startPos);
raf.write(buffer, 0, Integer.parseInt(arrInfo[2]));
fis.close();
}
raf.close();
}
Exécuter une commande externe
Copiez le code comme suit :
Exécuter une commande externe
public static void execExternalCommand (commande String, argument String)
{
Processus de processus = nul ;
essayer
{
process = Runtime.getRuntime().exec(commande + " " + argument);
InputStream est = process.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
Ligne de chaîne = null ;
while((line = br.readLine()) != null)
{
System.out.println(ligne);
}
}
attraper (exception ex)
{
System.err.println(ex.getMessage());
}
enfin
{
if (processus != null) process.destroy();
}
}
