Java JTree条目渲染问题

在我的项目GUI中，我使用

JTree

来显示文件系统，我遇到了一个特定于渲染的问题：所述

JTree

中的某些条目似乎能够正确渲染，也能够在先前选择的条目上渲染自己。这很难解释，所以我认为包括一个截图是最容易理解的

为了实现这一点，我用箭头键从上到下快速移动

我不太清楚这个问题的来源，但我怀疑这可能是我的

TreeModel

或

CellRenderer

的问题，这两个都包含在下面

欢迎任何可以帮助我解决此问题的帮助

import java.awt.Component;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Vector;

import javax.imageio.ImageIO;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.WindowConstants;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

public class MCVE {
    public static void main(String[] args) throws Throwable {
        JFrame frame = new JFrame();
        frame.getContentPane().add(new FileSystemTree(new File(System.getProperty("user.home"))));
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }
}

class FileSystemTree extends JPanel {
    private File                root;
    private FileSystemTreeModel model;
    private final JTree         fileSystem;

    public FileSystemTree(File root) throws IOException {
        this.root = root;
        model = new FileSystemTreeModel(root);
        fileSystem = new JTree(model);
        fileSystem.setEditable(false);
        fileSystem.setCellRenderer(new FileSystemTreeCellRenderer());
        fileSystem.putClientProperty("JTree.lineStyle", "None");

        add(new JScrollPane(fileSystem));
    }
}

class FileSystemTreeCellRenderer extends DefaultTreeCellRenderer {
    private final Icon  folderSpecial;
    private final Icon  folderOther;
    private final Icon  fileSpecial;
    private final Icon  fileOther;

    public FileSystemTreeCellRenderer() throws IOException {
        InputStream stream;
        BufferedImage image;

        stream = new FileInputStream("folder-special.png");
        image = ImageIO.read(stream);
        folderSpecial = new ImageIcon(image);
        stream.close();

        stream = new FileInputStream("folder-other.png");
        image = ImageIO.read(stream);
        folderOther = new ImageIcon(image);
        stream.close();

        stream = new FileInputStream("file-special.png");
        image = ImageIO.read(stream);
        fileSpecial = new ImageIcon(image);
        stream.close();

        stream = new FileInputStream("file-other.png");
        image = ImageIO.read(stream);
        fileOther = new ImageIcon(image);
        stream.close();
    }

    @Override
    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
        super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);

        if (value instanceof File) {
            Icon icon = null;
            File file = (File) value;

            if (file.isDirectory()) {
                if (file.getName().endsWith("-special")) {
                    icon = folderSpecial;
                } else {
                    icon = folderOther;
                }
            } else if (file.isFile()) {
                if (file.getName().endsWith(".special")) {
                    icon = fileSpecial;
                } else {
                    icon = fileOther;
                }
            }

            setIcon(icon);
        }

        return this;
    }
}

class FileSystemTreeModel implements TreeModel, Comparator<File> {
    private final File                      root;
    private final Vector<TreeModelListener> listeners   = new Vector<>();

    public FileSystemTreeModel(File root) {
        if (!root.isDirectory()) throw new IllegalArgumentException();
        this.root = root;
    }

    @Override
    public int compare(File a, File b) {
        if (a.isDirectory() && !b.isDirectory()) return -1;
        if (!a.isDirectory() && b.isDirectory()) return 1;
        return a.getName().compareToIgnoreCase(b.getName());
    }

    @Override
    public File getRoot() {
        return root;
    }

    @Override
    public File getChild(Object parent, int index) {
        File dir = (File) parent;
        File[] files = dir.listFiles();
        String[] children = new String[files.length];
        Arrays.sort(files, this::compare);

        for (int i = 0; i < files.length; i++) {
            children[i] = files[i].getName();
        }

        return new TreeFile(dir, children[index]);
    }

    @Override
    public int getChildCount(Object parent) {
        File file = (File) parent;
        if (file.isDirectory()) {
            String[] fileList = file.list();
            if (fileList != null) return fileList.length;
        }
        return 0;
    }

    @Override
    public boolean isLeaf(Object node) {
        File file = (File) node;
        return file.isFile();
    }

    @Override
    public int getIndexOfChild(Object parent, Object child) {
        File dir = (File) parent;
        File file = (File) child;
        File[] children = dir.listFiles();
        Arrays.sort(children, this::compare);

        for (int i = 0; i < children.length; i++) {
            if (file.equals(children[i])) return i;
        }

        return -1;
    }

    @Override
    public void valueForPathChanged(TreePath path, Object value) {}

    @Override
    public void addTreeModelListener(TreeModelListener listener) {
        listeners.add(listener);
    }

    @Override
    public void removeTreeModelListener(TreeModelListener listener) {
        listeners.remove(listener);
    }

    private static class TreeFile extends File {
        public TreeFile(File parent, String path) {
            super(parent, path);
        }

        @Override
        public String toString() {
            return getName();
        }
    }
}

导入java.awt.Component；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.util.array；
导入java.util.Comparator；
导入java.util.Vector；
导入javax.imageio.imageio；
导入javax.swing.Icon；
导入javax.swing.ImageIcon；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.JScrollPane；
导入javax.swing.JTree；
导入javax.swing.WindowConstants；
导入javax.swing.event.TreeModelListener；
导入javax.swing.tree.DefaultTreeCellRenderer；
导入javax.swing.tree.TreeModel；
导入javax.swing.tree.TreePath；
公共级MCVE{
公共静态void main（字符串[]args）抛出可丢弃的{
JFrame=新JFrame（）；
frame.getContentPane（）.add（新文件系统树（新文件（System.getProperty（“user.home”）））；
frame.setDefaultCloseOperation（WindowConstants.EXIT_ON_CLOSE）；
frame.pack（）；
frame.setVisible（true）；
}
}
类FileSystemTree扩展了JPanel{
私有文件根；
私有文件系统树模型；
私有最终JTree文件系统；
公共文件系统树（文件根目录）引发IOException{
this.root=根；
模型=新文件系统树模型（根）；
文件系统=新的JTree（模型）；
fileSystem.setEditable（false）；
setCellRenderer（新的FileSystemTreeCellRenderer（））；
putClientProperty（“JTree.lineStyle”，“无”）；
添加（新的JScrollPane（文件系统））；
}
}
类FileSystemTreeCellRenderer扩展了DefaultTreeCellRenderer{
私人最终图标folderSpecial；
私人最终图标folderOther；
私有最终图标文件专用；
私人最终图标文件其他；
公共文件系统TreeCellRenderer（）引发IOException{
输入流；
缓冲图像；
stream=newfileinputstream（“folder special.png”）；
image=ImageIO.read（流）；
folderSpecial=新图像图标（图像）；
stream.close（）；
stream=newfileinputstream（“folder other.png”）；
image=ImageIO.read（流）；
folderOther=新图像图标（图像）；
stream.close（）；
stream=newfileinputstream（“file special.png”）；
image=ImageIO.read（流）；
fileSpecial=新图像图标（图像）；
stream.close（）；
stream=newfileinputstream（“file other.png”）；
image=ImageIO.read（流）；
fileOther=新图像图标（图像）；
stream.close（）；
}
@凌驾
公共组件GetTreeCellRenderComponent（JTree树、对象值、布尔sel、布尔扩展、布尔叶、int行、布尔hasFocus）{
super.gettreeCellrenderComponent（树、值、sel、展开、叶、行、hasFocus）；
if（文件实例的值）{
图标=空；
文件=（文件）值；
if（file.isDirectory（））{
if（file.getName（）.endsWith（“-special”））{
icon=folderSpecial；
}否则{
图标=折叠其他；
}
}else if（file.isFile（））{
if（file.getName（）.endsWith（“.special”））{
图标=文件专用；
}否则{
icon=fileOther；
}
}
设置图标（图标）；
}
归还这个；
}
}
类FileSystemTreeModel实现TreeModel、Comparator{
私有最终文件根；
私有最终向量侦听器=新向量（）；
公共文件系统树模型（文件根）{
如果（！root.isDirectory（））抛出新的IllegalArgumentException（）；
this.root=根；
}
@凌驾
公共整数比较（文件a、文件b）{
if（a.isDirectory（）&&！b.isDirectory（））返回-1；
如果（！a.isDirectory（）&&b.isDirectory（））返回1；
返回a.getName（）.compareToIgnoreCase（b.getName（））；
}
@凌驾
公共文件getRoot（）{
返回根；
}
@凌驾
公共文件getChild（对象父对象，int索引）{
文件目录=（文件）父级；
File[]files=dir.listFiles（）；
String[]children=新字符串[files.length]；
sort（文件，this:：compare）；
对于（int i=0；ipublic class FileSystemTreeCellRenderer implements TreeCellRenderer {
    protected Color foregroundColor = null;
    protected Color backgroundColor = null;
    protected Color selectionForegroundColor = null;
    protected Color selectionBackgroundColor = null;
    protected Map<Object, JLabel> labels = new HashMap<>();
    protected final Icon  folderSpecial;
    protected final Icon  folderOther;
    protected final Icon  fileSpecial;
    protected final Icon  fileOther;

    public FileSystemTreeCellRenderer() throws IOException {
        InputStream stream;
        BufferedImage image;

        stream = new FileInputStream("folder-special.png");
        image = ImageIO.read(stream);
        folderSpecial = new ImageIcon(image);
        stream.close();

        stream = new FileInputStream("folder-other.png");
        image = ImageIO.read(stream);
        folderOther = new ImageIcon(image);
        stream.close();

        stream = new FileInputStream("file-special.png");
        image = ImageIO.read(stream);
        fileSpecial = new ImageIcon(image);
        stream.close();

        stream = new FileInputStream("file-other.png");
        image = ImageIO.read(stream);
        fileOther = new ImageIcon(image);
        stream.close();
    }

    protected JLabel getLabelFor(Object object) {
        JLabel label = labels.get(object);
        if(label == null) {
            label = new JLabel();
            labels.put(object, label);
        }
        return label;
    }

    public Color getForegroundColor() {
        if (foregroundColor == null) return UIManager.getColor("Tree.textForeground");
        return foregroundColor;
    }

    public Color getBackgroundColor() {
        if (backgroundColor == null) return UIManager.getColor("Tree.textBackground");
        return backgroundColor;
    }

    public Color getSelectionForegroundColor() {
        if (selectionForegroundColor == null) return UIManager.getColor("Tree.selectionForeground");
        return selectionForegroundColor;
    }

    public Color getSelectionBackgroundColor() {
        if (selectionBackgroundColor == null) return UIManager.getColor("Tree.selectionBackground");
        return selectionBackgroundColor;
    }

    @Override
    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
        JLabel label = getLabelFor(value);
        label.setText(Objects.toString(value, ""));
        label.setOpaque(true);
        label.setBackground(selected ? getSelectionBackgroundColor() : getBackgroundColor());
        label.setForeground(selected ? getSelectionForegroundColor() : getForegroundColor());
        label.setEnabled(tree.isEnabled());
        label.setComponentOrientation(tree.getComponentOrientation());

        if (value instanceof File) {
            Icon icon = null;
            File file = (File) value;

            if (file.isDirectory()) {
                if (file.getName().endsWith("-special")) {
                    icon = folderSpecial;
                } else {
                    icon = folderOther;
                }
            } else if (file.isFile()) {
                if (file.getName().endsWith(".special")) {
                    icon = fileSpecial;
                } else {
                    icon = fileOther;
                }
            }

            label.setIcon(icon);
        }

        return label;
    }
}