उप-संग्रह फॉर्म संग्रह जावा (संग्रह, Arrays, सूची) कैसे प्राप्त करें और पिछली बार का ट्रैक रखें

Question

public Collection<Comment> getCommentCollection() { 
    commentCollection = movie.getCommentCollection();  
    return split((List<Comment>) commentCollection, 4); 
} 

public Collection<Comment> split(List<Comment> list, int size){ 

    int numBatches = (list.size()/size) + 1; 
    Collection[] batches = new Collection[numBatches]; 
    Collection<Comment> set = commentCollection; 

    for(int index = 0; index < numBatches; index++) { 
     int count = index + 1; 
     int fromIndex = Math.max(((count - 1) * size), 0); 
     int toIndex = Math.min((count * size), list.size()); 
     batches[index] = list.subList(fromIndex, toIndex); 
     set = batches[index]; 
    } 

    return set; 
} 

हाय, मैं संग्रह में वस्तुओं की संख्या के आधार पर संग्रह को छोटे संग्रह में विभाजित करने की कोशिश कर रहा हूं "मां" संग्रह और उन छोटे संग्रहों में से एक को वापस पाने के लिए जब हर बार विधि को बुलाया जाता है (यह ट्रैक रखना कि कौन सा है), क्या कोई मुझे हाथ दे सकता है?
बहुत बहुत धन्यवाद।
इग्नेसियो

Answer 1

private int runs = 0; 

public void setRunsOneMore() { 
    runs++; 
} 

    public void setRunsOneLess() { 
    runs--; 
} 

public Collection<Comment> getCommentCollection() { 
    commentCollection = movie.getCommentCollection(); 
    Collection[] com = split((List<Comment>) commentCollection,4); 
    try{ 
     return com[runs]; 
    } catch(ArrayIndexOutOfBoundsException e) { 
     runs = 0; 
     } 
    return com[runs]; 
} 

public Collection[] split(List<Comment> list, int size){ 

    int numBatches = (list.size()/size) + 1; 
    Collection[] batches = new Collection[numBatches]; 
    Collection<Comment> set = commentCollection; 

    for(int index = 0; index < numBatches; index++) { 
     int count = index + 1; 
     int fromIndex = Math.max(((count - 1) * size), 0); 
     int toIndex = Math.min((count * size), list.size()); 
     batches[index] = list.subList(fromIndex, toIndex); 
    } 

    return batches; 
} 

वर्तमान अगले & पिछले बटन कार्यों

public String userNext() { 
    userReset(false); 
    getUserPagingInfo().nextPage(); 
    movieController.setRunsOneMore(); 
    return "user_movie_detail"; 
} 

public String userPrev() { 
    userReset(false); 
    getUserPagingInfo().previousPage(); 
    movieController.setRunsOneLess(); 
    return "user_movie_detail"; 
} 

Answer 2

आप Vector.remove (संग्रह), उदाहरण का उपयोग कर सकते हैं:

public Collection<Comment> getCommentCollection() { 
    commentCollection = movie.getCommentCollection(); 
    Vector<Comment> group = new Vector<Comment>(); 
    for (Comment com:commentCollection){ 
     group.add(com); 
    if(group.size() == 4){ 
     break; 
    } 
    } 
    movie.getCommentCollection().remove(commentCollection); 
    return commentCollection; 
} 

movie.getCommentCollection() यह मानते हुए भी एक वेक्टर

Answer 3

है मैं पूरी तरह यकीन नहीं है कि तुम क्या ' फिर से पूछ रहे हैं ... क्या आप उन्हें वापस लौटने से पहले स्रोत Collection से पहले 4 आइटमों को हटाना चाहते हैं, ताकि अगली बार जब आप विधि को कॉल करेंगे तो आपको अगली 4 मिल जाएगी? यदि हां, तो आप सिर्फ इस्तेमाल कर सकते हैं Iterator: ऐसा करने से

Iterator<Comment> iter = commentCollection.iterator(); 
while (iter.hasNext() && group.size() < 4) { 
    group.add(iter.next()); 
    iter.remove(); 
} 

, हालांकि, आप (टिप्पणियों के movie वस्तु के संग्रह को नष्ट होगी, जब तक यह है कि संग्रह के लिए हर बार की एक प्रति देता है, जो मामले में उपरोक्त काम नहीं करेगा)। मुझे लगता है कि आप पेजिंग की तरह कुछ करने की कोशिश कर रहे हैं, इस मामले में मैं आकार 4 के साथ टिप्पणियों के partitioningList की तरह कुछ अलग करने और उस विभाजन सूची में मौजूदा इंडेक्स (पृष्ठ) का ट्रैक रखने का सुझाव दूंगा।

Answer 4

यह सरल है के साथ "रन" की स्थापना: सिर्फ अमरूद से Lists.partition() का उपयोग करें। अगर मैं समझता हूं कि आप सही तरीके से क्या चाहते हैं, तो यह वही है जो यह करता है।

Answer 5

शायद मैं सवाल समझ में नहीं आता है, लेकिन इस सूची का हिस्सा है:

List<E> subList(int fromIndex, int toIndex) 

निर्दिष्ट fromIndex, समावेशी, और toIndex, अनन्य के बीच इस सूची के भाग के एक दृश्य देता है। (यदि इंडेक्स और इंडेक्स से बराबर हैं, तो लौटाई गई सूची खाली है।) लौटाई गई सूची इस सूची द्वारा समर्थित है, इसलिए लौटाई गई सूची में गैर-संरचनात्मक परिवर्तन इस सूची में दिखाई देते हैं, और इसके विपरीत। लौटाई गई सूची इस सूची द्वारा समर्थित सभी वैकल्पिक सूची संचालन का समर्थन करती है।

यह विधि स्पष्ट सीमा संचालन की आवश्यकता को समाप्त करती है (क्रमशः सरणी के लिए मौजूद है)। किसी भी ऑपरेशन को किसी सूची की अपेक्षा करने के लिए एक संपूर्ण सूची के बजाय उपसूची दृश्य पास करके एक श्रेणी संचालन के रूप में उपयोग किया जा सकता है।

list.subList(from, to).clear();

docs.oracle.com/javase/1.5.0/docs/api/java/util/List.html

Answer 6

public static <E extends Object> List<List<E>> split(Collection<E> input, int size) {\n 
    List<List<E>> master = new ArrayList<List<E>>(); 
    if (input != null && input.size() > 0) { 
     List<E> col = new ArrayList<E>(input); 
     boolean done = false; 
     int startIndex = 0; 
     int endIndex = col.size() > size ? size : col.size(); 
     while (!done) { 
      master.add(col.subList(startIndex, endIndex)); 
      if (endIndex == col.size()) { 
       done = true; 
      } 
      else { 
       startIndex = endIndex; 
       endIndex = col.size() > (endIndex + size) ? (endIndex + size) : col.size(); 
      } 
     } 
    } 
    return master; 
}