[Java] ImageCache

[uncopyable]

Guten Abend

Hier mein ImageCache Klasse aus meinem Client Projekt.

package tools;

import java.awt.Image;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import javax.imageio.ImageIO;

/** 
 * 
 * ImageCache.java 
 * 
 * Cache images from a zip file
 * 
 * @author uncopyable 
 *  
 * Version 1.0 Freitag, 1. Juni 2012 
 * 
 * 
 */ 


public class ImageCache {
    // Maximale anzahl der Bilder
    private int maxCount;
    // HashMap
    private Map<String, Image> imageCache = new HashMap<String, Image>();
    // Name der Zip Datei
    private String zipName;

    public ImageCache(int maxCount, String zipName) {
        this.maxCount = maxCount;
        this.zipName = zipName;
        loadImages();
    }

    /**
     * Lädt die Bilder aus dem Zip-Archiv in die HasMap
     */
    public void loadImages() {
        try {
            File f = new File(ImageCache.class.getResource("/res/" + zipName)
                    .getPath());
            if (f.exists()) {
                ZipFile zipFile = new ZipFile(f);
                Enumeration enu = zipFile.entries();
                while (enu.hasMoreElements()) {
                    ZipEntry zipEntry = (ZipEntry) enu.nextElement();

                    if (isImage(zipEntry.getName())) {
                        InputStream inputStream = zipFile
                                .getInputStream(zipEntry);
                        Image image = ImageIO.read(inputStream);
                        putImage(zipEntry.getName(), image);
                    }
                }

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 
     * Fügt den Name sowie das Bild in die HashMap ein
     * 
     */
    public void putImage(String name, Image image) {
        int i = this.imageCache.size();
        if (i <= maxCount) {
            this.imageCache.put(name, image);
        } else {
            System.out.println("HashMap full!");
        }
    }

    /**
     * Gibt ein Bild anhand des Namens aus dem Zip-Archiv zurück
     * 
     */
    public Image getImagesByName(String name) {
        try {
File f = new File(ImageCache.class.getResource("/res/" + zipName)
                    .getPath());
            if (f.exists()) {
                ZipFile zipFile = new ZipFile(f);
            Enumeration enu = zipFile.entries();
            while (enu.hasMoreElements()) {
                ZipEntry zipEntry = (ZipEntry) enu.nextElement();

                if (zipEntry.getName().equals(name)) {
                    InputStream inputStream = zipFile.getInputStream(zipEntry);
                    Image image = ImageIO.read(inputStream);
                    return image;
                }
}
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Gibt ein Bild anhand des Namens aus der HashMap zurück
     * 
     */
    public Image getImage(String name) {
        if (name.isEmpty()) {
            return null;
        }
        Image tmpImage = this.imageCache.get(name);
        if (tmpImage == null) {
            tmpImage = getImagesByName(name); 
            putImage(name, tmpImage);
        }
        return tmpImage;
    }

    /**
     * Gibt True zurück wenn s ein Bild ist sonst False
     *
     */
    private static boolean isImage(String s) {
        return s.contains(".gif") | s.contains(".png") | s.contains(".jpg");
    }

    /**
     * Setzt die maximale Anzahl 
     */
    public void setMaxCount(int maxCount) {
        this.maxCount = maxCount;
    }

    /**
     *  Löscht die HasMap
     */
    
    public void flush() {
        this.imageCache.clear();
    }
    
    
    /**
     *  Beispiel
     *  ImageCache chache = new ImageCache(100, "imgsj10a.zip");
     *  Image image = chache.getImage("kuecke2.gif");
     */
} 

Auch hier sind Verbesserungsvorschläge gerne gesehen

[Mr. White]

Du könntest das mit Java 7 eingeführte try-with-resources nutzen, oder schließe die Ressourcen manuell.

Wenn du Java 7 hast, kannst du dir in dieser Klasse auch ein wenig Tipparbeit sparen, dank des Diamond-Operators.

private Map<String, Image> imageCache = new HashMap<String, Image>();

zu:

private Map<String, Image> imageCache = new HashMap<>();

Ansonsten noch:

private static boolean isImage(String s) {
        return s.contains(".gif") | s.contains(".png") | s.contains(".jpg");
}

isImage("ausgetrickst.png.txt") würde fälschlicherweise true zurückgeben. Verwende statt contains(String s) lieber endsWith(String s). Hier sollen boolesche Werte verknüpft werden -> logisches Oder verwenden. Daraus ergibt sich auch der recht kleine Vorteil namens Short-Circuit-Evaluation. Endet die Bilddatei mit .gif, wird erst gar nicht mehr geprüft, ob es mit .png oder .jpg endet.

return null; Geschichten würde ich vermeiden, und lieber Exceptions werfen. Ich persönlich finde das schöner.