转】java 支持文件删除的树状视图文件资源管理器

 

效果图：

 

 

原文：http://www.xinbcw.com/viewthread.php?tid=2580

 

java代码：

 

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.File;

import javax.swing.JFrame;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.ScrollPaneConstants;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

//测试类
public class Exec {
        public static void main(String[] args) {
                // 创建窗体类变量
                DemoWindow dw = new DemoWindow("可以删除文件的树状视图文件资源管理器");

                // 将窗体的宽度和高度分别设置为屏幕宽度和屏幕高度的1/2，左上角位置设置为屏幕宽度和屏幕高度的1/4处
                Toolkit theKit = dw.getToolkit();
                Dimension wndSize = theKit.getScreenSize();
                dw.setBounds(wndSize.width / 4, wndSize.height / 4, wndSize.width / 2,
                                wndSize.height / 2);

                // 点击关闭按钮可以退出程序
                dw.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                // 设置窗体为可见
                dw.setVisible(true);
        }
}

// 界面窗体
class DemoWindow extends JFrame implements TreeExpansionListener {
        // 显示目录的树状视图
        JTree tree = null;

        // 树状视图的模型类
        DefaultTreeModel dtm = null;

        // 构造函数
        public DemoWindow(String title) {
                super(title);

                // 设置默认的查看目录
                File f = new File("C:\\Program Files\\Java\\jdk1.6.0_10");

                // 建立树状视图的根节点
                DefaultMutableTreeNode top = new DefaultMutableTreeNode(f.getPath());

                // 设置树状视图的初始状态到树状视图模型类
                getRoot(top, f);

                // 建立树状视图模型类
                dtm = new DefaultTreeModel(top);

                // 设置树状视图模型类为允许存在子节点，显示加号标记
                dtm.setAsksAllowsChildren(true);

                // 建立树状视图
                tree = new JTree(dtm);

                // 设置树状视图的滚动条
                int v = ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED;
                int h = ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED;
                JScrollPane jsp = new JScrollPane(tree, v, h);

                // 添加树状视图
                add(jsp, BorderLayout.CENTER);

                // 添加事件监听器
                tree.addTreeExpansionListener(this);

                // 添加事件监听器，响应右击树状视图显示快捷菜单
                tree.addMouseListener(new MouseAdapter() {
                        public void mousePressed(MouseEvent e) {
                                // 如果为右击
                                if (e.getButton() == MouseEvent.BUTTON3) {
                                        // 利用点击位置获取所选择的子节点
                                        int selRow = tree.getRowForLocation(e.getX(), e.getY());

                                        // 设置树状视图的选中状态
                                        tree.setSelectionRow(selRow);

                                        // 如果为有效子节点
                                        if (selRow != -1) {
                                                // 如果为右单击
                                                if (e.getClickCount() == 1) {
                                                        // 显示快捷菜单
                                                        JPopupMenu pop = new JPopupMenu();
                                                        JMenuItem item1 = new JMenuItem("删除");

                                                        // 该快捷菜单响应删除文件的操作
                                                        item1.addActionListener(new MenuAction());

                                                        pop.add(item1);
                                                        pop.show(tree, e.getX(), e.getY());
                                                }
                                        }
                                }
                        }
                });
        }

        // 内部类，响应快捷菜单的单击操作
        private class MenuAction implements ActionListener {
                public void actionPerformed(ActionEvent e) {
                        // 得到树状视图的被选择节点路径
                        TreePath tp = tree.getSelectionPath();

                        // 得到树状视图的被选择节点
                        DefaultMutableTreeNode node = (DefaultMutableTreeNode) tp
                                        .getLastPathComponent();

                        // 从树状视图删除当前节点
                        DefaultTreeModel dtm = (DefaultTreeModel) tree.getModel();
                        dtm.removeNodeFromParent(node);

                        // 得到被选择节点对应文件的完整路径信息
                        String fullPath = "";
                        for (Object obj : tp.getPath()) {
                                String str = obj.toString();

                                // 处理盘符根目录问题
                                if (str.endsWith("\\"))
                                        str = str.substring(0, str.length() - 1);
                                if (fullPath.equals(""))
                                        fullPath += str;
                                else
                                        fullPath += "\\" + str;
                        }

                        // 如果是文件，直接删除，如果是目录则调用deleteDir函数删除目录
                        File currentFile = new File(fullPath);
                        if (currentFile.isFile())
                                currentFile.delete();
                        else
                                deleteDir(currentFile);
                }
        };

        // 通过递归调用，可以删除目录的函数
        public static boolean deleteDir(File dir) {
                // 判断是否为目录，如果是，则递归调用自己，如果不是，直接删除文件
                if (dir.isDirectory()) {
                        String[] subDir = dir.list();
                        for (String s : subDir) {
                                deleteDir(new File(dir, s));
                        }
                }
                return dir.delete();
        }

        // 该函数设置树状视图的初始状态到树状视图模型类
        public void getRoot(DefaultMutableTreeNode superDmtn, File f) {
                // 遍历所有下级文件
                File files[] = f.listFiles();
                for (int i = 0; i < files.length; i++) {
                        // 建立树状视图的子节点，名称为文件名称
                        DefaultMutableTreeNode dmtn = new DefaultMutableTreeNode(files[i]
                                        .getName());

                        // 如果是目录，则对应的子节点允许存在子节点，显示加号标记，否则不显示
                        if (files[i].isDirectory())
                                dmtn.setAllowsChildren(true);
                        else
                                dmtn.setAllowsChildren(false);

                        // 将子节点加入上级节点
                        superDmtn.add(dmtn);
                }
        }

        // 响应展开树状视图
        public void treeExpanded(TreeExpansionEvent event) {
                // 得到当前展开的子节点
                DefaultMutableTreeNode node = (DefaultMutableTreeNode) (event.getPath())
                                .getLastPathComponent();

                // 判断是否已有子节点，如果没有，遍历文件信息将其添加到当前子节点下，生成下级子节点
                if (node.getChildCount() == 0) {
                        // 备份当前子节点
                        DefaultMutableTreeNode originalNode = node;

                        // 得到当前子节点的名，即对应文件的名称
                        String fileName = node.toString();

                        // 通过倒序上移节点，获取节点对应文件的完整路径
                        while (node.getParent() != null) {
                                node = (DefaultMutableTreeNode) node.getParent();
                                fileName = node.toString() + "\\" + fileName;
                        }

                        // 继续处理当前子节点
                        if (originalNode != null) {
                                // 生成当前子节点对应文件的类变量
                                File f = new File(fileName);

                                // 如果是目录，则继续处理
                                if (f.isDirectory()) {
                                        // 得到下级文件列表
                                        File files[] = f.listFiles();

                                        // 如果目录不为空，循环遍历每个下级文件
                                        if (files != null)
                                                for (int i = 0; i < files.length; i++) {
                                                        // 建立下级子节点，名称为文件名称
                                                        DefaultMutableTreeNode dmtn = new DefaultMutableTreeNode(
                                                                        files[i].getName());

                                                        // 如果是目录，则对应的子节点允许存在子节点，显示加号标记，否则不显示
                                                        if (files[i].isDirectory())
                                                                dmtn.setAllowsChildren(true);
                                                        else
                                                                dmtn.setAllowsChildren(false);

                                                        // 将新建的子节点追加到上级节点，作为最后一个节点
                                                        dtm.insertNodeInto(dmtn, originalNode, originalNode
                                                                        .getChildCount());
                                                }
                                }
                        }
                }
        }

        // 响应收缩树状视图
        public void treeCollapsed(TreeExpansionEvent event) {
        }
}