toString() में एक अनंत रिकर्सन को रोकने के लिए सबसे प्रभावी तरीका?

Question

संग्रह पर स्ट्रिंग करने के लिए एक अनंत लूप में प्रवेश किया जा सकता है यदि एकत्रित वस्तुओं के ग्राफ में कहीं भी एक संदर्भ है। नीचे उदाहरण देखें।

हां, अच्छे कोडिंग प्रथाओं को इसे पहले स्थान पर रोकना चाहिए, लेकिन फिर भी, मेरा प्रश्न है: इस स्थिति में एक पुनरावर्तन का पता लगाने का सबसे प्रभावी तरीका क्या है?

एक दृष्टिकोण थ्रेडलोकल में एक सेट का उपयोग करना है, लेकिन यह थोड़ा भारी लगता है।

public class AntiRecusionList<E> extends ArrayList<E> { 
    @Override 
    public String toString() { 
    if ( /* ???? test if "this" has been seen before */) { 
     return "{skipping recursion}"; 
    } else { 
     return super.toString(); 
    } 
    } 
} 


public class AntiRecusionListTest { 
    @Test 
    public void testToString() throws Exception { 
     AntiRecusionList<AntiRecusionList> list1 = new AntiRecusionList<>(); 
     AntiRecusionList<AntiRecusionList> list2 = new AntiRecusionList<>(); 
     list2.add(list1); 
     list1.add(list2); 
     list1.toString(); //BOOM ! 
    } 
} 

Answer 1

threadlocal बिट मैं प्रश्न में उल्लेख किया:

public class AntiRecusionList<E> extends ArrayList<E> { 


private final ThreadLocal<IdentityHashMap<AntiRecusionList<E>, ?>> fToStringChecker = 
     new ThreadLocal<IdentityHashMap<AntiRecusionList<E>, ?>>() { 
      @Override 
      protected IdentityHashMap<AntiRecusionList<E>, ?> initialValue() { 
       return new IdentityHashMap<>(); 
      } 
     };  

@Override 
public String toString() { 
    boolean entry = fToStringChecker.get().size() == 0; 
    try { 
     if (fToStringChecker.get().containsKey(this)/* test if "this" has been seen before */) { 
      return "{skipping recursion}"; 
     } else { 
      fToStringChecker.get().put(this, null); 
      entry = true; 
     } 
     return super.toString(); 
    } finally { 
     if (entry) 
      fToStringChecker.get().clear(); 
    } 
} 
} 

Answer 2

सबसे आसान तरीका: एक संग्रह या एक नक्शा के तत्वों पर toString() फोन नहीं है, कभी। यह इंगित करने के लिए कि यह एक संग्रह या मानचित्र है, और पूरी तरह से इसे फिर से शुरू करने से बचने के लिए बस [] प्रिंट करें। अनंत पुनरावृत्ति में गिरने से बचने के लिए यह एकमात्र बुलेट प्रूफ तरीका है।

सामान्य मामले में, आप अनुमान नहीं लगा सकते कि Collection या Map में किसी अन्य ऑब्जेक्ट के अंदर कौन से तत्व होने जा रहे हैं, और निर्भरता ग्राफ काफी जटिल हो सकता है, जिससे अप्रत्याशित परिस्थितियां होती हैं जहां ऑब्जेक्ट ग्राफ़ में एक चक्र होता है ।

आप किस आईडीई का उपयोग कर रहे हैं? क्योंकि ग्रहण में कोड जनरेटर के माध्यम से toString() विधि उत्पन्न करते समय स्पष्ट रूप से इस मामले को संभालने का विकल्प होता है - जब मैं एक विशेषता गैर-शून्य संग्रह या मानचित्र प्रिंट [] होता है, इस पर ध्यान दिए बिना कि इसमें कितने तत्व हैं।

Answer 3

जब मुझे जोखिम भरा ग्राफ पर पुनरावृत्ति करना होता है, तो मैं आमतौर पर कम करने वाले काउंटर के साथ एक फ़ंक्शन करता हूं।

उदाहरण के लिए:

public String toString(int dec) { 
    if ( dec<=0) { 
     return "{skipping recursion}"; 
    } else { 
     return super.toString(dec-1); 
    } 
} 

public String toString() { 
    return toString(100); 
} 

मैं इस पर जोर देते हैं नहीं, जैसा कि आप पहले से ही जानते हैं, लेकिन यह है कि जो छोटी और उम्मीद के मुताबिक हो गया है toString() के अनुबंध सम्मान नहीं करता।

Answer 4

समस्या संग्रह के लिए निहित नहीं है, यह ऑब्जेक्ट्स के किसी ग्राफ के साथ हो सकती है जिसमें चक्रीय संदर्भ हैं, उदाहरण के लिए, एक दोगुनी-लिंक्ड सूची।

मुझे लगता है कि एक शेन नीति है: toString() अपनी कक्षा के तरीके को अपने बच्चों के toString() पर कॉल नहीं करना चाहिए/यदि कोई संभावना है कि यह चक्र के साथ ऑब्जेक्ट ग्राफ़ का हिस्सा है तो संदर्भित नहीं किया जाना चाहिए। कहीं और, हमारे पास एक विशेष विधियां हो सकती हैं (शायद स्थैतिक, शायद एक सहायक वर्ग के रूप में) जो पूर्ण ग्राफ का एक स्ट्रिंग प्रतिनिधित्व उत्पन्न करती है।

Answer 5

हो सकता है आप अपने toString और स्टैकट्रेस पर लाभ उठाने में एक अपवाद बना सकते हैं पता करने के लिए जहां ढेर में हैं, और आप इसे देखते हैं मिलेगा रिकर्सिव कॉल कुछ ढांचे इस तरह से करते हैं।

@Override 
public String toString() { 
    // ... 
    Exception exception = new Exception(); 
    StackTraceElement[] stackTrace = exception.getStackTrace(); 
    // now you analyze the array: stack trace elements have 
    // 4 properties: check className, lineNumber and methodName. 
    // if analyzing the array you find recursion you stop propagating the calls 
    // and your stack won't explode  
    //...  

} 

Answer 6

आप उस स्ट्रिंग को बना सकते हैं जो एक पहचान हैश सेट लेता है।

public String toString() { 
    return toString(Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>())); 
} 

private String toString(Set<Object> seen) { 
    if (seen.add(this)) { 
     // to string this 
    } else { 
     return "{this}"; 
    } 
} 

Answer 7

तुम हमेशा प्रत्यावर्तन का ट्रैक रखने सकता है इस प्रकार है (ध्यान में रखा कोई सूत्रण मुद्दों):

public static class AntiRecusionList<E> extends ArrayList<E> { 
    private boolean recursion = false; 

    @Override 
    public String toString() { 
     if(recursion){ 
       //Recursion's base case. Just return immediatelly with an empty string 
       return ""; 
     } 
     recursion = true;//start a perhaps recursive call 
     String result = super.toString(); 
     recursion = false;//recursive call ended 
     return result; 
    } 
} 

Answer 8

आप पानी में गिर जाने के लिए चाहते हैं, आप एक पहलू यह है कि नेस्टेड संग्रह जब भी आप पटरियों इस्तेमाल कर सकते हैं कॉल टूस्ट्रिंग()।

public aspect ToStringTracker() { 
    Stack collections = new Stack(); 

    around(java.util.Collection c): call(String java.util.Collection+.toString()) && target(c) { 
    if (collections.contains(c)) { return "recursion"; } 
    else { 
     collections.push(c); 
     String r = c.toString(); 
     collections.pop(); 
     return r; 
    } 
    } 
} 

मैं ग्रहण में इस फेंकने के बिना वाक्य रचना पर कभी नहीं 100% हूँ, लेकिन मैं आप विचार

Answer 9

मैं अपाचे कॉमन्स लैंग से ToStringBuilder का उपयोग करना चाहिये मिल लगता है। आंतरिक रूप से यह एक थ्रेडलोकल मानचित्र का उपयोग करता है "चक्रीय वस्तु संदर्भों का पता लगाने और अनंत लूप से बचें।"