filechooser.java~1~

用java编写的压缩程序

package compress;
import java.io.File;
import java.util.Enumeration;
import java.util.Hashtable;
import java.awt.Toolkit;
import javax.swing.filechooser.*;
import javax.swing.plaf.*;
import javax.swing.*;
public class FileChooser  extends JFileChooser{
MyFileFilter filter;
//MyFileView fileView;
public FileChooser(){
	this.initial();
}
void initial(){
	filter=new MyFileFilter();
	//this.setFileFilter(filter);
	//fileView=new MyFileView();
	//this.setFileView(fileView);
//	set size
	   this.setSize(600, 400);
	//set Look and Feel
//	try {
//	      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
//	   } catch (Exception exc) {
//	      System.err.println("Error loading L&F: " + exc);
//	   }

  //set position
	   double   width   =   Toolkit.getDefaultToolkit().getScreenSize().getWidth();
       double   height   =   Toolkit.getDefaultToolkit().getScreenSize().getHeight();
       this.setLocation((int)(width - this.getWidth())/2,
                               (int)(height -  this.getHeight())   /   2);

}
}
class MyFileFilter extends FileFilter {

    private static String TYPE_UNKNOWN = "Type Unknown";
    private static String HIDDEN_FILE = "Hidden File";

    private Hashtable filters = null;
    private String description = null;
    private String fullDescription = null;
    private boolean useExtensionsInDescription = true;

    /**
     * Creates a file filter. If no filters are added, then all
     * files are accepted.
     *
     * @see #addExtension
     */
    public MyFileFilter() {
	this.filters = new Hashtable();
    }

    /**
     * Creates a file filter that accepts files with the given extension.
     * Example: new ExampleFileFilter("jpg");
     *
     * @see #addExtension
     */
//    public MyFileFilter(String extension) {
//	this(extension,null);
//    }

    /**
     * Creates a file filter that accepts the given file type.
     * Example: new ExampleFileFilter("jpg", "JPEG Image Images");
     *
     * Note that the "." before the extension is not needed. If
     * provided, it will be ignored.
     *
     * @see #addExtension
     */
//    public MyFileFilter(String extension, String description) {
//	this();
//	if(extension!=null) addExtension(extension);
// 	if(description!=null) setDescription(description);
//    }

    /**
     * Creates a file filter from the given string array.
     * Example: new ExampleFileFilter(String {"gif", "jpg"});
     *
     * Note that the "." before the extension is not needed adn
     * will be ignored.
     *
     * @see #addExtension
     */
//    public MyFileFilter(String[] filters) {
//	this(filters,null);
//    }

    /**
     * Creates a file filter from the given string array and description.
     * Example: new ExampleFileFilter(String {"gif", "jpg"}, "Gif and JPG Images");
     *
     * Note that the "." before the extension is not needed and will be ignored.
     *
     * @see #addExtension
     */
//    public MyFileFilter(String[] filters, String description) {
//	this();
//	for (int i = 0; i < filters.length; i++) {
//	    // add filters one by one
//	    addExtension(filters[i]);
//	}
// 	if(description!=null) setDescription(description);
//    }

    /**
     * Return true if this file should be shown in the directory pane,
     * false if it shouldn't.
     *
     * Files that begin with "." are ignored.
     *
     * @see #getExtension
     * @see FileFilter#accepts
     */
    public boolean accept(File f) {
	if(f != null) {
	    if(f.isDirectory()) {
		return true;
	    }
	    String extension = getExtension(f);
	    if(extension != null && filters.get(getExtension(f)) != null) {
		return true;
	    };
	}
	return false;
    }

    /**
     * Return the extension portion of the file's name .
     *
     * @see #getExtension
     * @see FileFilter#accept
     */
     public String getExtension(File f) {
	if(f != null) {
	    String filename = f.getName();
	    int i = filename.lastIndexOf('.');
	    if(i>0 && i<filename.length()-1) {
		return filename.substring(i+1).toLowerCase();
	    };
	}
	return null;
    }

    /**
     * Adds a filetype "dot" extension to filter against.
     *
     * For example: the following code will create a filter that filters
     * out all files except those that end in ".jpg" and ".tif":
     *
     *   ExampleFileFilter filter = new ExampleFileFilter();
     *   filter.addExtension("jpg");
     *   filter.addExtension("tif");
     *
     * Note that the "." before the extension is not needed and will be ignored.
     */
//    public void addExtension(String extension) {
//	if(filters == null) {
//	    filters = new Hashtable(5);
//	}
//	filters.put(extension.toLowerCase(), this);
//	fullDescription = null;
//    }


    /**
     * Returns the human readable description of this filter. For
     * example: "JPEG and GIF Image Files (*.jpg, *.gif)"
     *
     * @see setDescription
     * @see setExtensionListInDescription
     * @see isExtensionListInDescription
     * @see FileFilter#getDescription
     */
    public String getDescription() {
	if(fullDescription == null) {
	    if(description == null || isExtensionListInDescription()) {
 		fullDescription = description==null ? "(" : description + " (";
		// build the description from the extension list
		Enumeration extensions = filters.keys();
		if(extensions != null) {
		    fullDescription += "." + (String) extensions.nextElement();
		    while (extensions.hasMoreElements()) {
			fullDescription += ", ." + (String) extensions.nextElement();
		    }
		}
		fullDescription += ")";
	    } else {
		fullDescription = description;
	    }
	}
	return fullDescription;
    }

    /**
     * Sets the human readable description of this filter. For
     * example: filter.setDescription("Gif and JPG Images");
     *
     * @see setDescription
     * @see setExtensionListInDescription
     * @see isExtensionListInDescription
     */
//    public void setDescription(String description) {
//	this.description = description;
//	fullDescription = null;
//    }

    /**
     * Determines whether the extension list (.jpg, .gif, etc) should
     * show up in the human readable description.
     *
     * Only relevent if a description was provided in the constructor
     * or using setDescription();
     *
     * @see getDescription
     * @see setDescription
     * @see isExtensionListInDescription
     */
//    public void setExtensionListInDescription(boolean b) {
//	useExtensionsInDescription = b;
//	fullDescription = null;
//    }

    /**
     * Returns whether the extension list (.jpg, .gif, etc) should
     * show up in the human readable description.
     *
     * Only relevent if a description was provided in the constructor
     * or using setDescription();
     *
     * @see getDescription
     * @see setDescription
     * @see setExtensionListInDescription
     */
    public boolean isExtensionListInDescription() {
	return useExtensionsInDescription;
    }
}
//class MyFileView extends FileView {
//    private Hashtable icons = new Hashtable(5);
//    private Hashtable fileDescriptions = new Hashtable(5);
//    private Hashtable typeDescriptions = new Hashtable(5);
//
//    /**
//     * The name of the file.  Do nothing special here. Let
//     * the system file view handle this.
//     * @see #setName
//     * @see FileView#getName
//     */
//    public String getName(File f) {
//	return null;
//    }
//
//    /**
//     * Adds a human readable description of the file.
//     */
//    public void putDescription(File f, String fileDescription) {
//	fileDescriptions.put(fileDescription, f);
//    }
//
//    /**
//     * A human readable description of the file.
//     *
//     * @see FileView#getDescription
//     */
//    public String getDescription(File f) {
//	return (String) fileDescriptions.get(f);
//    };
//
//    /**
//     * Adds a human readable type description for files. Based on "dot"
//     * extension strings, e.g: ".gif". Case is ignored.
//     */
//    public void putTypeDescription(String extension, String typeDescription) {
//	typeDescriptions.put(typeDescription, extension);
//    }
//
//    /**
//     * Adds a human readable type description for files of the type of
//     * the passed in file. Based on "dot" extension strings, e.g: ".gif".
//     * Case is ignored.
//     */
//    public void putTypeDescription(File f, String typeDescription) {
//	putTypeDescription(getExtension(f), typeDescription);
//    }
//
//    /**
//     * A human readable description of the type of the file.
//     *
//     * @see FileView#getTypeDescription
//     */
//    public String getTypeDescription(File f) {
//	return (String) typeDescriptions.get(getExtension(f));
//    }
//
//    /**
//     * Conveinience method that returnsa the "dot" extension for the
//     * given file.
//     */
//    public String getExtension(File f) {
//	String name = f.getName();
//	if(name != null) {
//	    int extensionIndex = name.lastIndexOf('.');
//	    if(extensionIndex < 0) {
//		return null;
//	    }
//	    return name.substring(extensionIndex+1).toLowerCase();
//	}
//	return null;
//    }
//
//    /**
//     * Adds an icon based on the file type "dot" extension
//     * string, e.g: ".gif". Case is ignored.
//     */
//    public void putIcon(String extension, Icon icon) {
//	icons.put(extension, icon);
//    }
//
//    /**
//     * Icon that reperesents this file. Default implementation returns
//     * null. You might want to override this to return something more
//     * interesting.
//     *
//     * @see FileView#getIcon
//     */
//    public Icon getIcon(File f) {
//	Icon icon = null;
//	String extension = getExtension(f);
//	if(extension != null) {
//	    icon = (Icon) icons.get(extension);
//	}
//	return icon;
//    }
//
//    /**
//     * Whether the file is hidden or not. This implementation returns
//     * true if the filename starts with a "."
//     *
//     * @see FileView#isHidden
//     */
//    public Boolean isHidden(File f) {
//	String name = f.getName();
//	if(name != null && !name.equals("") && name.charAt(0) == '.') {
//	    return Boolean.TRUE;
//	} else {
//	    return Boolean.FALSE;
//	}
//    };
//
//    /**
//     * Whether the directory is traversable or not. Generic implementation
//     * returns true for all directories and special folders.
//     *
//     * You might want to subtype ExampleFileView to do somethimg more interesting,
//     * such as recognize compound documents directories; in such a case you might
//     * return a special icon for the diretory that makes it look like a regular
//     * document, and return false for isTraversable to not allow users to
//     * descend into the directory.
//     *
//     * @see FileView#isTraversable
//     */
//    public Boolean isTraversable(File f) {
//	// if (some_reason) {
//	//    return Boolean.FALSE;
//	// }
//	return null;	// Use default from FileSystemView
//    };
//
//}