Java Implémentation multithread pour télécharger des images et les compresser

Récemment, je fais une exigence: téléchargez le fichier stockant l'URL de l'image à partir du répertoire FTP d'autres systèmes, puis lisez l'adresse URL dans le fichier, téléchargez l'image en fonction de l'adresse et compressez-la dans un package en une journée. En moyenne, un fichier d'adresse contient environ 4 000 adresses. C'est-à-dire qu'après avoir scanné un fichier, vous devez télécharger environ 4 000 images, puis la compresser. Le suivant enregistre ma méthode d'implémentation et mon processus d'optimisation. Si vous avez de meilleures façons, vous pouvez le partager.

Cadre utilisé: Springmvc

Implémentation de la tâche chronométrée: hériter org.springframework.scheduling.quartz.quartzjobbean;

Je ne parlerai pas de la construction de l'environnement FTP. Je l'ai enregistré dans d'autres blogs que j'utilise le service FTP construit par CentOS dans la machine virtuelle pour créer un compte FTP et un répertoire correspondant, et télécharger le fichier d'adresse d'image qui doit être téléchargé à l'avance. Format de contenu de fichier "ID d'image || Adresse d'image".

Méthode 1. Le moyen le plus simple de l'implémenter est de télécharger d'abord le fichier qui stocke l'adresse URL de l'image, puis de lire le fichier Traversal l'adresse d'image, ajuster la méthode d'image téléchargée pour stocker l'image localement et enfin compresser l'image téléchargée. Une fois terminé, supprimez l'image téléchargée et conservez uniquement le package compressé.

 La classe publique PictureTransferJob étend QuartzJobbean {Protected void executeInternal (JobExEcutionContext Arg0) lève JobExECUTUCTION {// La configuration FTP réelle est obtenue en lisant le fichier de configuration // FTP Address String hostname = "192.168.1.112"; // FTP Port int port = 2001; / FTP Compte String username = "test1"; // FTP Password String Password = "Test1"; // FTP File Storage Directory String ftpdowload = "/"; // le chemin de stockage local du chemin de chaîne de fichiers = this.getClass (). GetResource ("/"). GetPath (); // la chaîne de stockage de fichiers d'adresse d'image addRpath = path.substring (1, path.indexof ("web-inf / classes")) + "picAddr"; // La chaîne répertoire du répertoire de stockage d'image téléchargé picPath = path.substring (1, path.indexof ("web-inf / classes")) + "pic"; addRpath = addRpath.replace ("% 20", ""); picPath = picPath.replace ("% 20", ""); essayez {// Créer le fichier CreatFile (addRPath); // Créer le fichier CreatFile (picPath); String oldaddrpath = addRPath; String oldpicPath = picPath; // Créez la connexion FTP FTPULIL2 FTPUTIL2 = new FTUTIL2 (nom d'hôte, port, nom d'utilisateur, mot de passe, ftpDowload, true); // transfère le fichier dans la chaîne de répertoire FTP [] files = ftputil2.listAllFiles (); // La base de données locale aura un enregistrement de table des fichiers téléchargés. Ici, nous interrogerons la base de données et les noms de fichiers répertoriés dans FTP. Si les fichiers téléchargés ne seront pas téléchargés et évitez les téléchargements répétés. // Le processus de comparaison est omis ci-dessous, boucle le tableau des fichiers et créez le fichier localement pour (int i = 0; i <files.length; i ++) {CreatFile (addRpath + file.separator + filename); // FTPDowload est l'adresse du serveur FTP pour stocker le fichier, AddRpath est l'adresse du fichier de stockage local // Voici un état de retour pour déterminer si le fichier est téléchargé avec succès booléen téléchargement en Addrpath); // Une méthode pour lire le fichier après le téléchargement du fichier avec succès, et l'adresse d'image à télécharger est stockée dans le conteneur Boolean EntityState = SetPictureTeTail (addRPath, picPath, filenamedate); }} catch (exception e) {e.printStackTrace (); // Cliquez sur la classe professionnelle qui enregistre le journal des erreurs pour envoyer des messages texte qui téléchargent les erreurs de fichier}} // Commencez à lire l'adresse d'image ici privé Boolean SetPictureTeTail (String addRpath, String picPath, String Syndate) { System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- String row; Int Count = 0; Addrmap.put (colonne [0] .trim (), colonnes [1] .trim ());} Catch (exception E) {e.printStackTrace (); System.out.println (new Date ()); System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- E.PrintStackTrace (); PicAddr = Null; File Pic = Null; Byte Array via InputStream et perdra des données, ce qui entraîne des images incomplètes. Byte Array, et après avoir lu, les données dans le flux sont effacées PIC = NOUVEAU (PICHPATH + FILENDE + ". JPG"); is.close ();} Retourne True;} Catch (exception e) {e.PrintStackTrace (); zippic (picPath, syncdate, addrmap); {// pause dans la liste des fichiers qui doivent être compressés et le nom de fichier compressé ziputil.zipbystream (piclist, nouveau fichier (picpath + syndate + ". zip")); if (! file.exists ()) {file.mkDirs ();

Méthode 2: téléchargement multi-thread, compression directe des flux

Méthode 1 Bien que les fonctions de base soient implémentées, car il y a trop d'images qui doivent être téléchargées, et comprimer des fichiers d'image locaux et supprimer des images sont également longs, il y a donc deux endroits où vous pouvez optimiser la vitesse. L'un consiste à améliorer l'efficacité du téléchargement des images, et l'autre est d'améliorer l'efficacité de la compression.

La méthode pour améliorer l'efficacité du téléchargement peut utiliser des téléchargements multiples, et la méthode pour améliorer l'efficacité de compression peut compresser directement le flux de fichiers sans enregistrer l'image localement.

Méthode d'implémentation multi-threading: Tout d'abord, nous enregistrons la liste d'adresses des fichiers qui doivent être téléchargés. Si nous voulons utiliser le multi-lancement pour télécharger, nous devons nous assurer que les images téléchargées par différents threads ne seront pas répétées. Par conséquent, un drapeau est nécessaire pour les distinguer. Pour le moment, nous pouvons utiliser un compteur d'index pour les diviser en fonction d'une certaine quantité d'images téléchargées par chaque fil. À partir de 0, toutes les 400 images, nous pouvons utiliser un fil pour télécharger à chaque fois, afin que nous puissions déterminer le nombre de threads nécessaires, et les images téléchargées par chaque fil ne seront pas répétées.

Méthode d'implémentation des fichiers compressés: parce que l'essence de la génération de fichiers compressés est de lire le flux de fichiers qui doit être compressé, puis de générer un package compressé, nous pouvons utiliser le conteneur pour stocker les données de flux d'image téléchargées par tous les threads au lieu de créer le fichier d'image téléchargé, puis transmettre les données de flux à la classe d'outils de compression pour la compresser directement. Cela omet le processus fastidieux de lire le fichier image pour créer le flux, puis générer le package compressé, puis supprimer le fichier image local.

Les principales implémentations de la transformation sont répertoriées ci-dessous:

 / ** * Compressez les images téléchargées par jour * @throws ioException * / private booléen zippic (String picPath, String Syndate, Map <String, String> addrmap) lance ioException {// Puisqu'il s'agit d'un flux d'image de stockage multipre ConcurrentHashMap <String, InputStream> (); // Le nombre d'images téléchargées par chaque thread est définie ici int count = 400; // Stockage L'adresse d'image qui doit être téléchargée Liste <entrée <String, String >> addrlist = new ArrayList <entrée <string, string >> (addrmap.entryset ()); // le nombre de threads, ajoutez-en un parce que vous souhaitez créer un thread pour télécharger le dernier moins de 400 images int nThreads = (addrlist.size () / count) +1; // CountdownLatch CountdownLatch = new CountdownLatch (nThreads); essayez {boolean downpic = false; // Exécuter Multithread Télécharger des images DownPic = DownPic (PicPath, Addrlist, PicList, PictureList, Nthreads, Count); if (downpic) {ziputil.zipbyArray (picList, nouveau fichier (picPath + syncate + ". zip")); } return true; } catch (exception e) {e.printStackTrace (); retourne false; }}

Voici la création d'une piscine de fil

 / ** * Téléchargez l'image en fonction de l'adresse URL * @throws interruptedException * / private boolean downpic (String picpath, liste <entrée <string, string >> addrlist, map <string, byte []> piclist, map <string, inputStream> pictureLlist, exécutorarse ThreadPool = exécuteurs.NewFixEdThreadpool (nThreads); // Créer deux compteurs CountdownLatch begin = new CountdownLatch (0); COUNTDOWNLATCH END = NOUVEAU COUNTDOWNLATCH (NTHARDS); // Loop Create Thread pour (int i = 0; i <nthreads; i ++) {list <entrée <string, string >> subaddrList = null; // Calculez les données exécutées par chaque thread if ((i + 1) == nthreads) {int startIndex = (i * count); int endIndex = addrlist.size (); subaddrlist = addrlist.sublist (startIndex, endIndex); } else {int startIndex = (i * count); int endIndex = (i + 1) * count; subaddrlist = addrlist.sublist (startIndex, endIndex); } // classe de thread picdownload myhead = new picDownload (picPath, subaddrlist, picList, pictureList); // La façon d'exécuter des threads ici est d'appeler la méthode threadpool.exécute (Myhead) dans le pool de threads. essayez {threadpool.execute (myhead); } catch (exception e) {// enregistrer le journal des erreurs return false; }} begin.countDown (); end.Await (); // Fermez le thread Pool Threadpool.shutdown (); // Ici, vous devez boucler jusqu'à ce que tous les threads de la piscine de fil se terminent avant de descendre. En raison de cette étape pendant le test, le thread enfant a téléchargé l'image mais n'a pas terminé, et le thread principal a baissé, ce qui n'a résulté en aucune image dans le package compressé // Vous pouvez également utiliser CountdownLatch pour implémenter / * while (true) {if (threadpool.isterMined ()) {System.out.println ("Tous les fils d'enfants ont fini!"); casser; }} * / return true; }

Ce qui suit est la mise en œuvre du thread

 Class PicDowload implémente Runnable {// Télécharger la liste d'adresses de la liste des images <entrée <string, string >> addrlist; // Chargez la liste des images Map téléchargées avec succès <String, byte []> picList; Map <string, inputStream> pictureList; // le chemin de stockage local de la chaîne d'images PicPath; CountdownLatch commence, fin; public picdownload (String picPath, list <entrée <string, string >> addrlist, map <string, inputStream> picList, CountdownLatch begin, comptdownlatch end) {this.addrlist = addrlist; this.picList = picList; this.picPath = picPath; this.begin = begin; this.end = end; } @Override public void run () {try {System.out.println (thread.currentThread (). GetName () + "------" + thread.currentThread (). GetId ()); DownPicture (addrlist); //System.out.println (CountdownLatch.getCount ()); begin.Await (); } catch (exception e) {e.printStackTrace (); } enfin {end.CountDown (); //countDownLatch.CountDown (); }} public boolean downPicture (list <entrée <string, string >> addrlist) lève exception {inputStream is = null; FileoutputStream fos = null; Url url = null; String filename = null; String picaddr = null; Fichier pic = null; try {for (map.entry <string, string> addRentry: addrlist) {filename = addRentry.getKey (); picaddr = addRentry.getValue (); // Créer l'URL Object URL = nouvelle URL (PICADDR); is = url.openStream (); // Le flux obtenu par URLConnection sera écrit directement dans le tableau d'octets via InputStream et perdra des données, ce qui entraînera des images téléchargées incomplètes. Utilisez org.apache.commons.io.ioutils.tobytearray (urlconnection.openStream ()) pour résoudre // byte [] bytes = ioutils.tobytearray (is); // Nouveau octet [is.available ()]; Les octets obtenus // Les données du flux sont lues dans le réseau d'octets. Après avoir lu, les données du flux sont effacées picList.put (nom de fichier + ". Jpg", IS); // Pour le moment, comme le flux n'est pas écrit dans le fichier, le flux ne doit pas être fermé, sinon les données du flux seront perdues //is.close (); } return true; } catch (exception e) {e.printStackTrace (); retourne false; } Enfin {// Le flux ne peut pas être fermé / * if (null! = is) {is.close (); } * /}}}

J'ai rencontré un autre problème en utilisant des flux de compression ci-dessus. Lors de la compression du fichier, java.net.socketException: réinitialisation de la connexion
Après avoir analysé la raison, il devrait être que le flux InputStream et UrlConnection sont dans l'état de connexion, et le délai de délai d'UrlConnection fait échouer le flux d'entrée.

J'ai essayé de définir l'heure du délai d'expiration de l'URLConnection, mais pendant le test, j'ai constaté que la vitesse du réseau du téléchargement d'image reçu était grandement affectée. Cette méthode est très instable et indésirable. En fin de compte, j'ai seulement abandonné l'utilisation du flux et utilisé un tableau d'octets pour le transmettre à la classe d'outils de compression, puis j'ai converti le tableau d'octets en compression de flux.

 / ** * Utilisez le conteneur pour stocker le tableau d'octets d'image téléchargé * / public booléen downpicture (list <entrée <string, string >> addrlist) lève exception {inputStream is = null; FileoutputStream fos = null; Url url = null; String filename = null; String picaddr = null; Fichier pic = null; try {for (map.entry <string, string> addRentry: addrlist) {filename = addRentry.getKey (); picaddr = addRentry.getValue (); // Créer l'URL Object URL = nouvelle URL (PICADDR); // Ouvrez la connexion et créez l'objet java.net.urlconnection. Cet objet n'a pas de méthode pour fermer la connexion. Il peut être converti à sa sous-classe httpurlconnection pour appeler la méthode de déconnexion pour fermer la connexion. //java.net.urlconnection et java.net.httpurlConnection les deux méthodes de délai de définition pour fermer la connexion // httpurlconnection uc = (httpurlconnection) url.openconnection (); is = uc.getInputStream (); // Le flux obtenu par URLConnection sera écrit directement dans le tableau d'octets via InputStream et perdra des données, ce qui entraînera des images téléchargées incomplètes. Utiliser org.apache.commons.io.ioutils.tobytearray (urlconnection.openStream ()) pour résoudre les octets [] bytes = ioutils.tobytearray (is); // new octet [is.available ()]; Les données BYTE // obtenues dans le flux sont lues dans le réseau d'octets. Après avoir lu, les données du flux sont effacées //is.read(Bytes); picList.put (nom de fichier + ". jpg", octets); is.close (); } return true; } catch (exception e) {e.printStackTrace (); retourne false; } enfin {if (null! = is) {is.close (); }}}

Résumer:

Problèmes rencontrés lors de la mise en œuvre:

1. Lors de l'utilisation du pool de threads, pour l'état partagé, par exemple, le conteneur de données d'octet d'image stocké ici est partagé par tous les threads, donc un conteneur synchronisé est requis, sinon il entraînera des problèmes avec les données stockées. Par conséquent, concurrenthashmap <string, byte []> est utilisé.
2. Il y a un problème avec l'ordre d'exécution du thread principal et du fil d'enfant ici, car le thread principal doit attendre que tous les threads du pool de threads terminent le téléchargement des images avant de descendre pour compresser les images. Si le thread principal n'attend pas que le thread enfant se termine et exécute la méthode de compression vers le bas, il conduira à des images manquantes ou non compressées. Par conséquent, vous pouvez utiliser CountdownLatch pour l'implémenter, ou utiliser une boucle morte pour vérifier Threadpool.isterMined () sous l'instruction de pool de filetage de clôture pour continuer à exécuter le thread principal pour comprimer l'image.
3. Étant donné que le flux d'entrée obtenu par URLConnection est directement transmis à la classe compressée pour la compression, il y a une situation où le délai de connexion se réinitialise, donc à la place, le flux téléchargé est stocké dans un tableau d'octets, puis transmis à la classe compressée pour compresser pour éviter des situations inattendues lors de l'utilisation du flux.
4. Après avoir utilisé URLConnection.OpenStream () pour obtenir le flux d'entrée, l'image que vous avez convertie en un tableau d'octets à télécharger est incomplète. . Il peut être résolu en utilisant org.apache.commons.io.ioutils.tobytearray (urlconnection.openStream ()). Pour plus de détails, vous pouvez lire le code source pour afficher l'implémentation.

Ce qui suit est la mise en œuvre de la classe d'outils FTP:

 Importer java.io.BufferedInputStream; Importer java.io.BufferedOutputStream; import java.io.fileInputStream; Importer java.io.fileOutputStream; Importer java.io.ioException; import org.apache.commons.net.ftp.ftpclient; import org.apache.commons.net.ftp.ftpClientConfig; import org.apache.commons.net.ftp.ftpconnectionClosedException; import org.apache.commons.net.ftp.ftpreply; classe publique ftpUtil2 {private ftpClient ftpClient = null; // Adresse du serveur FTP Nom de chaîne privée; // Port par défaut du serveur FTP public static int defaultport = 21; // Nom de connexion Nom d'utilisateur de chaîne privée; // Connexion mot de passe de mot de passe de chaîne privée; // Répertoire distant pour accéder à la chaîne privée Remotedir; / ** * @param hostname * Adresse hôte * @param port * numéro de port * @param nom d'utilisateur * nom d'utilisateur * @param mot de passe * mot de passe * @param remotedir * répertoire de travail par défaut * @param is_zhtimezone * s'il s'agit du côté serveur chinois * @return * @return * / / ** * new * / public ftputil2 () {proPonfig Configy PropConfig.LoadConfig ("System.Properties"); String hostname = config.getConfig ("ftpaddress"); String port = config.getConfig ("ftpport"); String username = config.getConfig ("ftpusername"); String mot de passe = config.getConfig ("ftppassword"); String RemoteDir = config.getConfig ("RemoteFilePath"); booléen is_zhtimezone = true; this.hostname = hostname; this.userName = nom d'utilisateur; this.password = mot de passe; this.Remotedir = Remotedir == null? "": Remotedir; this.ftpclient = new ftpClient (); if (is_zhtimeZone) {this.ftpclient.configure (ftputil2.config ()); this.ftpclient.setControleCcoding ("gbk"); } // Se connecter(); // change le répertoire this.changedir (this.remotedir); this.setFileType (ftpclient.binary_file_type); ftpClient.setDefaultPort (Integer.ParseInt (port)); } public ftpUtil2 (String hostname, int port, nom d'utilisateur de chaîne, mot de passe de chaîne, chaîne Remotedir, boolean is_zhtimezone) {this.hostname = hostname; this.userName = nom d'utilisateur; this.password = mot de passe; defaultport = port; this.Remotedir = Remotedir == null? "": Remotedir; this.ftpclient = new ftpClient (); if (is_zhtimeZone) {this.ftpclient.configure (ftputil2.config ()); this.ftpclient.setControleCcoding ("gbk"); } // Connectez-vous à this.login (); // change le répertoire this.changedir (this.remotedir); this.setFileType (ftpclient.ascii_file_type); ftpClient.setDefaultPort (port); } / ** * Connectez-vous au serveur FTP * / public booléen login () {booléen Success = false; essayez {ftpclient.connect (this.hostname, defaultport); ftpClient.login (this.userName, this.password); int réponse; Répondre = ftpClient.getReplyCode (); if (! ftpreply.ispositivecompletion (réponse)) {ftpclient.disconnect (); retourner le succès; }} catch (ftpConnectionClosedException e) {// TODO Block de catch généré automatique e.printStackTrace (); } catch (ioException e) {// TODO Bloc de capture généré automatiquement e.printStackTrace (); } Success = true; System.out.println ("Connecter au serveur FTP:" + this.hostname + "Success..start Login"); retourner le succès; } private static ftpClientConfig config () {ftpClientConfig conf = new ftpClientConfig (ftpclientconfig.syst_unix); conf.setRecentDateFormatStr ("mm mois dd dd hh: mm"); // conf.setRecentDateFormatStr ("(Yyyyy Year)? MM MOIND DD DATE (HH: MM)?"); Retour conf; } / ** * Changer le répertoire de travail * * @param RemoTedir * * / public void changolir (String Remotedir) {try {this.remotedir = remotedir; ftpClient.changeworkingDirectory (Remotedir); } catch (ioException e) {// TODO Bloc de capture généré automatiquement e.printStackTrace (); } System.out.println ("Modifier le répertoire de travail en:" + Remotedir); } / ** * Retour au répertoire de niveau précédent (répertoire parent) * / public void toparentDir () {try {ftpclient.changetOparentDirectory (); } catch (ioException e) {// TODO Bloc de capture généré automatiquement e.printStackTrace (); }} / ** * Réservez tous les fichiers dans le répertoire de travail actuel * / String public [] ListAllFiles () {String [] noms = this.listFiles ("*"); retourner this.sort (noms); } / ** * Liste des fichiers correspondants dans le répertoire de travail spécifié * * @param dir * exp: / cim / * @param file_regex * Le wildcard est * * / public String [] ListAllFiles (String dir, string file_regex) {String [] names = this.listFiles (dir + file_regex); retourner this.sort (noms); }! * //System.out.println(RemoteFiles.length); String [] name = new * string [RemoteFiles.length]; if (RemoteFiles! = NULL) {for (int * i = 0; i <RemoteFiles.length; i ++) {if (RemoteFiles [i] == null) * name [i] = ""; else * if (RemoteFiles [i] .getName () == null || RemoteFiles * [i] .getName (). Equals * (".") || RemoteFiles [i] .getName (). Equals ("..")) {name [i] = ""; *} else name [i] = RemoteFiles [i] .getName (); * System.out.println (name [i]); }} * / ftpclient.enterLocalPassiveMode (); String [] name = ftpclient.listNames (file_regex) ;; if (name == null) return new String [0]; retourner this.sort (nom); } catch (exception e) {// TODO Bloc de capture généré automatiquement e.printStackTrace (); } return new String [0]; } public void lists (String Reg) {try {String [] a = ftpclient.listNames (reg); if (a! = null) {for (String b: a) {System.out.println (b); }}} catch (ioException e) {// TODO Generated Catch Block E.PrintStackTrace (); }} / ** * Définissez le type de fichier transféré [fichier texte ou fichier binaire] * * @param filetype * - binary_file_type, ASCII_FILE_TYPE * / public void SetFileType (int FileType) {try {ftpclient.setFileType (fileTy); } catch (ioException e) {e.printStackTrace (); }} / ** * Fichier de téléchargement * * @param localfilepath * - Chemin de fichier local + nom de fichier * @param newFileName * --new Nom de fichier * / public void uploadfile (String localfilepath, string newFileName) {// upload fichier de mode. try {Buffin = new BufferedInputStream (new FileInputStream (localFilePath)); booléen ifupload = ftpclient.storefile (newFileName, buffin); if (! ifupload) {System.out.println ("Télécharger le fichier a échoué ..."); } else {System.out.println ("Télécharger le fichier avec succès ..."); }} catch (exception e) {e.printStackTrace (); } enfin {try {if (buffin! = null) buffin.close (); } catch (exception e) {e.printStackTrace (); }}} / ** * Fichier de téléchargement 2 * * Fichier @param * - FileInputStream Fichier * @param newFileName * --new Nom du fichier * / public void newUploadFile (fichier fileInputStream, string newFilename) {// upload the Fichier ce fichier de la connexion du mode passive BuffredSterStrstream = null; try {buffin = new buffredInputStream (fichier); booléen ifupload = ftpclient.storefile (newFileName, buffin); if (! ifupload) {System.out.println ("Télécharger le fichier a échoué ..."); } else {System.out.println ("Télécharger le fichier avec succès ..."); }} catch (exception e) {e.printStackTrace (); } enfin {try {if (buffin! = null) buffin.close (); } catch (exception e) {e.printStackTrace (); }}} / ** * Télécharger le fichier (single) * * @param RemoteFileName * - Nom de fichier sur le serveur * @param localfilename * - Nom de fichier local * / public booléen downloadfile (string RemoteFileName, string localfilename) {this.ftpclient.enterlocalpassiveMode (); // mode de connexion passive BuffiredUtStretStSt try {buffout = new BufferedOutputStream (new FileOutputStream (localFileName)); booléen ifdownload = ftpClient .Retreveriefile (RemoteFileName, buffout); if (! ifdownload) {System.out.println ("Fichier de téléchargement a échoué ..."); retourne false; } else {System.out.println ("Télécharger le fichier avec succès ..."); }} catch (exception e) {e.printStackTrace (); retourne false; } enfin {try {if (buffout! = null) buffout.close (); } catch (exception e) {e.printStackTrace (); }} return true; } / ** * Fermez la connexion FTP * / public void close () {try {if (ftpClient! = Null) {ftpclient.logout (); ftpClient.disconnect (); }} catch (exception e) {e.printStackTrace (); }} / ** * Bubble Sort String (du grand à petit) * / public String [] Sort (String [] str_array) {if (str_array == null) {throw new NullPointerException ("le str_array ne peut pas être null!"); } String tmp = ""; for (int i = 0; i <str_array.length; i ++) {for (int j = 0; j <str_array.length - i - 1; j ++) {if (str_array [j] .compareto (str_array [j + 1]) <0) {tmp = str_array [j]; str_array [j] = str_array [j + 1]; str_array [j + 1] = tmp; }}} return str_array; } public static void main (String [] strs) {ftpUtil2 ftpUtil2 = new ftputil2 ("192.168.1.112", 20011, "test1", "test1", "/", true); Ftputil2.downloadFile ("test.txt", "d: //test.txt"); }}

Ce qui suit est la classe d'outils zip:

 Importer java.io.file; import java.io.fileInputStream; Importer java.io.fileOutputStream; Importer java.io.ioException; import java.io.inputStream; import java.io.outputStream; import java.util.arraylist; Importer Java.util.Enumeration; Importer java.util.list; importation java.util.map; Importer java.util.zip.zipentry; import java.util.zip.zipfile; Importer java.util.zip.zipOutputStream; import org.apache.commons.io.ioutils; import com.ibatis.common.logging.log; import com.ibatis.common.logging.logfactory; classe publique ziputil {private static final log = logfactory.getLog (ziputil.class); / ** * Fichier compressé * * @Param SrcFile File [] Liste des fichiers qui doivent être compressés * @param ZipFile Fichier Fichiers compressés * / public static OutputStream ZipFiles (list <FichE> SRCFILE, OutputStream OutprowingStream) {byte [] buf = new Byte [1024]; essayez {// créer le fichier zip zipOutputStream out = new ZipOutputStream (outputStream); // compresse les fichiers pour (int i = 0; i <srcfile.size (); i ++) {file file = srcfile.get (i); FileInputStream dans = new FileInputStream (fichier); // Ajouter une entrée zip au flux de sortie. OUT.PUTNEXTENTRY (New Zipentry (file.getName ())); // transférer les octets du fichier vers le fichier zip int len; while ((len = in.read (buf))> 0) { //System.out.println(len+"======================================================================================= =================================================================================================================================. =================================================================================================================================. =================================================================================================================================. E) {Log.Error ("Ziputil ZipFiles Exception:" + E);} return outputStream;} / ** * Fichier compressé * * @param fichier Srcfile [] Byte [1024]; Stream de sortie. } Catch (ioException e) {log.Error ("Ziputil ZipFiles Exception:" + E);}} / ** * Fichier compressé * Srcfile: Key: File Name, Value: INPUT Stream correspondant au fichier * @param srcfile * @param zipfile * @see * / public static zipbyStream (Map <stralise, putain de srcfile, fichier static zipbyStream (Map <String, SHEDSTREAM, STATIQUE PUBLIQUE, STATIQUE ZIPBYSTRAMME (MAPH <String, SHIED, SCHETRAC zipfile) {try {// Créer le fichier zip zipoutputStream out = new ZipOutputStream (new FileOutputStream (zipfile)); FileEntry.getValue (); Out.CloseEntry (); @param srcfile * @param zipfile * @see * / public static void zipbyarray (map <string, byte []> srcfile, fichier zipfile) {byte [] buf = new byte [1024]; System.out.println (srcfile.entryset (). Size ()); Le fichier à zip byte [] bytes = filentry.getValue (); // ioutils.toByTeary (in); Exception: "+ e); System.out.println (e.getMessage ());}} / ** * unzip * * @param zipfile fichier de fichier de fichiers ZipFile (ZipFile); System.out.Println (ZipentryName); Out.Close ();}} Catch (ioException e) {Log.Error (Ziputil UnzipFiles Exception: "+ E);}} / ** * Main * * @param args * / new static Void (file> (); File (D: //1.jpg "); Ziputil.zipfiles (srcfile, zipfile);

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.