एक जेटीआर

Question

के सभी नोड्स को विस्तार/संक्षिप्त करने की गति बढ़ाएं मेरे पास लगभग 100000 नोड्स या उससे अधिक के साथ एक JTree है। अब मैं पूरे पेड़ का विस्तार करना चाहता हूं। ऐसा करने के लिए मैं here मिला समाधान का उपयोग करता हूं।

मेरी समस्या यह है कि इस तरह के बड़े पेड़ का विस्तार 60 सेकंड या उससे अधिक की तरह होता है, जो बहुत सुविधाजनक नहीं है। क्या किसी के पास कोई सुझाव है कि मैं विस्तार कैसे बढ़ा सकता हूं?

Answer 1

मुझे लगता है कि आपको एक प्रदर्शन रणनीति, या तो चौड़ाई पहले (सभी प्रत्यक्ष बच्चों को देखें) या गहराई से पहले सोचने की आवश्यकता है (केवल एक बच्चे के सभी वंशजों को देखें)। 100,000 स्क्रीन पर देखने के लिए बहुत सारे नोड्स हैं और आपको पैनिंग और ज़ूमिंग के बारे में सोचना होगा। आपको उन फ़िल्टरों के बारे में सोचना चाहिए जो आप चाहते हैं कि वंशजों के सबसेट का चयन कर सकते हैं।

एक रणनीति शीर्ष बच्चों को प्रदर्शित करने के लिए हो सकती है और जब आपका माउस किसी बच्चे में प्रवेश करता है, तो अपने सभी वंशजों को प्रदर्शित करते हैं और जब आप उन्हें पतन करते हैं। इस तरह आप ब्याज के वर्तमान उपखंड को प्रदर्शित करने वाले पेड़ पर नेविगेट कर सकते हैं।

Answer 2

हाँ, अपने यूआई तत्व पर पुनर्विचार करें। एक जेटी वह नहीं है जिसे आप 100,000 नोड्स दिखाने के लिए देख रहे हैं। कुछ ऐसा उपयोग करें जहां आप एक टेबल देख सकें और तालिका तत्व में ड्रिल-डाउन करने के लिए आइटम क्लिक करें। फिर इतिहास की तरह एक ब्रेडक्रंब है ताकि उपयोगकर्ता पदानुक्रम को नेविगेट कर सके ..

यदि आप जेटीआर होने पर जोर देते हैं, तो इस तरह से इसे पछतावा करने का एक तरीका है, लेकिन मुझे नहीं पता कि वह क्या करेगा विस्तार की समस्या के साथ आपकी मदद करें।

Answer 3

मैंने समाधान का प्रयास किया, आप भी इसका उपयोग करते हैं।

कोड प्रस्तुत मेरी राय के बाद वहां इष्टतम नहीं है: - यह सभी नोड्स के लिए tree.expandPath कहता है, बजाय यह केवल गहरी गैर पत्र-गांठ (पत्र-गांठ पर expandPath बुला कोई प्रभाव नहीं है के लिए बुलाने की, JDK देखें)

यहाँ एक सही संस्करण जो तेजी से होना चाहिए:

// If expand is true, expands all nodes in the tree. 
    // Otherwise, collapses all nodes in the tree. 
    public void expandAll(JTree tree, boolean expand) { 
     TreeNode root = (TreeNode)tree.getModel().getRoot(); 
     if (root!=null) { 
      // Traverse tree from root 
      expandAll(tree, new TreePath(root), expand); 
     } 
    } 

    /** 
    * @return Whether an expandPath was called for the last node in the parent path 
    */ 
    private boolean expandAll(JTree tree, TreePath parent, boolean expand) { 
     // Traverse children 
     TreeNode node = (TreeNode)parent.getLastPathComponent(); 
     if (node.getChildCount() > 0) { 
      boolean childExpandCalled = false; 
      for (Enumeration e=node.children(); e.hasMoreElements();) { 
       TreeNode n = (TreeNode)e.nextElement(); 
       TreePath path = parent.pathByAddingChild(n); 
       childExpandCalled = expandAll(tree, path, expand) || childExpandCalled; // the OR order is important here, don't let childExpand first. func calls will be optimized out ! 
      } 

      if (!childExpandCalled) { // only if one of the children hasn't called already expand 
       // Expansion or collapse must be done bottom-up, BUT only for non-leaf nodes 
       if (expand) { 
        tree.expandPath(parent); 
       } else { 
        tree.collapsePath(parent); 
       } 
      } 
      return true; 
     } else { 
      return false; 
     } 
    } 

Answer 4

मैं एक पेड़ 150 000 नोड्स (युक्त से अधिक 19 000 खुलने वाला नोड्स के साथ) के साथ एक ही समस्या थी। और मैं 5 से सिर्फ विधि अधिभावी getExpandedDescendants द्वारा की विस्तार सभी अवधि विभाजित:

JTree tree = new javax.swing.JTree() 
{ 
    @Override 
    public Enumeration<TreePath> getExpandedDescendants(TreePath parent) 
    { 
     if (!isExpanded(parent)) 
     { 
      return null; 
     } 
     return java.util.Collections.enumeration(getOpenedChild(parent, new javolution.util.FastList<TreePath>())); 
    } 

    /** 
    * Search oppened childs recursively 
    */ 
    private List<TreePath> getOpenedChild(TreePath paramTreeNode, List<TreePath> list) 
    { 
     final Object parent = paramTreeNode.getLastPathComponent(); 
     final javax.swing.tree.TreeModel model = getModel(); 
     int nbChild = model.getChildCount(parent); 
     for (int i = 0; i < nbChild; i++) 
     { 
      Object child = model.getChild(parent, i); 
      final TreePath childPath = paramTreeNode.pathByAddingChild(child); 
      if (!model.isLeaf(child) && isExpanded(childPath)) 
      { 
       //Add child if oppened 
       list.add(childPath); 
       getOpenedChild(childPath, list); 
      } 
     } 
     return list; 
    } 
}; 

सभी कार्रवाई का विस्तार अब 25 के बजाय 5 सेकंड लेने के लिए और मैं अभी भी प्रदर्शन में सुधार पर काम कर रहा हूँ।

Answer 5

त्वरित तरीका:

JTree jTree; 
for (int i = 0; i < jTree.getRowCount(); i++) { 
     jTree.expandRow(i); 
} 

Answer 6

मैं निम्नलिखित पैटर्न के साथ कुछ सफलता मिली है:

tree = new JTree(...) 
tree.setLargeModel(true); 

यह पहले से ही कुछ बड़े विस्तार लाया (150,000 पेड़ नोड्स) नीचे 12s से -> 3.5s

तो थोक में विस्तार करने के लिए अधिक तेजी से:

TreeUI treeUI = tree.getUI(); 
tree.setUI(null); 
try { 
    // perform bulk expansion logic, like in other answers 
} finally { 
    tree.setUI(treeUI); 
} 

यह इसे लगभग 1.0 के आसपास लाया।