सीमा समूह में जावा 8

Question

मैं प्रत्येक प्रविष्टि द्वारा समूह को कैसे सीमित कर सकता हूं?

उदाहरण के लिए (: stream groupBy इस उदाहरण के आधार पर):

studentClasses.add(new StudentClass("Kumar", 101, "Intro to Web")); 
studentClasses.add(new StudentClass("White", 102, "Advanced Java")); 
studentClasses.add(new StudentClass("Kumar", 101, "Intro to Cobol")); 
studentClasses.add(new StudentClass("White", 101, "Intro to Web")); 
studentClasses.add(new StudentClass("White", 102, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 106, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 103, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 104, "Advanced Web")); 
studentClasses.add(new StudentClass("Sargent", 105, "Advanced Web")); 

इस विधि सरल समूह वापसी:

Map<String, List<StudentClass>> groupByTeachers = studentClasses 
      .stream().collect(
        Collectors.groupingBy(StudentClass::getTeacher)); 

क्या होगा यदि मैं वापस आ संग्रह सीमित करने के लिए करना चाहते हैं? मान लीजिए कि मैं प्रत्येक शिक्षक के लिए केवल प्रथम एन कक्षा चाहता हूं। यह कैसे किया जा सकता है?

Answer 1

यह संभव होगा कि परिणामी सूची में तत्वों की संख्या सीमित करता है।

यह संग्राहक सूची के प्रमुख तत्वों को बनाए रखेगा (in encounter order)। संग्रह के दौरान सीमा तक पहुंचने पर संचयक और संयोजक प्रत्येक तत्व को फेंक देते हैं। Combiner कोड थोड़ा मुश्किल है लेकिन इसका लाभ यह है कि बाद में फेंकने के लिए कोई अतिरिक्त तत्व जोड़ा नहीं जाता है।

private static <T> Collector<T, ?, List<T>> limitingList(int limit) { 
    return Collector.of(
       ArrayList::new, 
       (l, e) -> { if (l.size() < limit) l.add(e); }, 
       (l1, l2) -> { 
        l1.addAll(l2.subList(0, Math.min(l2.size(), Math.max(0, limit - l1.size())))); 
        return l1; 
       } 
      ); 
} 

और फिर इस तरह इसका इस्तेमाल:

Map<String, List<StudentClass>> groupByTeachers = 
     studentClasses.stream() 
        .collect(groupingBy(
          StudentClass::getTeacher, 
          limitingList(2) 
        )); 

Answer 2

इसके लिए आपको अपने मानचित्र के परिणाम .stream() की आवश्यकता है। आप यह कर कर ऐसा कर सकते हैं:

// Part that comes from your example 
Map<String, List<StudentClass>> groupByTeachers = studentClasses 
      .stream().collect(
        Collectors.groupingBy(StudentClass::getTeacher)); 

// Create a new stream and limit the result 
groupByTeachers = 
    groupByTeachers.entrySet().stream() 
     .limit(N) // The actual limit 
     .collect(Collectors.toMap(
      e -> e.getKey(), 
      e -> e.getValue() 
     )); 

यह ऐसा करने का एक बहुत ही आसान तरीका नहीं है। लेकिन अगर आप प्रारंभिक सूची में .limit(), तो समूह के परिणाम गलत होंगे। सीमा की गारंटी देने का यह सबसे सुरक्षित तरीका है।

संपादित करें:

के रूप में टिप्पणी इस शिक्षक, नहीं प्रति शिक्षक वर्ग की सीमा में कहा गया है। उस मामले में आप कर सकते हैं:

groupByTeachers = 
     groupByTeachers.entrySet().stream() 
      .collect(Collectors.toMap(
       e -> e.getKey(), 
       e -> e.getValue().stream().limit(N).collect(Collectors.toList()) // Limit the classes PER teacher 
      )); 

Answer 3

यह आपको इच्छित परिणाम देना होगा, लेकिन यह अभी भी धारा के सभी तत्वों को categorizes: एक नए कलेक्टर को पेश करने

final int N = 10; 
final HashMap<String, List<StudentClass>> groupByTeachers = 
     studentClasses.stream().collect(
      groupingBy(StudentClass::getTeacher, HashMap::new, 
       collectingAndThen(toList(), list -> list.subList(0, Math.min(list.size(), N))))); 

Answer 4

आप collectingAndThen इस्तेमाल कर सकते हैं, जिसके परिणामस्वरूप सूची पर एक फिनिशर आपरेशन को परिभाषित करने के। इस तरह से आप सीमित कर सकते हैं, फिल्टर, प्रकार, ... सूचियां:

int limit = 2; 

Map<String, List<StudentClass>> groupByTeachers = 
    studentClasses.stream() 
        .collect(
         groupingBy(
          StudentClass::getTeacher, 
          collectingAndThen(
           toList(), 
           l -> l.stream().limit(limit).collect(toList()))));