परिपूर्णता के लिए...
कि आप कहते हैं कि वास्तव में क्या कर इलाज के लिए चाहते हैं Mapके रूप में मान Listहै, लेकिन आप को कॉपी से बचना चाहते हैं Setएक में Listहर बार।
उदाहरण के लिए, हो सकता है कि आप एक लाइब्रेरी फ़ंक्शन को कॉल कर रहे हैं जो एक बनाता है Set, लेकिन आप अपना Map<String, List<String>>परिणाम एक (खराब-डिज़ाइन किए गए लेकिन अपने हाथों से) लाइब्रेरी फ़ंक्शन को पारित कर रहे हैं Map<String, List<String>>, जो केवल लेता है , भले ही किसी भी तरह आपको पता हो कि ऑपरेशन इसके साथ करता है Lists किसी भी Collection(और इस प्रकार किसी भी Set) के लिए समान रूप से लागू होते हैं । और किसी कारण से आपको प्रत्येक सेट को एक सूची में कॉपी करने की गति / मेमोरी ओवरहेड से बचने की आवश्यकता होती है।
इस सुपर आला मामले में, (शायद अनजाने में) व्यवहार के आधार पर लाइब्रेरी फ़ंक्शन को आपके Lists से बाहर की जरूरत है , आप प्रत्येक सेट पर एक List दृश्य बनाने में सक्षम हो सकते हैं । ध्यान दें कि यह स्वाभाविक रूप से असुरक्षित है (क्योंकि प्रत्येक से लाइब्रेरी फ़ंक्शन की आवश्यकताओं Listको संभवतः आप बिना जाने बदल सकते हैं), इसलिए एक और समाधान को प्राथमिकता दी जानी चाहिए। लेकिन यहाँ आप इसे कैसे करेंगे।
आप एक ऐसी क्लास बनाएँगे जो Listइंटरफ़ेस को लागू करती है, Setकंस्ट्रक्टर में ले जाती है और उस सेट को एक फील्ड में असाइन करती है, और फिर एपीआई Setको लागू करने के लिए उस आंतरिक का उपयोग करती Listहै (हद तक, और वांछित)।
ध्यान दें कि कुछ सूची व्यवहार आप केवल तत्वों के रूप में संग्रहीत किए बिना नकल करने में सक्षम नहीं होंगे List, और कुछ व्यवहार आप केवल आंशिक रूप से नकल करने में सक्षम होंगे। फिर, यह वर्ग Listसामान्य रूप से s के लिए एक सुरक्षित ड्रॉप-इन प्रतिस्थापन नहीं है । विशेष रूप से, यदि आप जानते हैं कि उपयोग के मामले में अनुक्रमणिका से संबंधित संचालन की आवश्यकता होती है या MUTATING List, यह दृष्टिकोण बहुत तेजी से दक्षिण की ओर जाएगा।
public class ListViewOfSet<U> implements List<U> {
private final Set<U> wrappedSet;
public ListViewOfSet(Set<U> setToWrap) { this.wrappedSet = setToWrap; }
@Override public int size() { return this.wrappedSet.size(); }
@Override public boolean isEmpty() { return this.wrappedSet.isEmpty(); }
@Override public boolean contains(Object o) { return this.wrappedSet.contains(o); }
@Override public java.util.Iterator<U> iterator() { return this.wrappedSet.iterator(); }
@Override public Object[] toArray() { return this.wrappedSet.toArray(); }
@Override public <T> T[] toArray(T[] ts) { return this.wrappedSet.toArray(ts); }
@Override public boolean add(U e) { return this.wrappedSet.add(e); }
@Override public boolean remove(Object o) { return this.wrappedSet.remove(o); }
@Override public boolean containsAll(Collection<?> clctn) { return this.wrappedSet.containsAll(clctn); }
@Override public boolean addAll(Collection<? extends U> clctn) { return this.wrappedSet.addAll(clctn); }
@Override public boolean addAll(int i, Collection<? extends U> clctn) { throw new UnsupportedOperationException(); }
@Override public boolean removeAll(Collection<?> clctn) { return this.wrappedSet.removeAll(clctn); }
@Override public boolean retainAll(Collection<?> clctn) { return this.wrappedSet.retainAll(clctn); }
@Override public void clear() { this.wrappedSet.clear(); }
@Override public U get(int i) { throw new UnsupportedOperationException(); }
@Override public U set(int i, U e) { throw new UnsupportedOperationException(); }
@Override public void add(int i, U e) { throw new UnsupportedOperationException(); }
@Override public U remove(int i) { throw new UnsupportedOperationException(); }
@Override public int indexOf(Object o) { throw new UnsupportedOperationException(); }
@Override public int lastIndexOf(Object o) { throw new UnsupportedOperationException(); }
@Override public ListIterator<U> listIterator() { throw new UnsupportedOperationException(); }
@Override public ListIterator<U> listIterator(int i) { throw new UnsupportedOperationException(); }
@Override public List<U> subList(int i, int i1) { throw new UnsupportedOperationException(); }
}
...
Set<String> set = getSet(...);
ListViewOfSet<String> listOfNames = new ListViewOfSet<>(set);
...